[Aula-RGSS]Elementos de Programação RGSS

[Akina]

Não acredito que eu achei uma aula tão boa, e resolvi disponibiliza-la para vocês! Então espero que gostem.

Elementos de Programação RGSS

Créditos a: Thiago Farenheith.

Descrição

Pessoal, neste tópico farei uma exposição de alguns termos comumente usados em programação. Para quem quiser aprender RGSS, conhecer um pouco sobre estes conceitos é indispensável. Não é intuito deste tópico abordar questões de lógica de programação, mas sim introduzir alguns detalhes elementares com exemplos de aplicações no próprio RGSS.

Introdução

A princípio, talvez nem fosse necessário dizer isso, mas programação, em seu nível mais básico, nada mais é do que dispor uma série de comandos com funcionalidades específicas a fim de obter um resultado. Esse é o tipo de coisa que todos tem costume de fazer... para ilustrar isso no dia-a-dia, escovar os dentes é um tipo de programação. Afinal, você executa uma série de passos, ordenadamente, (pega a escova, pega a pasta, coloca um pouco de pasta na escova, molha a escova... etc) a fim de obter um resutado final. Na programação é a mesma coisa, mas os comandos têm uma forma mais rígida e é necessário conhecer a sintaxe para poder usá-los e compreendê-los. Com o decorrer deste tópico, darei alguns exemplos tirados do próprio RGSS. Também é importante dizer que usaremos com frequência a palavra método. Em um outro tópico darei mais detalhes sobre este termo, mas neste, direi apenas que método é todo o bloco de código, feito dentro de uma classe, que é declarado com a cláusula def... por exemplo:

Código:

def initialize

  .
  .
 (aqui tem um monte de código)
  .
  .
end

Tais métodos determinam um certo procedimento da classe, que pode ser ativado por uma chamada, isto é, usando o próprio nome do método. Por exemplo, temos um método chamado move_forward visível na classe Game_Player. Ele serve para mover o personagem para frente.
Ou seja, se, por exemplo, abrirmos o comando chamar script em algum evento de mapa e colocarmos o seguinte código:

Código:

$game_player.move_forward

Nosso herói irá andar um tile para frente quando este evento for executado. Exemplos mais interessantes serão dados quando algumas outras coisas forem explicadas.

Variáveis e visibilidade

Primeiramente, variável é um armazenador, um termo que representa um valor. Você pode atribuir valores diversos a uma variável e inclusive pode usá-la em operações. Por exemplo:

Código:

 
    @id = 0
    @x = 0
    @y = 0

Este código foi tirado da classe Game_Character, no método initialize. Neste trecho, vê-se três variáveis: @id, que se refere a um código de identificação do personagem. @x, que é a coordenada x do personagem e @y que é a coordenada y. Vemos que as três variáveis receberam o valor 0. Temos também um pequeno trecho onde vemos a variável @y ter seu valor modificado:

Código:

@y += 1

Este treco também poderia ser escrito assim:

Código:

@y = @y + 1

Ele foi tirado de um método chamado move_down, que serva para mover um evento para baixo. Quando um evento é movido para baixo, sua coordenada y aumenta em 1, e é exatamente isso o que ocorre neste trecho de exemplo. As duas formas de serem escritas são equivalentes.
Olhando para a segunda, suponhamos que, antes deste código ser executado, o personagem
estava numa posição onde o @y valia 10. Ora, 10 + 1 é 11. Então, dizer @y = @y + 1, neste caso,
equivale a @y = 10 + 1. Notem um pequeno detalhe: para o @y à direita do =, eu considero o valor,
para o da esquerda, eu considero a variável. Isso por que o = serve exatamente para pegar o valor
à direita dele e atribuí-lo à variável da esquerda. @y += 1 é apenas uma maneira resumida de se escrever
o que acabou de ser explicado. Um outro exemplo podemos montar assim:

Código:

@y = @y*3

