InícioPortalFAQBuscarMembrosGruposRegistrar-seLogin
Entrem no novo Forum MGB http://planetmaker.forumeiros.com/

Compartilhe | 
 

 [Aula] 7 Aulas de RGSS2

Ver o tópico anterior Ver o tópico seguinte Ir em baixo 
AutorMensagem
PackMan
Experiente [***]


Mensagens Mensagens : 91
Cash Makers Cash Makers : 950

MensagemAssunto: [Aula] 7 Aulas de RGSS2   Sab Ago 15, 2009 2:50 pm

Creditos a Flaepru por criar as aulas...eu soh dei ctrl+c ctrl+v....

Se for dar credito a mim deem soh pq eu dei ctrl+c ctrl+v.....



Olá pessoal! Sejam bem-vindos ao meu tutorial de RGSS2. Com o RPG Maker VX aí e uma certa "decadência" da comunidade maker brasileira, decidi criar este tutorial para ensinar RGSS2 de uma forma fácil e compreensiva. Apesar disto, este tutorial ficou bem extenso, pois é difícil ensinar bem alguma coisa com poucas palavras, mas eu tentei comprimir ao máximo. De qualquer forma, se você for preguiçoso e ter medo de ler mais de 100.000 caracteres, é bom nem começar. o_o
Boa leitura!

Flaepru - flaepru@gmail.com


[SIZE="3"]Agradecimentos[/SIZE]
  • Ao site Ruby-Doc.org, onde pego definições e outras coisas para as aulas.

[SIZE="3"]Índice[/SIZE]

Para acessar as aulas, cliquem nos links da lista. Aulas sem links ainda não estão disponíveis.

Aulas
  1. Introdução: introdução à programação, definição do RGSS2 e observações
  2. Variáveis I: o que são, tipos e definições
  3. Variáveis II: arrays e hashes
  4. Operadores: operadores matemáticos (soma, subtração, etc)
  5. Métodos: definição e usos
  6. Controle de Fluxo I: condicionais (if, case, unless)
  7. Controle de Fluxo II: repetidores (while, until, loop, for)
  8. Classes: o que são e usos
  9. Janelas & Cenas: criando e gerenciando



O que é o RGSS2?
RGSS é a abreviação para Ruby Game Scripting System (Sistema Ruby de Programação de Jogos), uma variante da linguagem Ruby, uma linguagem orientada a objetos muito famosa no oriente. O RGSS2 é uma "evolução" do RGSS e se encontra no RPG Maker VX. Apesar de terem nomes diferentes, basicamente apenas a forma com a qual eles interagem com o maker que muda de um para o outro, a sintaxe é a mesma - logo, este tutorial serve mesmo se você deseja programar para o XP.
Se quiser saber mais sobre a definição do RGSS, clique aqui.

Programação orientada a objetos?
Uma programação orientada a objetos é um paradigma de análise, projeto e programação de sistemas de software baseado na composição e interação entre diversas unidades de software chamadas objetos. Como características de uma POO, podemos citar o uso de classes, objetos, atributos, métodos, herança, abstração, polimorfismo dentre outros. Ruby não é a única POO existente. Existem várias outras: Python, C++, Smalltalk, Java, etc.
(Obs.: nunca chame uma POO de POO em fóruns gringos. :P)

[SIZE="1"]Fonte: Wikipédia[/SIZE]

Como programar?
O ato de "programar" é passar uma série de instruções para o computador com o intuito de que ele realize alguma tarefa. Por exemplo, para fazer uma conta de adição, você usaria:

Código:
a = 1 + 2
print a.to_s

Basicamente o que você fez foi: "o valor de a é igual à soma entre 1 e 2, exiba a transformado em string". Não se preocupe se você não entendeu o código, você entenderá posteriormente.

O RGSS2: primeiros comandos
Ok, está na hora de você aprender as duas coisas mais básicas do RGSS2: comentários e o comando "print".
Eis um exemplo:

Código:
# Exibe "Hello World" na tela
print "Hello World!"

Um código simples e rápido. Cole isso no editor de scripts (em um script novo) ou use o comando "Chamar Script" do editor de eventos. Veja o resultado. Uma caixa de diálogo escrita "Hello World!" apareceu. Simples, não? Esta é a função do print. Você vai usá-lo para verificar dados e notificar erros em caixas de diálogo. Além do print há o comando p, o qual explicarei mais posteriormente.
Mas provavelmente você pode notar que a primeira linha de código foi ignorada. Por quê? Simplesmente porque ela é um comentário. Linhas de código após um # são consideradas comentários.
Além do # para comentários, podemos utilizar =begin =end. Exemplos:

Código:
# Este é um comentário
a = 10 # Comentário - só o que fica depois do # é considerado comentário

=begin
  Utilize esta função para comentários mais longos
=end

