Nesta aula veremos um exemplo prático de como fazer um sistema simples de dia e noite.
O sistema basicamente consiste em um ciclo de horas de 0 a 24 onde o tom da tela é alterado em função das horas.
- Introdução
Primeiro temos que saber onde fazer esta modificação, o script é a class Scene_Map, é lá onde é atualizado todo o mapa. Quando falo em atualizar, lembre-se do método update, e é ele que iremos modificar.
Como há momentos em que não desejamos ligar o sistema, temos que fazer uma condição para que ele só funcione se a switch estiver ligada.
Então vamos criar as variáveis globais:
$secs = 0
$mins = 0
$hours = 0
$hours_var = 1
$dn_on = 1
As três primeiras são as variáveis do tempo. A penúltima é a variável que armazena a hora, é a mesma que $hours, porém para que fique melhor utilizar em eventos, por condições fica melhor associá-la a uma variável do jogo. E a última é a switch que liga e desliga o sistema.
- Modificando o método update
Antes de modificar o método precisamos criar uma variável de velocidade do tempo, poderíamos deixar o valor 1 como velocidade assim os segundos passariam normalmente, porém como é apenas um exemplo vamos colocar um valor alto para vermos o tempo passar mais rápido.
$time_speed = 35
Crie um novo script e escreva a classe Scene_Map, não se esqueça de por a classe mãe Scene_Base por meio de herança e
copie o método update.
Agora antes do end cole o código:
if $game_switches[$dn_on]
$secs += $time_speed
if $secs >= 60
$secs = 0
$mins += 1
end
if $mins >= 60
$mins = 0
$hours += 1
end
if $hours >= 24
$hours = 0
$game_variables[$hours_var] = $hours
end
update_screen
end
Aqui são feitas as três condições do tempo, os segundos serão incrementados pela velocidade e ao atingirem 60 ou mais serão
zerados e os minutos serão incrementados em 1, repetindo o ciclo até que os minutos sejam igual a 60, zerando-os e incrementando as horas, que por sua vez será incrementada até chegar a 24, onde voltará a ser 0.
Chamamos o método update_screen então que é o que irá fazer a tela mudar de tonalidade.
- O método da tonalidade
Crie o método:
def update_screen
case $hours
when 0,1,2,3,4
$game_map.screen.start_tone_change(Tone.new(-102,-102,-102),140)
when 5,6,7
$game_map.screen.start_tone_change(Tone.new(-34,-34,-34),140)
when 8,9,10,11,12,13,14,15,16,17
$game_map.screen.start_tone_change(Tone.new(20,10,10),140)
when 18,19,20,21,22,23
$game_map.screen.start_tone_change(Tone.new(-68,-68,-68),140)
end
end
Aqui são feitas condições também para verificar qual é a hora e em sua função mudar a tonalidade. Usamos a classe Game_Map que tem uma instância da Game_Screen ($game_map.screen) a qual é a responsável pela tela do jogo, e nela há o método start_tone_change que muda a tonalidade da tela. Os argumentos são o tom e a velocidade. O tom é uma classe também, portanto temos que iniciá-la com o new e os argumentos são as cores RGB (vermelho, verde, azul) que vão de 0 a 255.
Para fazermos a condição, eu utilizei o comando case, poderíamos escrever 24 if + eslsif porém esta maneira é muito mais eficiente.
Aqui está o script completo. Para testá-lo, lembre-se de ativar a switch 1.
$secs = $mins = $hours = 0
$time_speed = 35
$hours_var = 1
$dn_on = 1
class Scene_Map < Scene_Base
def update
super
$game_map.update(true)
$game_player.update
$game_timer.update
@spriteset.update
update_scene if scene_change_ok?
if $game_switches[$dn_on]
$secs += $time_speed
if $secs >= 60
$secs = 0
$mins += 1
end
if $mins >= 60
$mins = 0
$hours += 1
end
if $hours >= 24
$hours = 0
$game_variables[$hours_var] = $hours
end
update_screen
end
end
def update_screen
case $hours
when 0,1,2,3,4
$game_map.screen.start_tone_change(Tone.new(-102,-102,-102),140)
when 5,6,7
$game_map.screen.start_tone_change(Tone.new(-34,-34,-34),140)
when 8,9,10,11,12,13,14,15,16,17
$game_map.screen.start_tone_change(Tone.new(20,10,10),140)
when 18,19,20,21,22,23
$game_map.screen.start_tone_change(Tone.new(-68,-68,-68),140)
end
end
end
sexta-feira, 19 de abril de 2013
segunda-feira, 15 de abril de 2013
Aprendendo RGSS do zero - Aula 09
Nesta aula finalmente aprenderemos algo prático, na verdade será um pouco de tudo
que vimos em todas as aulas, apesar de não ter uma utilidade em si, mas é um ótimo
exemplo de como funcionam as coisas na prática.
- Introdução
A Scene que criaremos consiste em uma janela com entrada para comandos, são as setas direcionais.
Primeiro criamos um módulo com os caracteres desejados.
module Commands
Commands = {'u' => '↑', 'd' => '↓', 'l' => '←', 'r' => '→'}
end
Utilizamos uma hash para associar cada comando a um caractere.
Os comandos ou chaves são u,d,l,r respectivamente up, down, left e right.
- Criando a janela
class Window_Commands < Window_Selectable
def initialize(x,y,w,h)
super(x,y,w,h)
@commands = []
refresh
end
def refresh
contents.clear
draw_commands
end
def commands
return @commands
end
def draw_commands
x = 0
for c in @commands
draw_text(x, 0, contents.width, 30, Commands::Commands[c])
x += 20
end
end
def pop
return if @commands.size == 0
@commands.pop
refresh
end
def push(c)
return if @commands.size == 14
@commands << c
refresh
end
end
Vamos dividir a explicação em cada método.
No primeiro método criamos uma variável lista que armazenará os comandos u,d,l,r e chamamos o método
que escreverá eles.
No segundo, apagaremos todo o conteúdo e em seguida escreveremos novamente.
No terceiro, criamos um método que retorna a própria lista dos comandos.
No quarto, escrevemos os caracteres um a um utilizando o for, perceba que para não sobrepor cada seta,
cria-se uma variável x que será incrementada a cada repetição, assim cada vez que tiver uma seta, terá um espaço de 20 pixels.
Usamos a hash para dizer qual caractere será impresso, por exemplo se for o u, ficaria assim:
Commands::Commands['u'] # => ↑
No quinto e sexto os métodos são respectivamente de remoção e adição de comandos, como visto na aula 6.
Veja a condição em cada método, o comando só será executado caso a condição seja realizada. Não será possível remover
um comando se a lista estiver vazia e não será possível adicionar se a lista tiver 14 elementos.
- Criando a scene
class Scene_Commands < Scene_Base
def start
super
draw_windows
end
def draw_windows
@command_window = Window_Commands.new(10,10,310,50)
end
def update
super
return_scene if Input.trigger?(:B) and @command_window.commands.size == 0
@command_window.pop if Input.repeat?(:B)
@command_window.push('u') if Input.repeat?(:UP)
@command_window.push('d') if Input.repeat?(:DOWN)
@command_window.push('l') if Input.repeat?(:LEFT)
@command_window.push('r') if Input.repeat?(:RIGHT)
end
def terminate
super
@command_window.dispose
end
end
Novamente a explicação por métodos.
No primeiro, criamos o método principal e chamamos o método de criação da janela.
No segundo, criamos a janela. Perceba que o método start só é chamado uma vez, que é quando chamamos a scene, bem como este
método, pois só é preciso criar a janela uma vez!
No terceiro, fazemos várias condições de checagem de teclas. Perceba na primeira linha que retornamos a scene anterior somente se
a lista estiver vazia, isso serve para não voltar a scene simplesmente ao pressionar ESC, pois pode conter comandos ainda na
lista. Caso tenha, usamos o método pop para remover o último elemento. Em seguida criamos as quatro condições para cada tecla e
adicionamos a lista o comando respectivo.
No quarto simplesmente destruimos a janela ao sair.
- Finalizando
Copie todos os códigos e cole num script novo e teste o jogo chamando o código:
SceneManager.call(Scene_Commands)
Pronto, agora é só teclar as setas direcionais e pressionar ESC para remover o último comando ou sair.
que vimos em todas as aulas, apesar de não ter uma utilidade em si, mas é um ótimo
exemplo de como funcionam as coisas na prática.
- Introdução
A Scene que criaremos consiste em uma janela com entrada para comandos, são as setas direcionais.
Primeiro criamos um módulo com os caracteres desejados.
module Commands
Commands = {'u' => '↑', 'd' => '↓', 'l' => '←', 'r' => '→'}
end
Utilizamos uma hash para associar cada comando a um caractere.
Os comandos ou chaves são u,d,l,r respectivamente up, down, left e right.
- Criando a janela
class Window_Commands < Window_Selectable
def initialize(x,y,w,h)
super(x,y,w,h)
@commands = []
refresh
end
def refresh
contents.clear
draw_commands
end
def commands
return @commands
end
def draw_commands
x = 0
for c in @commands
draw_text(x, 0, contents.width, 30, Commands::Commands[c])
x += 20
end
end
def pop
return if @commands.size == 0
@commands.pop
refresh
end
def push(c)
return if @commands.size == 14
@commands << c
refresh
end
end
Vamos dividir a explicação em cada método.
No primeiro método criamos uma variável lista que armazenará os comandos u,d,l,r e chamamos o método
que escreverá eles.
No segundo, apagaremos todo o conteúdo e em seguida escreveremos novamente.
No terceiro, criamos um método que retorna a própria lista dos comandos.
No quarto, escrevemos os caracteres um a um utilizando o for, perceba que para não sobrepor cada seta,
cria-se uma variável x que será incrementada a cada repetição, assim cada vez que tiver uma seta, terá um espaço de 20 pixels.
Usamos a hash para dizer qual caractere será impresso, por exemplo se for o u, ficaria assim:
Commands::Commands['u'] # => ↑
No quinto e sexto os métodos são respectivamente de remoção e adição de comandos, como visto na aula 6.
Veja a condição em cada método, o comando só será executado caso a condição seja realizada. Não será possível remover
um comando se a lista estiver vazia e não será possível adicionar se a lista tiver 14 elementos.
- Criando a scene
class Scene_Commands < Scene_Base
def start
super
draw_windows
end
def draw_windows
@command_window = Window_Commands.new(10,10,310,50)
end
def update
super
return_scene if Input.trigger?(:B) and @command_window.commands.size == 0
@command_window.pop if Input.repeat?(:B)
@command_window.push('u') if Input.repeat?(:UP)
@command_window.push('d') if Input.repeat?(:DOWN)
@command_window.push('l') if Input.repeat?(:LEFT)
@command_window.push('r') if Input.repeat?(:RIGHT)
end
def terminate
super
@command_window.dispose
end
end
Novamente a explicação por métodos.
No primeiro, criamos o método principal e chamamos o método de criação da janela.
No segundo, criamos a janela. Perceba que o método start só é chamado uma vez, que é quando chamamos a scene, bem como este
método, pois só é preciso criar a janela uma vez!
No terceiro, fazemos várias condições de checagem de teclas. Perceba na primeira linha que retornamos a scene anterior somente se
a lista estiver vazia, isso serve para não voltar a scene simplesmente ao pressionar ESC, pois pode conter comandos ainda na
lista. Caso tenha, usamos o método pop para remover o último elemento. Em seguida criamos as quatro condições para cada tecla e
adicionamos a lista o comando respectivo.
No quarto simplesmente destruimos a janela ao sair.
- Finalizando
Copie todos os códigos e cole num script novo e teste o jogo chamando o código:
SceneManager.call(Scene_Commands)
Pronto, agora é só teclar as setas direcionais e pressionar ESC para remover o último comando ou sair.
domingo, 14 de abril de 2013
Aprendendo RGSS do zero - Aula 08
Nesta aula iremos aprender a criar Scenes. Scenes são classes que possuem uma interação com o jogador, eu costumo dizer que são a alma dos jogos, a ideia delas está amplamente ligada à janelas, pois somente as janelas não fazem a interação.
- Introdução
Antes de mais nada saiba que o nome Scene é uma convenção, você pode por qualquer nome que quiser na sua classe, porém quando se põe Scene fica mais claro o que ela é.
No RGSS3 há a classe mãe Scene_Base, que facilita muito a nossa vida, pois precisamos apenas chamar os métodos básicos e não criá-los do zero.
class Scene_Teste < Scene_Base
def start
super
end
end
O método obrigatório é o start, ele faz rodar toda a janela.
Chama-se uma Scene da seguinte forma:
SceneManager.call(Nome_Da_Scene)
Note que não há necessidade de por .new pois o programa se encarrega disso.
Obviamente se você chamar o script acima verá apenas uma tela preta permanente.
Vamos adicionar um comando de voltar ao pressionar ESC:
class Scene_Teste < Scene_Base
def start
super
end
def update
super
return_scene if Input.trigger?(:B)
end
end
Sempre que precisar checar se algo é cumprido ou algo do tipo, que será necessário repetir várias vezes, ou um valor atingir certo número, usa-se o método update.
Neste, tudo será repetido em um determinado tempo, no caso será sempre checada a condição de pressionada a tecla ESC (usa-se o símbolo :B) e chamamos e método return_scene que retorna a scene anterior.
- Adicionando uma janela
Para adicionarmos uma janela usamos o método start, pois será criada apenas uma vez e não várias!
class Scene_Teste < Scene_Base
def start
super
@window = Window_Teste.new(0,0,200,200)
end
def update
super
return_scene if Input.trigger?(:B)
end
end
Agora vamos adicionar um método para apagar a janela quando sairmos da Scene.
class Scene_Teste < Scene_Base
def start
super
@window = Window_Teste.new(0,0,200,200)
end
def update
super
return_scene if Input.trigger?(:B)
end
def terminate
super
@window.dispose
end
end
Este método é chamado terminate. O comando dispose é o que apaga a janela.
Por enquanto é isso, na próxima aula vamos usar um exemplo envolvendo tudo que aprendemos nas últimas aulas!
- Introdução
Antes de mais nada saiba que o nome Scene é uma convenção, você pode por qualquer nome que quiser na sua classe, porém quando se põe Scene fica mais claro o que ela é.
No RGSS3 há a classe mãe Scene_Base, que facilita muito a nossa vida, pois precisamos apenas chamar os métodos básicos e não criá-los do zero.
class Scene_Teste < Scene_Base
def start
super
end
end
O método obrigatório é o start, ele faz rodar toda a janela.
Chama-se uma Scene da seguinte forma:
SceneManager.call(Nome_Da_Scene)
Note que não há necessidade de por .new pois o programa se encarrega disso.
Obviamente se você chamar o script acima verá apenas uma tela preta permanente.
Vamos adicionar um comando de voltar ao pressionar ESC:
class Scene_Teste < Scene_Base
def start
super
end
def update
super
return_scene if Input.trigger?(:B)
end
end
Sempre que precisar checar se algo é cumprido ou algo do tipo, que será necessário repetir várias vezes, ou um valor atingir certo número, usa-se o método update.
Neste, tudo será repetido em um determinado tempo, no caso será sempre checada a condição de pressionada a tecla ESC (usa-se o símbolo :B) e chamamos e método return_scene que retorna a scene anterior.
- Adicionando uma janela
Para adicionarmos uma janela usamos o método start, pois será criada apenas uma vez e não várias!
class Scene_Teste < Scene_Base
def start
super
@window = Window_Teste.new(0,0,200,200)
end
def update
super
return_scene if Input.trigger?(:B)
end
end
Agora vamos adicionar um método para apagar a janela quando sairmos da Scene.
class Scene_Teste < Scene_Base
def start
super
@window = Window_Teste.new(0,0,200,200)
end
def update
super
return_scene if Input.trigger?(:B)
end
def terminate
super
@window.dispose
end
end
Este método é chamado terminate. O comando dispose é o que apaga a janela.
Por enquanto é isso, na próxima aula vamos usar um exemplo envolvendo tudo que aprendemos nas últimas aulas!
sábado, 13 de abril de 2013
Aprendendo RGSS do zero - Aula 07
Nesta aula vamos aprender um pouco sobre Windows, que são as janelas do jogo.
Uma Window é uma classe, logo toda janela é um objeto, elas são um ótimo exemplo de porque utilizar classes, visto que há dezenas de janelas, e como elas têm muito em comum, é viável usar o conceito de orientação a objeto.
- Introdução
Definimos uma janela assim:
class Window_Teste < Window_Base
end
A classe mãe é a Window_Base, herdamos todos os métodos dela.
Agora vamos utilizar o método de início.
class Window_Teste < Window_Base
def initialize(x,y,w,h)
super(x,y,w,h)
end
end
O método initialize requer quatro argumentos, que são respectivamente posição x, posição y, largura e altura.
A palavra reservada super chama o método da classe mãe, nesse caso chamará o método initialize da classe Window_Base com os argumentos dados.
Crie um evento e chame o script
Window_Teste.new(10,10,200,200)
- Escrevendo textos
Agora vamos escrever um texto na nossa janela.
class Window_Teste < Window_Base
def initialize(x,y,w,h)
super(x,y,w,h)
draw_text(0,0,140,30,"Hello World")
end
end
Usa-se o método draw_text para escrever um texto. Os argumentos são os seguintes: posição x, posição y, largura do retângulo, altura do retângulo, texto
O retângulo é a área do texto.
Para fazer a janela ficar permanente e também ter interações utiliza-se as Scenes, conteúdo que veremos adiante.
- Mudando a cor
Para mudarmos a cor do texto, usa-se o método change_color
change_color(text_color(2))
change_color(Color.new(200,0,0))
O método text_color(n) retorna uma cor pré definida de acordo com a Windowskin, caso queira uma cor que não esteja disponível, use a classe Color e coloque os três argumentos RGB, de 0 a 255.
- Exemplo
Vamos colocar uma imagem na nossa janela.
class Window_Teste < Window_Base
def initialize(x,y,w,h)
super(x,y,w,h)
bitmap = Cache.battler("Assassin",0)
rect = Rect.new(0,0,bitmap.width,bitmap.height)
contents.blt(0,0,bitmap,rect)
end
end
Na quarta linha criamos uma Bitmap (classe das imagens e textos em geral) com o método battler do módulo Cache. O primeiro argumento é o nome do arquivo e o segundo a tonalidade.
Na quinta linha criamos um retângulo, que será a delimitação da imagem, a imagem fica dentro do retângulo. Os argumentos são os mesmos das janela, a diferença é que quando colocamos bitmap.width, bitmap.height não nos restrigimos a um valor número, o próprio programa se encarrega de pegar os valores.
Na sexta linha pegamos esse retângulo com a imagem e jogamos na janela. Os argumentos são posição x e y, imagem e o retângulo.
Você pode modificar os valores dos argumentos para entender melhor o que cada um faz.
Uma Window é uma classe, logo toda janela é um objeto, elas são um ótimo exemplo de porque utilizar classes, visto que há dezenas de janelas, e como elas têm muito em comum, é viável usar o conceito de orientação a objeto.
- Introdução
Definimos uma janela assim:
class Window_Teste < Window_Base
end
A classe mãe é a Window_Base, herdamos todos os métodos dela.
Agora vamos utilizar o método de início.
class Window_Teste < Window_Base
def initialize(x,y,w,h)
super(x,y,w,h)
end
end
O método initialize requer quatro argumentos, que são respectivamente posição x, posição y, largura e altura.
A palavra reservada super chama o método da classe mãe, nesse caso chamará o método initialize da classe Window_Base com os argumentos dados.
Crie um evento e chame o script
Window_Teste.new(10,10,200,200)
- Escrevendo textos
Agora vamos escrever um texto na nossa janela.
class Window_Teste < Window_Base
def initialize(x,y,w,h)
super(x,y,w,h)
draw_text(0,0,140,30,"Hello World")
end
end
Usa-se o método draw_text para escrever um texto. Os argumentos são os seguintes: posição x, posição y, largura do retângulo, altura do retângulo, texto
O retângulo é a área do texto.
Para fazer a janela ficar permanente e também ter interações utiliza-se as Scenes, conteúdo que veremos adiante.
- Mudando a cor
Para mudarmos a cor do texto, usa-se o método change_color
change_color(text_color(2))
change_color(Color.new(200,0,0))
O método text_color(n) retorna uma cor pré definida de acordo com a Windowskin, caso queira uma cor que não esteja disponível, use a classe Color e coloque os três argumentos RGB, de 0 a 255.
- Exemplo
Vamos colocar uma imagem na nossa janela.
class Window_Teste < Window_Base
def initialize(x,y,w,h)
super(x,y,w,h)
bitmap = Cache.battler("Assassin",0)
rect = Rect.new(0,0,bitmap.width,bitmap.height)
contents.blt(0,0,bitmap,rect)
end
end
Na quarta linha criamos uma Bitmap (classe das imagens e textos em geral) com o método battler do módulo Cache. O primeiro argumento é o nome do arquivo e o segundo a tonalidade.
Na quinta linha criamos um retângulo, que será a delimitação da imagem, a imagem fica dentro do retângulo. Os argumentos são os mesmos das janela, a diferença é que quando colocamos bitmap.width, bitmap.height não nos restrigimos a um valor número, o próprio programa se encarrega de pegar os valores.
Na sexta linha pegamos esse retângulo com a imagem e jogamos na janela. Os argumentos são posição x e y, imagem e o retângulo.
Você pode modificar os valores dos argumentos para entender melhor o que cada um faz.
quinta-feira, 11 de abril de 2013
Aprendendo RGSS do zero - Aula 06
Neste módulo intermediário aprederemos um pouco mais de algumas coisas que não foram vistas. É altamente recomendando que você tenha lido e entendido o módulo básico.
- Hashes
Hashes ou dicionários são váriaveis que armazenam valores, diferente das listas (arrays) hashes não se referem ao valores por índices, e sim por chaves. Declara-se hashes assim:
var = {}
Podemos também já definir os valores na declaração.
var = {1 => "um"}
var2 = {2 => 'dois'}
Para colocar vários conjuntos numa mesma variável, use o operador vírgula:
var = {"au au" => "cachorro", "miau" => "gato"}
O operador => tem a função de associar os valores relacionados, veja como se usa as hashes:
var["au au"] # cachorro
var["miau"] # gato
Os termos do lado esquerdo (antes do =>) são chamados chaves e os do lado direito, valores.
Perceba que se chama as hashes com o operador de array também (colchetes), porém usa-se as chaves para fazer a referência.
Pode-se usar números e símbolos e outros objetos nas chaves.
var = {1=>'um',:s="string"}
- Exemplo
Um exemplo para pegar todos os valores:
hash = {1=>"um",2=>"dois",3=>"três"}
for i in hash.keys # 1,2,3
msgbox hash[i]
end
O método keys retorna um array das chaves [1,2,3], e em seguida são passados ao for, que neste caso não tem o operador de ponto, pois ele já sabe quantos elementos ler.
- Um pouco mais sobre arrays
Vamos aprender mais dois métodos úteis das arrays, o push e pop.
O push serve para adicionar um elemento a fila, colocando-o em último lugar.
a = [1,2,3]
a.push(4) # a = [1,2,3,4]
Podemos também utilizar o operador <<
a = [4,5,6]
a << 7 # a = [4,5,6,7]
O pop serve para remover o último elemento da lista.
a = [1,2,3,5]
a.pop() # a = [1,2,3]
Bom, pessoal por enquanto é isso, gostaria que postassem nos comentários que tipos de aula vocês gostariam. Nas próximas irei falar sobre windows.
- Hashes
Hashes ou dicionários são váriaveis que armazenam valores, diferente das listas (arrays) hashes não se referem ao valores por índices, e sim por chaves. Declara-se hashes assim:
var = {}
Podemos também já definir os valores na declaração.
var = {1 => "um"}
var2 = {2 => 'dois'}
Para colocar vários conjuntos numa mesma variável, use o operador vírgula:
var = {"au au" => "cachorro", "miau" => "gato"}
O operador => tem a função de associar os valores relacionados, veja como se usa as hashes:
var["au au"] # cachorro
var["miau"] # gato
Os termos do lado esquerdo (antes do =>) são chamados chaves e os do lado direito, valores.
Perceba que se chama as hashes com o operador de array também (colchetes), porém usa-se as chaves para fazer a referência.
Pode-se usar números e símbolos e outros objetos nas chaves.
var = {1=>'um',:s="string"}
- Exemplo
Um exemplo para pegar todos os valores:
hash = {1=>"um",2=>"dois",3=>"três"}
for i in hash.keys # 1,2,3
msgbox hash[i]
end
O método keys retorna um array das chaves [1,2,3], e em seguida são passados ao for, que neste caso não tem o operador de ponto, pois ele já sabe quantos elementos ler.
- Um pouco mais sobre arrays
Vamos aprender mais dois métodos úteis das arrays, o push e pop.
O push serve para adicionar um elemento a fila, colocando-o em último lugar.
a = [1,2,3]
a.push(4) # a = [1,2,3,4]
Podemos também utilizar o operador <<
a = [4,5,6]
a << 7 # a = [4,5,6,7]
O pop serve para remover o último elemento da lista.
a = [1,2,3,5]
a.pop() # a = [1,2,3]
Bom, pessoal por enquanto é isso, gostaria que postassem nos comentários que tipos de aula vocês gostariam. Nas próximas irei falar sobre windows.
segunda-feira, 18 de março de 2013
Aprendendo RGSS do zero - Aula 05
Resolução do exercício anterior
def maior_elemento
a = [5,20,50,98,68,120]
indice = 0
for i in 0...a.size # size é igual a length
if a[i] > a[indice]
indice = i
end
return a[indice]
end
- Introdução
Classes são elementos da programação orientada a objeto, imagine-as como um pai ou mãe que terão um ou vários filhos, estes chamados de instâncias.
A principal característica das classes é a herança, as suas instâncias terão os mesmos métodos e variáveis (somente as de classe).
Assim como definimos métodos, se define classes com uma palavra reservada.
class Nome_da_classe
end
Por conveniência se utiliza inicial maiúscula em classes e minúsculas em métodos.
Para iniciar-se uma classe não basta apenas declarar uma variável, temos que "ativá-la".
class A
def initialize
msgbox "Fui criada"
end
end
A.new # Fui criada
O método initialize é comum em todas as classes, ele é o primeiro método a ser executado quando a classe é criada, porém não é necessário criá-lo.
- Herança
Agora vem a parte interessante, vamos entender este conceito. Veja o exemplo:
class Animal
attr_accessor :nome
end
class Cachorro < Animal
def initialize
@nome = "Cachorro"
end
end
class Gato < Animal
def initialize
@nome = "Gato"
end
end
msgbox Cachorro.new.nome # Cachorro
msgbox Gato.new.nome # Gato
Primeira coisa, o método attr_accessor cria um atributo da classe, no caso a variável de classe nome.
Perceba que nome é um símbolo, que é um pouco diferente das variáveis, não vou me aprofundar agora nisso, mas toda vez que for criar um atributo utilize-o desta forma.
Há três tipos de atributos:
attr_reader => somente de leitura/consulta
attr_writer => somente de escrita
attr_accessor => leitura e escrita
Segunda coisa, notou o operador ponto? Usamos ele também para nos referirmos à atributos, poderíamos escrever as últimas duas linhas da seguinte forma:
cachorro = Cachorro.new()
msgbox(cachorro.nome)
gato = Gato.new()
msgbox(gato.nome)
Terceira coisa, o operador < nesse caso indica herança, a classe da esquerda herda os métodos e variáveis da classe a direita.
- Métodos de classe e instância
Há dois tipos de métodos em classes, o primeiro é o de classe. Não podemos criar uma instância nele.
class Matematica
def self.pi
3.1415
end
end
Matematica.new.pi # errado
Matematica.pi # correto
Quando usamos o new, criamos uma instância dessa classe, porém nos métodos de classe não é criada uma instância, o método é simplesmente lido diretamente da classe.
Usamos o self para substituir o nome da classe, assim se mudarmos o seu nome, não será necessário mudar o nome do método, veja como é mais conveniente:
def self.pi
3.1415
end
def Matematica.pi
3.1415
end
Já os métodos de instância necessitam que a classe seja criada.
class Matematica
def pi
3.1415
end
end
Matematica.new.pi # 3.1415
- Módulos
Os módulos são basicamente classes, porém não são criadas instâncias pois eles são somente para consulta, devem ser iniciado com letra maiúscula.
Geralmente todas as variáveis são constantes.
module Teste
VAR = 10
def self.m
return VAR+VAR
end
end
Teste::VAR # 10
Teste.m # 20
O operador de módulo é o ::, funciona do mesmo jeito que o . dos attr_x.
Note não é criada uma instância com o uso do new.
Acabamos a primeira parte das aulas, o nível básico. Agora entraremos no nível intermediário.
Não exite em voltar ao começo para ver o que esqueceu e pratique muito, pois não é fácil aprender algo novo, principalmente a programar.
def maior_elemento
a = [5,20,50,98,68,120]
indice = 0
for i in 0...a.size # size é igual a length
if a[i] > a[indice]
indice = i
end
return a[indice]
end
- Introdução
Classes são elementos da programação orientada a objeto, imagine-as como um pai ou mãe que terão um ou vários filhos, estes chamados de instâncias.
A principal característica das classes é a herança, as suas instâncias terão os mesmos métodos e variáveis (somente as de classe).
Assim como definimos métodos, se define classes com uma palavra reservada.
class Nome_da_classe
end
Por conveniência se utiliza inicial maiúscula em classes e minúsculas em métodos.
Para iniciar-se uma classe não basta apenas declarar uma variável, temos que "ativá-la".
class A
def initialize
msgbox "Fui criada"
end
end
A.new # Fui criada
O método initialize é comum em todas as classes, ele é o primeiro método a ser executado quando a classe é criada, porém não é necessário criá-lo.
- Herança
Agora vem a parte interessante, vamos entender este conceito. Veja o exemplo:
class Animal
attr_accessor :nome
end
class Cachorro < Animal
def initialize
@nome = "Cachorro"
end
end
class Gato < Animal
def initialize
@nome = "Gato"
end
end
msgbox Cachorro.new.nome # Cachorro
msgbox Gato.new.nome # Gato
Primeira coisa, o método attr_accessor cria um atributo da classe, no caso a variável de classe nome.
Perceba que nome é um símbolo, que é um pouco diferente das variáveis, não vou me aprofundar agora nisso, mas toda vez que for criar um atributo utilize-o desta forma.
Há três tipos de atributos:
attr_reader => somente de leitura/consulta
attr_writer => somente de escrita
attr_accessor => leitura e escrita
Segunda coisa, notou o operador ponto? Usamos ele também para nos referirmos à atributos, poderíamos escrever as últimas duas linhas da seguinte forma:
cachorro = Cachorro.new()
msgbox(cachorro.nome)
gato = Gato.new()
msgbox(gato.nome)
Terceira coisa, o operador < nesse caso indica herança, a classe da esquerda herda os métodos e variáveis da classe a direita.
- Métodos de classe e instância
Há dois tipos de métodos em classes, o primeiro é o de classe. Não podemos criar uma instância nele.
class Matematica
def self.pi
3.1415
end
end
Matematica.new.pi # errado
Matematica.pi # correto
Quando usamos o new, criamos uma instância dessa classe, porém nos métodos de classe não é criada uma instância, o método é simplesmente lido diretamente da classe.
Usamos o self para substituir o nome da classe, assim se mudarmos o seu nome, não será necessário mudar o nome do método, veja como é mais conveniente:
def self.pi
3.1415
end
def Matematica.pi
3.1415
end
Já os métodos de instância necessitam que a classe seja criada.
class Matematica
def pi
3.1415
end
end
Matematica.new.pi # 3.1415
- Módulos
Os módulos são basicamente classes, porém não são criadas instâncias pois eles são somente para consulta, devem ser iniciado com letra maiúscula.
Geralmente todas as variáveis são constantes.
module Teste
VAR = 10
def self.m
return VAR+VAR
end
end
Teste::VAR # 10
Teste.m # 20
O operador de módulo é o ::, funciona do mesmo jeito que o . dos attr_x.
Note não é criada uma instância com o uso do new.
Acabamos a primeira parte das aulas, o nível básico. Agora entraremos no nível intermediário.
Não exite em voltar ao começo para ver o que esqueceu e pratique muito, pois não é fácil aprender algo novo, principalmente a programar.
sábado, 16 de março de 2013
Aprendendo RGSS do zero - Aula 04
Resolução do exercício anterior
i = 0
while i < $game_party.all_members.length
msgbox $game_party.all_members[i].level
i += 1
end
- Introdução
Nesta aula vamos falar sobre métodos!
Um método ou função é um ou um conjunto de instruções feito em um bloco.
Define-se um método da seguinte forma:
def nome_do_metodo
# instrução
end
A grande vantagem dos métodos é que assim que você os define, só
precisa chamá-los para que a ação seja executada. Isso poupa tempo e linhas de código.
Vamos a um exemplo básico:
def falar()
msgbox "Olá"
end
Vamos chamar o método:
falar()
Note que não é preciso o uso de parêntesis, mas por convenção, usa-se. Aqueles métodos
que vimos nas outras aulas também se aplicam a essa afirmação. msgbox e exit também são métodos!
def falar_mensagem(msg)
msgbox msg
end
A variável entre os parêntesis é chamada de argumento ou parâmetro,
dependendo do método pode não havê-lo ou haver mais de um. Ele serve para usarmos uma variável de fora nele, em resumo.
No caso acima poderia também por msgbox(msg). Os argumentos são separados por vírgula (ela também é um operador):
def falar_duas(msg1, msg2)
msgbox msg1 + " " + msg2
end
- O comando return
Quando usamos um método e esperamos um valor de retorno, usamos o comando return.
def potencia(n, p)
return n**p
end
O operador ** é o de potenciação. No exemplo acima podemos declarar uma variável que
receberá esse valor, veja:
var = potencia(2,3) # 2 ** 3 => 8
Atenção, assim que o return for lido, a função "quebrará", ou seja, irá parar de rodar e voltará a próxima linha
após o seu end.
def advinhar(n)
g = rand(3)
if g == n
return true
else
msgbox g
g = rand(3)
advinhar(n)
end
end
O método rand gera um número aleatório até o valor dado, no exemplo acima será 0, 1 ou 2.
Pode-se também chamar o método dentro dele próprio, esse é o conceito de recursividade.
O método continuará rodando até que o número da variável g seja o mesmo que o argumento.
- Exemplo
Vamos criar um método que verifica se o número é par.
def par_ou_impar(n)
if n % 2 == 0
return "é par"
else
return "é ímpar"
end
end
O operador % (modulo) é o de o resto da divisão.
par_ou_impar(22) # é par
par_ou_impar 37 # é ímpar
- Outro tipo de return
Em ruby, quando a última linha tem apenas o nome da variável ou expressão, fica implícito que há o seu retorno.
def retorno_explicito(n)
i = (n*2)+1
return i
end
def retorno_implicito(n)
(n*2)+1
end
- Exercício
Crie um método que retorne o maior valor de um array aleátorio (crie).
Dica: Você usará o for aqui, não se esqueça de usar o operador de maior.
Na próxima aula veremos classes.
i = 0
while i < $game_party.all_members.length
msgbox $game_party.all_members[i].level
i += 1
end
- Introdução
Nesta aula vamos falar sobre métodos!
Um método ou função é um ou um conjunto de instruções feito em um bloco.
Define-se um método da seguinte forma:
def nome_do_metodo
# instrução
end
A grande vantagem dos métodos é que assim que você os define, só
precisa chamá-los para que a ação seja executada. Isso poupa tempo e linhas de código.
Vamos a um exemplo básico:
def falar()
msgbox "Olá"
end
Vamos chamar o método:
falar()
Note que não é preciso o uso de parêntesis, mas por convenção, usa-se. Aqueles métodos
que vimos nas outras aulas também se aplicam a essa afirmação. msgbox e exit também são métodos!
def falar_mensagem(msg)
msgbox msg
end
A variável entre os parêntesis é chamada de argumento ou parâmetro,
dependendo do método pode não havê-lo ou haver mais de um. Ele serve para usarmos uma variável de fora nele, em resumo.
No caso acima poderia também por msgbox(msg). Os argumentos são separados por vírgula (ela também é um operador):
def falar_duas(msg1, msg2)
msgbox msg1 + " " + msg2
end
- O comando return
Quando usamos um método e esperamos um valor de retorno, usamos o comando return.
def potencia(n, p)
return n**p
end
O operador ** é o de potenciação. No exemplo acima podemos declarar uma variável que
receberá esse valor, veja:
var = potencia(2,3) # 2 ** 3 => 8
Atenção, assim que o return for lido, a função "quebrará", ou seja, irá parar de rodar e voltará a próxima linha
após o seu end.
def advinhar(n)
g = rand(3)
if g == n
return true
else
msgbox g
g = rand(3)
advinhar(n)
end
end
O método rand gera um número aleatório até o valor dado, no exemplo acima será 0, 1 ou 2.
Pode-se também chamar o método dentro dele próprio, esse é o conceito de recursividade.
O método continuará rodando até que o número da variável g seja o mesmo que o argumento.
- Exemplo
Vamos criar um método que verifica se o número é par.
def par_ou_impar(n)
if n % 2 == 0
return "é par"
else
return "é ímpar"
end
end
O operador % (modulo) é o de o resto da divisão.
par_ou_impar(22) # é par
par_ou_impar 37 # é ímpar
- Outro tipo de return
Em ruby, quando a última linha tem apenas o nome da variável ou expressão, fica implícito que há o seu retorno.
def retorno_explicito(n)
i = (n*2)+1
return i
end
def retorno_implicito(n)
(n*2)+1
end
- Exercício
Crie um método que retorne o maior valor de um array aleátorio (crie).
Dica: Você usará o for aqui, não se esqueça de usar o operador de maior.
Na próxima aula veremos classes.
Assinar:
Postagens (Atom)