Dessa vez, estamos dizendo que o @y vai receber o seu valor antigo multiplicado por três. Logo, se antes @y valia 11, com a execução deste código passa a vale 33. Agora, vamos super que um personagem está na posição (3, 10) do mapa, isto é, coordenada x = 3 e coordenada y = 10. Então, se executarmos este código:

Código:

@x = @x + @y

@x passará a valer a soma do antigo valor de @x com o do @y, isto é, 3 + 10 = 13.
Agora, entendendo o que é variável, temos que entender também o que é visibilidade. Reparem que as variáveis que usamos começam com @. Isso significa que o valor dela está acessível em qualquer lugar da classe na qual ela foi declarada. Estes são exemplos da classe Game_Character, logo, em qualquer método da Game_Character eu posso recorrer a estas variáveis. Se, por exemplo, eu declarasse-as sem o @, elas só seriam visíveis dentro do próprio método na qual foram declaradas. Outro símbolo útil é o $. Se a variável começar com $ (por exemplo, $game_player), eu poderei acessar ela de qualquer lugar. É a chamada variável global.
Mais detalhes sobre isso postarei em um próximo tutorial, quando falarmos de Orientação a Objetos.
Por fim, é valido dizer que, quando uma variável ainda não foi inicializada ou declarada, o RGSS considera que seu valor é nil (nulo). Portanto, se eu chamasse @x em qualquer outra classe, o mínimo que aconteceria era retornar nil.

Estruturas condicionais (if, unless, case)

Uma das coisas mais usadas em programação são as condicionais. Quem já mexeu com eventos já deve estar familiarizado com condicionais mas, para quem ainda não está, condicional é um bloco de código que só é executado se certa condição for atendida. Como praticamente todo bloco de código em Ruby, as condicionais são iniciadas de uma maneira distintas mas são encerradas sempre pela palavra “end”.
Começaremos dando um exemplo do mais simples entre eles, o condicional if:

Código:

if self.guarding?
          self.damage /= 2
        end

Esse código foi retirado do método attack_effect da classe Game_Battler, que serve para processar um ataque sofrido pelo batalhante. Encontramos neste exemplo ainda uma chamada para um outro método desta classe: guarding?, que retorna se o batalhante está defendendo ou não. Agora, damage é uma propriedade, uma variável desta classe que contém o dano sofrido pelo batalhante. Apesar de damage ser visível em toda a classe, não estamos usando @ para iniciar seu nome, mas sim self. Igualmente o método guarding?, e isso tem uma diferença conceitual que não será abordada neste momento. Neste caso em particular, @damage também seria aplicável.
Repare que o código self.damage /= 2, é muito semelhante ao exemplo de operação dado anteriormente, @y += 1, a diferença é que a operação em questão é divisão ( / ) e não soma. Portanto, igualmente no exemplo anterior, este código é equivalente a:
self.damage = self.damage / 2
Enfim, sabendo de tudo isso, podemos entender exatamente o que o trecho está dizendo:

Código:

se o batalhante estiver defendendo,
          Divida o dano sofrido por 2

Um pouco de conhecimento do significado dos termos usados também é útil nestes casos, já que “if” é “se” em inglês. De qualquer forma, imagino que tenha ficado clara a sintaxe utilizada neste comando:

Código:

if (condição)
    (comandos)
end

Podemos usar também uma cláusula dentro do comando if onde discriminamos o que vai acontecer se a condição não for atendida: a cláusula else (senão). A sintaxe seria essa:

Código:

if (condição)
    (comandos1)
else
    (comandos2)
end

Por fim, ainda há a possibilidade de usar ifs encadeados da seguinte maneira:

Código:


if (condição1)
    (comandos1)
elsif  (condicao2)
    (comandos2)
elsif  (condicao3)
    (comandos3)
elsif  (condicao4)
    (comandos4)
...
end