Lembre-se de que comentários são úteis ao decorrer do código para explicar as funções e muito mais. Programadores profissionais usam comentários antes de vender seus produtos aos seus clientes, lembre-se disso ^_^

Sumário
No final de cada aula, colocarei um sumário para resumir tudo o que foi aprendido na aula. Dê uma checada e veja se aprendeu tudo mesmo :P


  • O que é o Ruby
  • Conceito de programação orientada a objetos
  • Programa "Hello World!"
  • Comentários e comando print

[ancora=aula2][/ancora]


Bem, aqui está a segunda aula do Guia do RGSS2. Após uma breve introdução ao mundo da programação e ao RGSS2, ensinarei uma das coisas mais importantes em uma linguagem de programação: variáveis.

O que são variáveis?
Assim como na programação por eventos, variáveis são objetos que armazenam atributos. Entretanto, em programação elas podem tanto armazenar números, quanto letras e/ou sentenças inteiras.

Atribuição
Para armazenarmos determinados valores em variáveis, temos que atribuí-los a ela. Para isso, usamos variável - valor. Entenda melhor os valores e variáveis abaixo.
Note que você pode definir uma variável como tendo o valor igual a outra, deixando uma independente da outra - é como se fosse um copiar e colar.

Tipo de variáveis


  • Variáveis locais: variáveis locais são variáveis que podem ser acessadas dentro de um bloco de código ou método.
    Nomenclatura: variáveis locais são nomeadas iniciando-se com uma letra minúscula e sem espaços ou caracteres especiais. Ex.: variavel_local
  • Variáveis de instância: "instância" vem do inglês "instance" e significa "exemplo". Essas variáveis são utilizadas em classes e podem ser acessadas por quaisquer objetos da classe. Você aprenderá a usá-las corretamente e anexá-las às classes na aula 8.
    Nomenclatura: a mesma regra das variáveis locais, mas o nome deve conter um @ antes. Ex.: @variavel_de_instancia
  • Variáveis de classe: são variáveis que devem estar em uma classe, e seus valores são compartilhados por todos os métodos da mesma.
    Nomenclatura: a mesma regra das variáveis locais, mas o nome deve conter dois @ (@@) antes. Ex.: @@variavel_de_classe
  • Variáveis globais: variáveis que podem ser acessadas por qualquer método ou código no jogo inteiro.
    Nomenclatura: a mesma regra das variáveis locais, mas o nome deve conter um $ antes. Ex.: $variavel_global
  • Constantes: como o próprio nome diz, elas têm um valor constante e que não pode ser modificado. Podem ser acessadas por qualquer classe com o escopo correto.
    Nomenclatura: variáveis constantes devem iniciar com uma letra maiúscula, embora a maioria dos programadores as façam inteiras em maiúsculas. Caracteres especiais e espaços não são permitidos. Ex.: CONSTANTE

Tipo de dados

  • String: string são os tipos mais comuns, e servem para armazenar textos. Uma string definida por aspas duplas (" ") ao invés de aspas simples (" ") podem conter comandos especiais de código.
    Definindo uma string: variavel = "String."
  • Numéricos: variáveis que armazenam valores numéricos. Possuem várias ramificações.
    Definindo um valor numérico: variavel = 10
    • Integer: variáveis que armazenam números inteiros. É dividido em Fixnum e Bignum.
      • Fixnum: um Fixnum armazena valores inteiros que podem ser representados em uma palavra em uma máquina nativa (menos 1 bit). Se qualquer operação Fixnum exceder o alcance, o valor é automaticamente convertido para Bignum.
      • Bignum: um Bignum é tratado como uma string de bits de tamanho infinita com duas representações complementares.

    • Float: o dado "float" (flutuante) é equivalente ao conjunto de números reais da matemática, e armazena valores não-inteiros (fracionários).

  • Boolean: talvez o mais simples dos valores: pode ser apenas "true" ou "false" (verdadeiro ou falso).

Conversões
Com o RGSS2, podemos converter os tipos de dados das variáveis, juntamente com o seu valor. Como exemplo, para que você exiba um valor numérico em um print jutamente com strings, ele deve ser convertido para uma string antes disso. Para converter uma variável, digite variavel.to_x, trocando X pelo tipo. Aqui estão os métodos:

  • .to_s: a mais conhecida, converte valores em strings.
  • .to_i: converte valores em integers. O valor é automaticamente classificado como Fixnum ou Bignum.
  • .to_f: converte valores em floats.
  • .to_a: o menos conhecido, usado e relativamente difícil de se manusear. Converte os valores em dados de uma array (que aprenderemos na próxima aula).

Exercícios
Finalmente, prática! :D Em toda aula, haverão exercícios para que você coloque em prática tudo o que aprendeu e, é claro, fazer um pouco mais se desejar! Os dessa aula são:
  • Defina uma variável local sendo uma string de valor "Hello World!" e exiba-a com o comando print.
  • Defina uma variável de instância de valor boleano equivalente a verdadeiro.
  • Defina uma variável global de valor integer com um valor numérico de sua preferência, e depois exiba-a com o comando print.
  • Crie uma string com o valor "50" e exiba-a. Após isso, transforme-a em float, e então exiba-a como string.
Estes exercícios são meio chatos, mas é o que eu consegui criar com esse assunto tão simples (que deu um tópico enorme ._.). Entretanto, em breve os exercícios ficarão legais. :D
Aqui vai uma resolução, para conferir:
Spoiler:
 

Sumário
  • Definição de variável
  • Tipos de variáveis e funções
  • Tipos de dados
  • Conversores de tipos de dados

Por enquanto é só. Próxima aula tem mais. Se tiverem dúvidas, não hesitem em perguntar. Até, galera! \o
Voltar ao Topo Ir em baixo
Ver perfil do usuário
PackMan
Experiente [***]


Mensagens Mensagens : 91
Cash Makers Cash Makers : 950

MensagemAssunto: Re: [Aula] 7 Aulas de RGSS2   Sab Ago 15, 2009 2:51 pm

[ancora=aula3][/ancora]


Bem-vindos à terceira aula do meu guia de programação para o VX. Após ter aprendido sobre variáveis, vocês aprenderão sobre arrays e hashes. Adianto já que elas são potencialmente complexas, mas ajudam muito na hora da programação.
Em programação, arrays e hashes são mais conhecidas como containers (e não é para menos, parecem-se com gavetas :P).

O que são arrays?
Arrays são coleções indexadas e ordenadas de qualquer objeto. Isso significa que ela servem para armazenar múltiplos valores em apenas uma variável, de forma que eles sejam acessados pelos indexadores. O primeiro valor contido em uma array corresponde ao indexador "0", o segundo ao "1" e por assim vai. Entretanto, também é possível fazer isso de forma inversa: "-1" irá acessar o último valor, "-2" irá acessar o penúltimo, e por assim vai.

Definindo uma array
Há dois tipos de arrays: unidimensionais (conhecidas também como vetor/lista) e multidimensionais (conhecidas também como matriz).
Para definir uma array unidimensional, usamos:

Código:
array = ["Valor 1", "Valor 2", "Valor 3"]

Para definir uma array multidimensional, usamos:

Código:
array = [["Valor 1", "Valor 2"], ["Valor 3", "Valor 4"]]

Percebe a semelhança que as arrays têm com os conjuntos matemáticos (S = {1, 2, 3, ...})? Não é tão difícil, afinal.
Se fôssemos definir nossas duas arrays de exemplo graficamente, seria desta forma:



Percebam os números com contorno verde. Eles são os indexadores, e é por eles que acessaremos os dados da array. Perceba também a semelhança da array multidimensional com uma tabela - por causa disso, arrays tinham esse nome antigamente, em linguagens como COBOL.

Acessando valores em uma array
Assim como na definição, para acessar os dados há uma diferença entre as arrays unidimensionais e multidimensionais. Levando em conta as variáveis do exemplo anterior, utilizaríamos isto para o primeiro caso:

Código:
array = ["Valor 1", "Valor 2", "Valor 3"]
print array[0]

Coloque este código com o comando "Chamar script" dos eventos. Vejam o resultado: uma janelinha escrita "Valor 1", não? Exato. O que você fez, como exemplificado anteriormente, foi acessar o valor (Valor 1) do primeiro indexador (0). Agora, para uma array multidimensional:

Código:
array = [["Valor 1", "Valor 2"], ["Valor 3", "Valor 4"]]
print array[0][0]
print array[1][0]

O que aconteceu aqui? Para definir qual valor acessamos, primeiro precisamos definir qual é o "conjunto" em que ele está contido, e colocamos o indexador dela no primeiro colchete. No segundo, definimos qual será o valor do conjunto a ser exibido, utilizando o indexador.
Veja que primeiro nós colocamos 0 e 0, ou seja, abrir o primeiro conjunto e seu primeiro valor. Após isso, abrimos o segundo conjunto e seu primeiro valor.
Outra coisa: quando tentamos acessar um indexador sem valor numa array, seu retorno é "nil" (nulo).
Assim, terminamos as arrays.

O que são hashes?
Uma hash é uma coleção de pares de valores. É similar a uma array em todos os sentidos, exceto pelo fato de que a indexação é feita por meio de chaves arbitrárias de qualquer tipo, e não apenas por indexadores inteiros pré-definidos.

Definindo uma hash
Para definir uma hash, usamos chave => valor. Desta forma:

Código:
hash = {1 => "Um", 2 => "Dois"}

Assim como em arrays, podemos definir uma hash multidimensional:

Código:
hash = {"numerais" => [1,2,3], "escritos" => ["Um", "Dois", "Três"]}