No caso, a primeira condição é testada. Se for verdadeira, comandos1 é executado. Se for falsa, a condicao2 é testada. Caso esta seja verdadeira comandos2 é executado e, caso seja falsa, a condicao3 é testada. Esse processo continua até que uma das condições na cadeia de ifs seja verdadeira ou até que todas as condições sejam testadas. O que podemos saber, a princípio, é que no máximo um dos blocos de comandos será executado. Pode acontecer de nenhuma condição ser verdadeira e nada ser feito mas, mesmo que várias condições destas sejam verdadeiras, apenas a primeira que for testada e der certo encadeará a execução dos comandos do bloco. As demais sequer serão testadas pois a execução da cadeia de ifs se dará por encerrada.

Um condicional muito semelhante ao if é o unless. Esta palavra significa “a não ser que”, portanto, o condicional unless é exatamente o oposto do if: quando a condição não for atendida, o comando é executado. Por exemplo:

Código:

unless @state_changed
          self.damage = "Miss"
        end

Este código também foi retirado da classe Game_Battler, mas do método skill_effect. Este método determina o que acontece quando o personagem é atingido por uma magia. Em particular este trecho controla um detalhe do que acontece com o personagem quando ele é atingido por uma magia que apenas muda o status. No caso, @state_changed é verdadeiro se houve alguma mudança de status devido à magia, e este trecho diz o seguinte:

Código:

A não ser que os status se modificaram, mostre a mensagem “Miss” sobre o personagem

Portanto, a sintaxe para o condicional unless é a seguinte:

Código:

unless (condição)
  comandos
end

Ao contrario do if, não existe outras variações para este condicional.
Falta apenas falarmos do condicional “case”. Todavia, antes de falarmos dele, falaremos um pouco dos operadores condicionais. Estes servem para montar as condições que regem os blocos if e unless além de outras coisas. Todo operador condicional retorna um resultado (true ou false, verdadeiro ou falso). Há condições que dispensam o uso de operadores, por exemplo, as condições que usam métodos que já retornam um valor lógico (verdadeiro ou falso) ou uma variável que já possua em si um valor lógico, como são os casos dos exemplos usados acima.
Mostraremos, então, os operadores mais comuns:

== (duplo igual): este operador determina se uma expressão é exatamente igual a outra. Ele pode ser usado com praticamente qualquer tipo de informação. Repare que = é atribuição de valor, não comparação, enquanto == sim, é comparação;
>= (maior ou igual): Retorna true se o valor da esquerda é maior ou igual o da direita e false se não for. Pode ser usados com diversos tipos de valor, o mais comum é o numérico;
<= (menor ou igual): Análogo ao de cima;
> (maior): Análogo ao de cima;
< (menor): Análogo ao de cima;
!= (não igual ou diferente): exatamente o contrário do ==. Este retorna true se dois valores são diferentes.
! (negação): Inverte um valor lógico. Por exemplo se eu tomar a condição (self.hp == self.maxhp), utilizável na classe Game_Battler, ela retornará verdadeiro se o hp do personagem estiver completo, isto é, igual ao máximo. Agora se eu colocar ! logo antes dela, desse jeito:
! (self.hp == self.maxhp), então o valor lógico é invertido, essa expressão retornará false caso o hp estiver cheio.

Podemos montar diversos tipos de condições com esses operadores. Temos ainda outros operadores lógicos, como o and (e), o or (ou), e os operadores associativos, que são os parênteses. No entanto, seria mais apropriado falar destes em um tutorial sobre lógica. Para quem quiser aprnder a mexer com programação, tenha certeza que esta parte é uma das mais essenciais para tanto. Quem quiser uma apostila de lógica para estudar por conta própria, pode procurar no pai google ou pode baixar uma aqui.

Agora que apresentamos estes operadores, podemos falar do último condicional, o case. Em RGSS, a sintaxe do case é a seguinte:

Código: [Selecionar]
case (expressão)
when (valor1)
(comandos1)
when (valor2)
(comandos2)
when (valor3)
(comandos3)
...
else
(comandos do senão)
end