Vê? Basicamente a mesma coisa que as arrays.
Ah, lembrem-se: colocar uma hash com dois valores (ex.: {1, 2}) irá atribuir o segundo valor ao primeiro, que será a chave. Entretanto, quando você coloca um número ímpar de chaves/valores, haverá um erro de código.

Acessando valores em uma hash
Primeiramente, iremos acessar a nossa primeira hash exemplificada, unidimensional:

Código:
hash = {1 => "Um", 2 => "Dois"}
print hash[1]
print hash[2]

Qual foi o resultado? Primeiro, foi exibido "Um" na tela, e depois "Dois", correto?
Isso aconteceu porque a chave "1" está ligada ao valor "Um", e quando você a acessa, seu valor é apresentado. O mesmo acontece com a chave "2". Veja outro exemplo:

Código:
hash = {"pesquisa" => "Google", "email" => "Gmail"}
print hash["pesquisa"]
print hash["email"]

Primeiro, o resultado foi "Google" e depois "Gmail". Fizemos a mesma coisa, a diferença era que nesse caso as chaves eram strings (por isso estarem entre aspas, se não seriam consideradas código).
Agora, em uma hash multidimensional:

Código:
hash = {"numerais" => [1,2,3], "escritos" => ["Um", "Dois", "Três"]}
print hash["numerais"][1]
print hash["escritos"][3]

O que apareceu? Primeiro, "2". Por que isso? Ao acessarmos um valor em um conjunto, usamos a indexação automática igual às variáveis, logo, seguimos a regra de iniciar no 0. Depois, apareceu "nil", correto? Significa "nulo". O quarto valor (representado pelo 3) não existe no conjunto "escritos".

Observações
Arrays são definidas com colchetes ([]) e hashes com chaves ({}), entretanto quando acessamos o valor de qualquer uma delas usamos os colchetes. Conjuntos de uma hash multidimensional também são definidos com colchetes.

Exercícios
Continuando, irei colocar alguns exercícios aqui para ver se vocês realmente aprenderam sobre o assunto.
  • Crie uma array unidimensional com 4 valores quaisquer e exiba o último sem usar o método -1.
  • Crie uma array multidimensional com dois conjuntos em três membros em cada conjunto, e exiba o terceiro valor do segundo conjunto.
  • Crie uma hash unidimensional com dois pares chave/valor, e acesse qualquer um deles.
  • Crie uma hash multidimensional com dois conjuntos: um dos makers sem RGSS e outro dos makers com RGSS, e exiba qualquer um dos valores.

Resolução:
Spoiler:
 
Sumário
  • O que são arrays e hashes
  • Definindo uma array e uma hash
  • Unidimensionalidade e multidimensionalidade
  • Acessando valores em uma array e hash

Sim, eu sei. O tópico ficou realmente grande. Mas espero que vocês tenham entendido tudo certinho o_o
Até a próxima aula, galera \o/

[ancora=aula4][/ancora]


Olá pessoal! Faz já um certo tempo que eu não adiciono novas aulas, mas finalmente a quarta aula do nosso guia chegou. Aqui, iremos abordar coisas bastante utilizadas em RGSS2: operadores. Vamos lá então!

O que são operadores?
No RGSS2, os operadores têm praticamente a mesma função que na matemática: realizar operações entre dois ou mais termos, e não apenas números - pelo contrário, vão muito além disso.
Aqui está uma lista com os operadores do RGSS2 (com a exceção de alguns, que ensinarei nas aulas de controle de fluxo). Não se preocupe se eles são muitos e parecem assustadores, vários deles serão ignorados por você.



Note que alguns operadores significam a mesma coisa, como o "and" e o "&&", que significam "e".

Utilizando operadores
Utilize o editor de scripts ou o comando Chamar script para testar o seguinte código:

Código:
# Definição das variáveis
a = 4
b = 2

# Operações
print a + b            # 6 (a mais b)
print a - b            # 2 (a menos b)
print b - a            # -2 (b menos a)
print a * b            # 8 (a vezes b)
print a ** b          # 16 (a elevado a b)
print a / b            # 2 (a dividido por b)
print b.to_f / a.to_f  # 0.5 (b real dividido por a real)
print (a + 1) % 2      # 1 (a mais um - dividir por dois e retornar o resto)

# Usando operadores nas strings
print a.to_s + b.to_s    # 42
str1 = "Tutorial"
str2 = "RGSS2"
print str1 + " " + str2  # Tutorial RGSS2

# Verificações
print 1 == 2              # false (um é igual a dois)
print 1 < 2              # true (um é menor que dois)
print str1 == "Tutorial"  # true (variável str1 contém "Tutorial"
print 1 != 10            # true (um é diferente que dez)

# Atribuições
var = 10    # Atribuição comum
print var  # 10
var += 5    # Adicionar cinco ao valor da variável
print var  # 15
var -= 3    # Subtrair três do valor da variável
print var  # 12

Veja o resultado de cada um deles. É auto-explicativo. + soma dois valores numéricos ou dois valores strings. - subtrai valores numéricos. * multiplica valores numéricos. ** eleva um número à potência do outro. / divide um número por outro. Os outros, basta olhar na tabela para testar seu funcionamento.

Observações
Um dos erros mais comuns em programação é confundir = com ==. Eles são completamente diferentes. O = significa atribuição, e não igualdade. O operador que representa igualdade é o == e o === representa "contém no range" (verão mais posteriormente).

Sumário

  • O que são operadores
  • Lista de operadores
  • Utilização de alguns operadores

Bom, galera, é isso. Essa aula não tem exercícios, porque sinceramente, esse assunto é tão simples que foi muito complicado de se explicar e rendeu uma aula curtíssima. O máximo que eu colocaria era mandar vocês fazerem contas do primário :icon_rolleyes: De qualquer forma, boa sorte nas próximas aulas. Até mais!

[ancora=aula5][/ancora]


Sejam bem-vindos à quinta aula do guia do RGSS2. Vejam só, já passamos da metade! Aqui, abordaremos coisas muito úteis e que são essenciais no RPG Maker: métodos.

O que são métodos?
Métodos não são nada mais, nada menos que um bloco de código pré-definido que pode ser acessado várias vezes, de forma igual ou diferente. Um exemplo de seu uso seria isso: você tem que realizar uma operação de báskara, por exemplo, que é deveras comprida. Ao invés de escrever o código várias vezes, chamaríamos o código já escrito várias vezes.
Uma curiosidade: as classes são feitas apenas por métodos.

Definindo e acessando um método
Para definir um método que exibisse um "Hello World" na tela, simplesmente usaríamos:

Código:
def Metodo
  print "Hello World"
end

E, logo depois, para acessá-lo, usaríamos:

Código:
Metodo()

Por que temos que utilizar parênteses? Nesse caso, utilizamos parênteses vazios porque não há nenhum valor específico necessário para este método. Sem os parênteses, o interpretador viria o comando como uma constante. Agora, teste o seguinte:

Código:
def Metodo(x, y)
  print x + y
end

Metodo(1, 3)
Metodo(4, 1)

Vejam o resultado. "4" e "5". Isso porque o método exige que as variáveis locais x e y sejam declaradas, para então fazer uma operação de adição entre os valores. Imagine isso em processos repetitivos e/ou automáticos, o quanto que facilita :icon_cool:
Uma coisa que é comum é utilizar variáveis de instância, principalmente quando os métodos são utilizados em classes:

Código:
def Metodo(x, y)
  @x = x
  @y = y
  print @x + @y
end

Metodo(1, 2)

Redefinição e alias
Em n casos você pode precisar re-escrever o seu método, mudar o código contido nele, ou simplesmente acrescentar. Para isso, há duas maneiras: redefinição e alias.
A redefinição é simples: basicamente, o método inteiro é apagado e o novo código é colocado em seu lugar.

Código:
# Definição do método
def Metodo(x, y)
  print x + y
end

Metodo(1, 2)  # 3

def Metodo(z)
  print "Agora exibe isso e " + z.to_s
end

Metodo(9)    # Agora exibe isso e 9

Agora, o comando que realmente é importante é o comando alias. Podem parecer um pouco complicados, mas são simples. Alias, em inglês, significa "nome falso", e é basicamente isso! Com o método alias, você renomeia um método, coloca o código existente nele e adiciona o novo ao novo método, com o nome antigo. A sintaxe é alias NomeNovo NomeAntigo. Um exemplo prático:

Código:
# Define um método com o nome "MetodoNormal"
def MetodoNormal
  print "Mostrando o método \"MetodoNormal\""
end

# Exibe o conteúdo do método "MetodoNormal"
MetodoNormal()  # Mostrando o método "MetodoNormal"

# Fazer o alias
# Jogar todo o código existente no método "MetodoNormal" no novo método
# "NovoMetodoNormal", e redefinir o método "MetodoNormal" com um código novo.
alias NovoMetodoNormal MetodoNormal
def MetodoNormal
  print "Esse é o novo \"MetodoNormal\""
end

MetodoNormal()      # Esse é o novo "MetodoNormal"
NovoMetodoNormal()  # Mostrando o método "MetodoNormal"

E pronto! Acontece o que está descrito nos comentários. Ah, é comum utilizar o alias para redefinições também - para isso, você chama o método de novo nome dentro do método de nome antigo com código novo (vide o VX_SP1, no Editor de scripts).

Curiosidades
print, p e loop são alguns dos métodos que já vêm criados no maker. Perceba que eles não têm coloração. :icon_lol:

Observações
Os métodos seguem a mesma regra de nomenclatura que as variáveis - nada de caracteres especiais, nem espaços. Ah, palavras reservadas (def, begin, etc) são proibidas.