Ao contrário dos outros condicionais, este não dá liberdade para usar os operadores lógicos. Ele, na verdade, utiliza automaticamente o operador ==. Assim, quando a expressão for igual ao valor1, comandos1 é executado, quando igual ao valor2, comandos2 é executado e assim por diante. A cláusula else é opcional, como no if, e serve para dizer o que acontece caso expressão não seja igual a nenhum dos valores especificados nos whens. Igualmente com os ifs encadeados, apenas um dos blocos de comando será executado.
Quem estiver bem atento poderá notar que o condicional case pode ser substituído facilmente por ifs encadeados, no entanto, eu aconselho que se dê preferência ao case quando este puder ser utilizado. Com ele, além do código ficar mais fácil de ler, eu acredito que também seja mais rápido de processar, mesmo que seja uma diferença ínfima.
O condicional case pode ser usado, portanto, sempre que houver uma série de condições necessárias, todas envolvendo comparações == com uma mesma variável. Se houver apenas uma comparação a ser feita, use o if. Se houver mais de uma, já não vejo problema em usar o case. Um exemplo dele pode ser visto logo abaixo:

Código: [Selecionar]
case Input.dir4
when 2
move_down
when 4
move_left
when 6
move_right
when 8
move_up
end

Este código foi retirado da classe Game_Player do método update. Ele determina exatamente o Movimento do herói. Input é um módulo interno que controla a entrada de informação feita pelo teclado, e dir4 é um método que diz qual a direção que o jogador apertou, considerando 4 direções. Existe também o método dir8, que faz a mesma coisa considerando 8 direções. No caso, 2 é o valor de dir4 quando o jogador aperta pra baixo, 4 é pra esquerda, 6 é pra direita e 8 é para cima. Portanto, este case compara o valor de Input.dir4 com cada um destes valores e executa a operação apropriada. Há a possibilidade de nenhum dos blocos dos when ser executado: quando o jogador não aperta para nenhuma direção e Input.dir4 retorna 0.

Enfim, este tópico fez apenas uma rápida abordagem de algumas das coisas mais essenciais para programação: variáveis e condicionais. Creio que essas informações ainda não sejam o suficiente para customizações avançadas no RGSS, mas é o começo para um entendimento pleno delas. No tutorial que fiz anteriormente, o do movimento analógico, achei que eu fiquei devendo uma explicação mais detalhada das coisas que falei aqui, e ainda há muito o que falar. Quem tiver a chance de baixar a apostila de lógica, de estudá-la e de até fazer os exercícios propostos nela, não percam a chance. Eu não tenho a resposta dos exercícios aqui, mas posso até montar um gabarito se tiverem interesse. Lembre-se que não adianta nada conhecer a sintaxe do RGSS se você não gostar e não estudar lógica de programação.


Espero que seja util a todos, bye. <3

[xXangeloXx]

Caramba a sua aula ficou muito boa parabéns pena que agora eu estou sem tempo de ler ela, mas quando tiver tempo certamente vou ler...

E espero que você poste mais aulas, com exemplos e exercícios

Té +

[Akina]

A aula não é minha é do Thiago Farenheith.

Créditos a: Thiago Farenheith.

Se eu achar outras eu posto

[Guyts]

Gostei da aula, é bem básica mas extremamente importante pra quem pretende aprender RGSS, Além disso, a aula explora exemplos retirados das classes do RGSS, algo raro de se encontrar na maioria dos tutoriais sobre o assunto. Estou aprendendo RGSS e percebo que boa parte dos tutoriais que encontro são carregados de exemplos com pouca ou nenhuma aplicabilidade, deixando o aprendizado mais difícil.
No mais, valeu Akina por disponibilizar o tuto! Se encontrar outros como esse poste por favor.

[HenriqueCM]

Muito boa aula.
Vou ler e vou tentar entender o que explica.
Mas tenho quase certeza de que vou aprender algo.
Obrigado Akina, +1 Pedra Lunar !
Obrigado por disponibilizar !

[Conteúdo patrocinado]