Exercícios
  • Crie o método X, renomeie-o para Y e coloque um código novo em X, fazendo com que ele chame Y.
  • Crie um método X, ative-o, reescreva-o e ative-o novamente.

Resolução:
Spoiler:
 
Sumário
  • O que são métodos
  • Utilização dos métodos
  • Redefinição e alias

E aqui terminam a aula sobre os métodos. Vocês terão uma abordagem com eles novamente na aula sobre classes, pois como disse, elas são formadas apenas de métodos. Dêem sugestões para possíveis melhorias nas aulas! :icon_biggrin: Até a próxima!
Voltar ao Topo Ir em baixo
Ver perfil do usuário
PackMan
Experiente [***]


Mensagens Mensagens : 91
Cash Makers Cash Makers : 950

MensagemAssunto: Re: [Aula] 7 Aulas de RGSS2   Sab Ago 15, 2009 2:52 pm

[ancora=aula6][/ancora]


Olá novamente e bem-vindos à sexta aula do meu tutorial de RGSS2, que irá ensiná-los a controlar o fluxo do programa! Nesta aula, aprenderemos algo muito importante, e talvez até um pouco familiar a vocês: condicionais!

O que são condicionais?
Uma estrutura condicional é uma estrutura que avalia uma certa coisa, e dependendo do que for, exibe um resultado diferente. Condicionais são conhecidas por vocês: elas são praticamente iguais às usadas nos eventos do maker.
Os operadores (aprendidos na aula 4) são usados intensivamente aqui.

Os tipos de condicionais: if
O tipo mais comum de condicionais é a que usa a função "if". Um exemplo de avaliação com um bloco de condição cumprida e outro de exceção, igual ao maker:

Código:
var = 9

if var < 10 then
  print "O valor é menor que 10."
else
  print "O valor não é menor que 10."
end

Lendo o código, teríamos: Se o valor da variável "var" for menor que 10, exiba "O valor é menor que 10.", se não, exiba "O valor não é menor que 10.". Perceba nesse código o uso do operador que representa "é menor que", o <. Em eventos, este bloco de código se pareceria com isso:



Bem, o que você fez foi criar uma condicional semelhante à do RPG Maker, mas agora aprenderá como criar uma condicional com várias opções de ocorrências. Veja o código:

Código:
idade = 14

if idade == 0
  print "Você ainda nem nasceu direito!"
elsif idade < 12
  print "Você é uma criança!"
elsif idade < 18
  print "Você é um adolescente!"
elsif idade < 120
  print "Você é um adulto!"
else
  print "Tão velho assim?!"
end

Vejam só: para cada caso, há uma resposta. Mas veja que 14 é menor que 18 e que 120, mas a condição aceita é a primeira que for cumprida - ou seja, assim que a condição é cumprida, o resto do if é ignorado, não importa quantas outras opções hajam. Se nenhuma das opções são cumpridas, cai no else. Se não há else, o bloco de código é ignorado.
Evidentemente, é possível fazer como no RPG Maker e colocar vários ifs separados para agirem desta forma.

Outra forma bastante comum é de utilizar o if em conjunto com "and" e/ou "or" para avaliar mais de uma afirmação. Veja os seguintes exemplos:

Código:
var1 = 10
var2 = 15

if var1 and var2 == 10
  print "As duas variáveis possuem o mesmo valor."
else
  print "Uma variável tem o valor de " + var1.to_s + " e a outra de " + var2.to_s + "."
end

if var1 or var2 == 10
  print "Alguma das duas variáveis possui o valor de 10."
else
  print "Nenhuma das duas variáveis possui o valor de 10."
end

Vejam: no primeiro exemplo, os dois valores devem ser iguais a 10, cada um. Já no segundo, apenas um deles deve ser igual a 10 para que a condição seja satisfeita. Ah, perceba que você pode trocar o "and" por "&&" e o "or" por "||" (vejam a lista de operadores da aula 4).

Um outro exemplo utilizando o operador "===", que poucos de vocês conhecem e provavelmente usarão, mas eis o exemplo:

Código:
variavel = 10
print (5..15) === variavel
print (15..20) === variavel

O operador "===", como eu disse antes, significa "contém no range", e o range, no caso, é definido pelo operador "..". Notem que foi preciso colocar o valor entre parênteses pois temos mais de um operando.

Os tipos de condicionais: case
Quando você tiver a necessidade de fazer uma condição com vários valores de uma forma fácil, na melhor do que usar os "cases", ou como são chamados em outras linguagens de programação, "switches". Ah, notem que não são os switches do maker, é uma coisa completamente diferente :P

Estudemos o seguinte código para entendê-los:

Código:
variavel = 35

case variavel
  when 10
    print "O valor da variável é 10."
  when 35
    print"O valor da variável é 35."
  when 40..50
    print "O valor da variável está entre 40 e 50."
  else
    print "O valor da variável é outro."
end

Percebem a semelhança com os ifs? O case é nada mais do que vários elsifs juntos, e também possui a função else para quando o valor não é encontrado. Notem que aqui ocorre o mesmo que nos ifs, onde quando o valor é satisfeito, qualquer condição satisfeita após aquilo na mesma estrutura é ignorada.

Os tipos de condicionais: unless
O último tipo de condicional, o unless é o oposto do if, e significa "a menos que", ou de uma forma mais prática, "pode ser tudo menos isso". Eles às vezes confundem um pouco mesmo. Estudemos o seguinte código:

Código:
var = 15

unless var == 10
  print "A variável tem um valor diferente de 10."
else
  print "A variável tem um valor igual a 10."
end

Leiam o código como o seguinte: "pode ser qualquer coisa, menos 10". No caso, não era 10, então o respectivo comando foi acessado.

Basicamente, é isso que vocês têm que saber sobre as condicionais.

Observações
Lembrem-se sempre de que o sinal de verificação de igualdade não é o =, é o ==. Isso já foi dito, mas nunca é muito lembrar deste detalhe. = significa "atribuição", enquanto == significa "igualdade".

Curiosidades
"if", "then" e os outros são operadores, os quais eu não coloquei na aula 4 pois seriam vistos aqui. Vocês têm total liberdade de usar qualquer um dos operadores nas condicionais.

Exercícios
  • Defina uma variável com valor qualquer, e crie uma estrutura condicional if verificando o seu valor e mostrando resultados diferentes
  • Faça o mesmo que no exercício anterior, mas com switches

Resolução:
Spoiler:
 
Sumário
  • Estrutura condicional "if"
  • Estrutura condicional "case"
  • Estrutura condicional "unless"
  • Uso de operadores no controle do fluxo via condicionais

Bom, essa foi a primeira aula de controle de fluxo, sobre as condicionais. Logo, logo teremos a aula sobre as estruturas repetidoras de fluxo, que são bem interessantes - e às vezes perigosas ^^' Até mais!

[ancora=aula7][/ancora]


Depois de um certo tempo grande de espera, trago a vocês a sétima aula do meu tutorial de RGSS2, e a segunda de controle de fluxo. Aqui, aprenderemos a utilizar os repetidores!

O que são estruturas repetidoras?
São estruturas que permitem que você repita a mesma parte de código por várias vezes, de acordo com a sua vontade. Os repetidores são utilizados freqüentemente os programadores e ajudam na hora de programar, deixando o código mais curto e mais fácil de se escrever.

Estrutura repetidora: loop
Bem, comecemos pela estrutura de repetição mais básica: o loop. O loop permite que você cria um bloco de código que será repetido eternamente. Veja o exemplo (não cole-o no maker XD):

Código:
var = 1
loop do
  print var
  var += 1
end

Se você utilizar este código no maker, ele simplesmente ficará exibindo janelas eternamente com valores diferentes por um. Mas podemos quebrar o loop a qualquer hora, desta forma:

Código:
var = 1
loop do
  print var
  if var == 10
    break
  else
    var += 1
  end
end

Basicamente, este código irá avaliar toda vez se a variável possui o valor de 10. Se possuir, ela chama o comando "break" (quebrar), que rompe o loop. Se não, adiciona o valor 1 à variável, e volta tudo ao começo.
Percebam como os loops são semelhantes aos "Ciclos" do RPG Maker :icon_biggrin:

Estrutura repetidora: while
Uma das estruturas que mais me agrada, é o while, que em português pode ser traduzida como "enquanto". Lembram-se do segundo código mostrado no loop? Podemos encurtá-lo desta forma:

Código:
var = 1
while var <= 10
  print var
  var += 1
end

Podemos ler este código como: "enquanto o valor da variável for menor ou igual a 10, exiba o valor da variável e adicione 1 ao seu valor". Percebam como é útil. Podemos utilizar isso para várias coisas, vai de acordo com a necessidade.

Estrutura repetidora: until
O until, em português, significa "até que". Percebam como aquele mesmo código seria escrito utilizando a estrutura until:

Código:
var = 1
until var == 11
  print var
  var += 1
end

Percebam uma diferença: o número que eu utilizei como máximo é o 11. Mas por quê? Neste caso, ele romperá o repetidor quando for igual, e no caso, após exibirmos o valor 10, a variável ganhou valor 11 e o until foi quebrado. Vejam este outro exemplo:

Código:
var = 1
until var > 10
  print var
  var += 1
end

Este bloco de código segue a mesma lógica. "Realize a repetição até que o valor da variável seja maior que 10".

Estrutura repetidora: for
O for é uma estrutura repetidora que se diferencia das outras, pois aqui você define quantas repetições haverão de uma forma mais fácil, e na hora de escrever. O mesmo código, aqui, seria escrito assim:

Código:
for i in 1..10
  print i
end

Com esse código dizemos "repita o código enquanto i estiver de 1 a 10", ou, literalmente, "para cada i de 1 a 10". Com isso, dizemos que o valor inicial de i é 1 e o código será quebrado quando este valor atingir 10. Percebam também que o valor do i é automaticamente atribuído cada vez que o repetidor é iniciado. Utilizamos i como variável, por este ser o padrão, mas podemos fazer várias mudanças neste código:

Código:
x = 5
y = 15
for z in x..y
  print z
end

Percebam a flexibilidade do comando. Ele é, inclusive, muito utilizado em arrays. Sim, vejam:

Código:
array = ["1º Valor", "2º Valor", "3º Valor", "4º Valor"]
for i in 0..array.length - 1
  print array[i]
end

Aqui utilizei uma propriedade provavelmente desconhecida por vocês, o comando "length" da array. Ele retorna o número de valores armazenados por ela - entretanto, ele começa a contar do 1, logo, é necessário reduzir 1 do valor para que fique igual aos indexadores, e possamos exibi-los.

Exercícios
  • Crie um loop que exiba o valor da variável x adicione 1 ao valor desta mesma variável "por rodada" e rompa-o quando este valor for igual a 15.
  • Crie um while que exiba o valor da variável y e adicione 1 ao seu valor "por rodada" até que seu valor seja 10.
  • Crie um for que vá desde o valor de y até 20, e exiba o valor da variável "por rodada".

Resolução:
Spoiler:
 
Sumário
  • Estrutura repetidora loop
  • Estrutura repetidora while
  • Estrutura repetidora until
  • Estrutura repetidora for

Bem, aqui termina a segunda aula sobre controle de fluxo. Espero que ela tenha ficado tão boa como as outras (como dizem ^^'). Vou tentar lançar a próxima aula ainda neste mês e, quem sabe, a última também. Até mais, pessoal!
Voltar ao Topo Ir em baixo
Ver perfil do usuário
°thiago°
Administrador


Mensagens Mensagens : 327
Cash Makers Cash Makers : 1210

MensagemAssunto: Re: [Aula] 7 Aulas de RGSS2   Sab Ago 15, 2009 8:27 pm

Hum... exelente tuto de RGSS2
Parabens! Muito bem explicado
Vou deixar as letras miudas como tão, porque você pois os creditos ao criador no titilo.
xP

_________________________________________________


Which Final Fantasy Character Are You?
Final Fantasy 7

Voltar ao Topo Ir em baixo
Ver perfil do usuário
Trasgo@01254
Coordenador Maker


Mensagens Mensagens : 426
Cash Makers Cash Makers : 723

MensagemAssunto: Re: [Aula] 7 Aulas de RGSS2   Sex Ago 28, 2009 7:30 pm

Cara, não vou ler agora pois estou sem tempo, mais nunca vi aulas tão completas, mais já salvei no meu PC para ler depois, valeu!
Voltar ao Topo Ir em baixo
Ver perfil do usuário
Jorge Guerra
Experiente [***]


Mensagens Mensagens : 52
Cash Makers Cash Makers : 445

MensagemAssunto: Re: [Aula] 7 Aulas de RGSS2   Sab Ago 29, 2009 9:29 am

Foi com esse tuto dele que aprendi a maioria das coisas que sei hoje sobre RGSS2 (Variáveis, condições,etc.), porém acho que você deveria mover o tópico para "Aulas de RGSS1/RGSS2" já que tive a idéia dela para isso...

Vlws
Voltar ao Topo Ir em baixo
Ver perfil do usuário
lz-leo
Super Maker [******]


Mensagens Mensagens : 604
Cash Makers Cash Makers : 895

MensagemAssunto: Re: [Aula] 7 Aulas de RGSS2   Seg Set 14, 2009 9:07 pm

Tuto monstruoso e eficaz,pena que não tenho jeito em Scripts,Obrigado aew Jorge.
Voltar ao Topo Ir em baixo
Ver perfil do usuário
Conteúdo patrocinado




MensagemAssunto: Re: [Aula] 7 Aulas de RGSS2   Hoje à(s) 7:17 pm

Voltar ao Topo Ir em baixo
 
[Aula] 7 Aulas de RGSS2
Ver o tópico anterior Ver o tópico seguinte Voltar ao Topo 
Página 1 de 1
 Tópicos similares
-
» [Iniciante][Video-Aula][ON]Video aula sign completa no ps, e animada no flash !
» [Video-Aula] Sign GFX Clean
» Criação de sprites por Joton (Vídeo-Aula 1)
» [Aula] Array e Matriz em GML
» Game Maker - Aula 9 - Instrução While

Permissão deste fórum:Você não pode responder aos tópicos neste fórum
 :: Centro Maker :: Curso de RGSS/RGSS2 :: Aulas de RGSS2-
Ir para: