Biblia RGSS [Tópico 3]

Maverick ~ · 1 Biblia RGSS [Tópico 3] 23/8/2012, 17:16

Maverick ~

Membro Honorário I

Mensagens : 107
<b> T$: </b>

T$: : 5089

Idade : 30

Quem preferir baixar aqui está o link Biblia DO RGSS em PDF

Creditos ao Jão e DarkChocobo
Maverick~ (eu) por arrumar os BBCodes e postar[/i]
Topico 1
Topico 2

Tópico 2.4 – Hash
Assim como as Arrays, Hash é um tipo de valor utilizado como container para guardar outros tipos de valores. Para trabalhar com hashes, são utilizados chaves ( „{„ e „}‟ ) ao invés de colchetes, como nas arrays. Diferente das Arrays, nas Hashes, não importa a posição em que cada valor se encontra, pois quando trabalhamos com Hashes, não mais utilizaremos um sistema de „ids‟ dos valores. Ao invés disso, os valores estarão “soltos” dentro da Hash, podendo assim chamar qualquer um de seus valores, através de númetos ou textos determinados, estes números textos representarão cada valor da hash. Para declarar uma hash, deve-se colocar cada um de seus valores separados por vírgulas (assim como na Array), porém, para cada valor introduzido na hash, você deve atribuir um número ou um texto como um “nome”(ou um núemero) para aquele valor; que deverá ser colocado logo antes do valor, separado por um „=>‟. (Não representa „maior que‟.) Exemplo de Declaração de uma Hash:
hash = { “valor 01” => 5, “valor 02” => 10, “valor03” => 15 }

No Exemplo acima, os nomes “valor 01”, “valor 02” e “valor 03” representarão os “nomes” dos valores 5, 10 e 15. Note que, como nas hashes não importa a ordem com que os valores estão na Hash, o exemplo poderia ser realizado também das seguintes formas:
hash = { “valor 01” => 5, “valor 02” => 10, “valor03” => 15 } ou hash = { “valor02” => 10 , “valor 01” => 5, “valor 03” => 15 } ou hash = { “valor 03” => 15 , “valor02” => 10 , “valor 01” => 5 # Em outras palavras, não importa a ordem utilizada.

Como eu determinei certos valores para representarem cada valor, eu deverei colocá-los no lugar do id do valor, e chamá-lo exatamente igual as Arrays. Exemplo:
hash = {} hash[“valor 01”] = 5 hash[“valor 02”] = 10 hash[“valor 03”] = 15 # Desta forma, resultaria uma hash exatamente igual a hash do exemplo anterior.

Como foi dito, cada valor da hash deverá ser representado por um nome ou um número, logo, eu poderia criar uma hash desta forma também:
hash = {} hash[0] = 5 hash[1] = 10 hash[2] = 15 # Lembrando que 0, 1 e 2 são os nomes que representam cada valor 5, 10 e 15 da hash, # e não os ids dos mesmos, pois hashes não têm ids.

Métodos Por ser uma classe, Hash também tem seus próprios métodos, que deverão ser utilizados de acordo com a situação, seus principais métodos são: clear, delete, empty, has_key?/include?, has_value?, index, keys, length/size, values. Clear, Delete, Empty?, Length e Size Estes comandos, também estão presentes nas Arrays, por este motivo, suas explicações serão bem simples: Clear apaga cada valor da Hash, como se a apagasse e a recriasse sem nenhum valor. Exemplo:
hash = { “valor” => 0 } hash.clear # hash agora está assim: {}

Delete deve ser utilisado com um valor entre parênteses. Delete apaga qualquer valor que tiver como representante o valor entre parênteses. Exemplo:
hash = { “valor 01” => 5, “valor 02” => 10, “valor03” => 15 } hash.delete(“valor 01”) # hash agora está assim: { “valor 02” => 10, “valor03” => 15 }

„Empty?‟ deve ser colocado numa condição, ele será substituído por true se a hash não tiver qualquer valor. Exemplo:
if hash.empty? # significa que a hash está assim: {} else # significa que a hash não está assim: {} End

Length e Size representam o número de valores contidos na hash. Exemplo:
hash = { “valor 01” => 5, “valor 02” => 10, “valor03” => 15 } # neste caso, hash.size será 3 hash.clear # agora, hash está assim: „{}‟, logo, hash.size será 0.

Index O comando Index será substituído pelo número ou texto que representa o valor especificado entre parênteses ao chamar o comando.

hash = { “valor 01” => 0, “valor 02” => 1, 0 => 42, 1 => 56 } nome1 = hash.index(”valor 02”) nome2 = hash.index(0) # neste caso, „nome1‟ será „1‟ e „nome2‟ será „42‟.

Values O comando será substituído por uma Array que irá conter todos os valores da Hash. Exemplo:
hash = { “valor 01” => 0, “valor 02” => 1, 0 => 42, 1 => 56 } # neste caso, hash.values será: # [0, 1, 42, 56]

Keys Keys é um comando extremamente semelhante ao Values, porém, ao contrário de Values, em Keys você obterá uma Array com os valores referentes aos textos e números que representam cada um dos valores, na Hash. Exemplo:
hash = { “valor 01” => 0, “valor 02” => 1, 0 => 42, 1 => 56 } # neste caso, hash.keys será: # [“valor 01”, “valor 02”, 0, 1]

Has_value? Este, é um comando que deverá ser utilizado como condição. Ele determina se a Hash possue algum determinado valor. Exemplo 1:
if hash.has_value?(10) # algum dos valores da Hash é „10‟ else # nenhum valor da Hash é „10‟ end

Exemplo 2:
hash = { “valor 01” => 0, “valor 02” => 1, 0 => 42, 1 => 56 } # # # # # # neste neste neste neste neste neste caso, caso, caso, caso, caso, caso, „hash.has_value?(0)‟ será true „hash.has_value?(1)‟ será true „hash.has_value?(2)‟ será false „hash.has_value?(42)‟ será true „hash.has_value?(56)‟ será true „hash.has_value?(“texto 01”)‟ será false

Has_key? / Include? Has_Value e Include deverão ser utilizados em condições, e não há diferença entre eles. Eles determinam se a Hash tem como representante de um valor, o texto ou número especificado. Exemplo:
if hash.has_key?(“texto 01”) # significa que algum valor tem como representante: ”texto 01”

esle # significa que nenhum dos valores da Hash têm “texto 01” como representante # em outras palavras, „hash[“texto 01”]‟ não existe end

Tópico 2.5 – Ragexp
Ragexp foi previamente explicado na aula 02 como “Expressões Regulares”. Ragexp é um tipo de valor semelhante às strings, porém são mais complexas. Ragexp é usado principalmente nos scripts de mensagens, para diferenciar os comandos de mensagens do resto da mensagem (ex: \c[2], \g, etc.). Diferente das strings, para utilizar Ragexp é utilizado barras inclinadas para direita ( „/‟ ) entre o texto (ex: „/Meu nome é DarkChocobo/‟). O editor de scripts do RPGMaker XP não diferencia Ragexp em uma cor diferente (provavelmente bug =P) , porém, o editor do RPGMaker VX diferencia, facilitando (para alguns) seu uso. Uma letra „i‟ ou „m‟ logo após uma Ragexp pode determinar uma opção a mais, alterando assim sua função. Exemplo:
# apesar das 3 expressões abaixo terem o mesmo texto escrito, # serão interpretados de forma diferente /Meu nome é DarkChocobo/ /Meu nome é DarkChocobo/i /Meu nome é DarkChocobo/m

OBS: Ao utilizar uma destas letras („i‟ ou „m‟) logo após uma Ragexp no editor do RMVX você perceberá que esta letra também ficou da cor roxa. A letra „i‟ torna a Ragexp uma expressão que não diferencia letras maiúsculas de minúsculas. A letra „m‟ ativa o modo “multiple-run”, que faz com que novas linhas sejam tratadas como caracteres normais, como um ponto. ( „.‟ )

Tópico 2.6 – For
For é uma estrutura de repetição muito usado principalmente em Windows, através dela é possível fazer uma repetição alterando um determinado valor quantas vezes forem necessárias. Um bom exemplo é a janela de status dos heróis no menu do jogo. Para que apareça cada um dos heróis na janela é feita uma repetição, é desenhado os atributos de cada herói (ou seja, a repetição é feita 4 vezes), mas a dava vez que é repetido, um valor é alterado, para que não seja desenhado o mesmo herói as 4 vezes. Para iniciar uma estrutura for utilize a palavra „for‟, o nome de uma variável local qualquer (será declarada automaticamente), a palavra „in‟, e por último, uma range ou uma array já declarada. A cada vez que a estrutura se repetir, a variável local que você escolheu, terá o valor de um dos valores da array ou da range. A estrutura é automaticamente quebrada quando a variável local já tiver se equalizado a cada um dos valores da array ou da range. Para um melhor compreendimento desta estrutura, crie um novo script acima de todos

os outros (para que ocorra primeiro), e então crie uma estrutura for como a do exemplo abaixo:
for i in 0 ... 3 print i end

Agora teste o jogo, e veja o resultado, tendo em mente a função do comando „print‟ (abrir uma janela padrão do Windows mostrando o valor de „i‟). Aparecerá 4 vezes a janela, cada vez será mostrado um valor diferente, sendo eles: 0, 1, 2 e 3. Isso aconteceu porque a cada vez que a estrutura se repete, „i‟ tem um valor diferente, neste caso, os valores 0, 1, 2 e 3. Com já foi dito, também podemos utilizar uma array no lugar da range, se ao invés de „0 ... 3‟ fosse utilizado a array.

Tópico 3 – Funções Exclusivas do RGSS
Ao implantar a linguagem Ruby no RPGMaker XP, a Enterbrain incluiu algumas funções extras para facilitar a criação dos jogos, assim nasceu o RGSS. Neste tópico, estudaremos estas funções extras, adicionadas à biblioteca do RGSS (RMXP). Como sabemos, o RGSS (RMXP) tem algumas diferenças quando comparado ao RGSS2 (RMVX), porém as funções extras do RGSS foram mantidas na criação do RGSS2, logo, esta lição vale para ambos RGSS e RGSS2. Estas funções do RGSS poderão ser chamadas a qualquer momento em qualquer script de todo o jogo, podendo ser comparados com métodos globais (aqueles que são declarados fora de qualquer classe e/ou módulo, podendo assim ser chamados de qualquer parte do jogo). As principais funções do RGSS são as seguintes: return, eval, exit, open, p/print, rand, printf e save_data/load_data. Return Return é o comando utilizado para sair de um método, da mesma forma que se usa o comando “Parar Evento” para mais nenhum de seus comandos serem executados. Exemplo:
def update_buy_selection @status_window.item = @buy_window.item if Input.trigger?(Input::B) # Se apertar o botão „B‟ Sound.play_cancel # Executa o som de cancelar @command_window.active = true # Altera o valor de várias variáveis @dummy_window.visible = true @buy_window.active = false @buy_window.visible = false @status_window.visible = false @status_window.item = nil @help_window.set_text("") return # E finalmente é executado o retorno, significa que mais nenhum dos commandos será utilizado end [...] # o método é muito grande, não coloquei todo ele aqui

O comando return também pode ser utilizado seguido de um valor, neste caso, o valor determinado irá retornar ao local de onde foi chamado o método.

Exemplo:
def método return 5 end variável = método # variável terá o valor de „5‟, pois „método‟ foi subtituido pelo valor de retorno 5

OBS: Note que o comando „return‟, quando vem seguido de um valor de retorno, faz com que o comando de chamar o método seja substituído pelo valor do retorno. Note que eu posso colocar qualquer valor no retorno: Exemplo:
def método retorno_1 = 5 retorno_2 = 20 return retorno_1 + retorno_2 end variável = método + 50 # variável terá o valor de „150‟

Você também pode retornar mais de um valor, utilizando vírgulas: Exemplo:
def método return 12, 64 end valor_1, valor_2 = método # valor_1 será 12 # valor_2 será 64 def método valor = 0 valor += 5 valor *= 4 return valor valor *= 5 valor -= 50 end variável = método # variável será 20

Eval Comando pouco utilizado, deve ser utilizado sempre seguido de uma string. Faz com que o conteúdo da string se transforme em um comando (como se tivesse apenas retirado as aspas).

Exemplo 1:
def método return 5 end variável = eval “método” # variável terá o valor de 5

Exemplo 2:
$scene = eval (“Scene_Title” + “.new”)

Exemplo 3:
def método eval “return” end

Exit Este é um comando extremamente simples, não tem muito que explicar. Ele simplesmente feicha o jogo. Como teste, crie um novo script acima de todos os outros e coloque simplesmente um „exit‟. Ao testar o jogo, o jogo irá feichar automaticamente, pois o exit está no começo dos scripts do jogo. Este é um comando utilizado eventualmente no caso de erros no jogo. Open O comando „open‟ servirá para carregar arquivos da pasta do jogo, como arquivos gráficos (pictures) e de Áudio. Este comando pode não ser muito útil pelo fato de o próprio RGSS já conter comandos padrões para este tipo de uso (para isso serve o módulo Cache, mas vocês vão aprender isso somente em aulas futuras). Para utilizar o comando „open‟ chame-o com o respectivo diretório do arquivo numa string entre parênteses logo após do nome do comando. (extensões de nome dos arquivos são necessários) Exemplo:
@picture = open(“Graphics\\Pictures\\Arquivo.png”) ou @picture = open(“Graphics/Pictures/Arquivo.png”)

OBS: Note que tanto „/‟ quanto „\‟ podem ser utilizados para separar as pastas do diretório, porém, quando é utilizada a barra inclinada para esquerda, é necessário duas barras, pôs „\‟ é um dígito utilizado para comandos pelos RPGMakers, logo, é necessário duas barras para o reconhecimento da mesma. p/print Vocês já devem saber para que servem os comandos „p‟ e „print‟, mas mesmo assim vou explicar: Ambos os comandos „p‟ e „print‟ criam uma janela de pop up padrão do Windows para exibir um determinado valor. A única diferença entre eles é que o comando „p‟, exibe o valor exatamente como ele é,

diferente do comando „print‟, que exibe o valor na forma de string (ou se preferir: „exibe o valor na forma que ele seria exibido no jogo‟). Exemplo:
print “String” p “String” print 1_000_000 p 1_000_000 print [1, 2, 3] p [1, 2, 3] print /Ragexp/ p /Ragexp/

OBS: Crie um novo script acima de todos os outros e coloque o exemplo acima depois dê um teste no jogo, e veja na prática a diferença dos comandos „p‟ para „print‟. Rand Este é um comando bem simples, e muito utilizado em RGSS. Ele cria um número aleatório qualquer em forma de integer entre 0 e um número máximo definido entre parênteses logo após comando. Exemplo:
variável_aleatória = rand(255) # o valor de „variável_aleatória‟ poderá ser qualquer um entre 0 e 255.

Se o valor máximo for definido como „0‟ ou não for definido, o comando retorna um número float (decimal) aleatório de 15 dígitos. Printf Este é um comando extremamente complexo, e confesso que nem eu sei exatamente usá-lo. Sua função é facilitar a substituição de valores contidos dentro de uma string por outros valores também em string. Um bom exemplo é o chat da batalha do RPGMaker VX, é utilizado sempre as mesmas frases (ex: “Fulano atacou o monstro!!”) porém, algumas palavras podem ser adicionadas/alteradas, como o número do dano e o autor da ação, por exemplo. Estes diálogos da batalha do RPGMaker VX são feitos através do comando „printf‟, que permite alterar algumas palavras dentro das strings. Para utilizar o comando é preciso colocar determinados valores entre parênteses, o primeiro valor é a mensagem principal, e os outros são os valores que serão substituídos. Você deverá colocar caracteres como „%‟ e „#‟ por exemplo, para serem substituídos pelos valores entre parênteses, porém não entendo exatamente como funcionam. Exemplo:
sprintf("%#b", 10) # => "0b1010" sprintf("%#010x", 10) # => "0x0000000a" sprintf("%#05x", 10) # => "0x00a" sprintf("%.*s", 5, "foobar") # => "fooba" sprintf("%s", [1, 2, 3]) sprintf("%p", [1, 2, 3]) # => "123" # => "[1, 2, 3]"

printf("%d", n & ~(-1 << n.size*8))

Outro Exemplo:
# A linha abaixo foi retirada da classe Window_PlayTime do RMXP, linha 33 text = sprintf("%02d:%02d:%02d", hour, min, sec)

save_data/load_data Estes dois comandos são utilizados especialmente para salvar e carregar jogos salvos. O comando „save_data‟ salva um determinado valor em um arquivo em qualquer diretório dentro da pasta do jogo. Para usá-lo utilize dois valores entre parênteses: o valor que deseja salvar, e o diretório a salvar. Exemplo:
save_data(5, “Arquivo”)

Crie um novo script acima de todos os outros, coloque o exemplo acima e teste o jogo, logo depois saia do jogo e olha na pasta do jogo, haverá um novo arquivo chamado “Arquivo”. Note que este novo arquivo não têm uma extensão de arquivo. Agora altere o comando para „save_data(5, “Arquivo.rxdata”)‟ ou „save_data(5, “Arquivo.rvdata”)‟ dependendo do amker que estiver utilizando. Após o teste de jogo haverá um novo arquivo na pasta, com nome “Arquivo”, mas agora com a extensão do maker. OBS: Não é obrigatório o uso da extensão rxdata/rvdata para a leitura do arquivo. O comando „load_data‟ carrega um arquivo salvo por meio do comando „save_data‟, para usá-lo basta colocar o diretório do arquivo entre parênteses. Exemplo:
load_data(“Arquivo”) ou, no caso do teste anterior: load_data(“Arquivo.rxdata”) load_data(“Arquivo.rvdata”)

Você pode observar, que nas classes Scene_Save(RMXP) e Scene_File(RMVX) os arquivos são salvos e carregados de forma diferente, é utilizado o módulo Marshal (que será estudado em aulas futuras, assim como Cache).

Tópico 3.1 Classes Internas do RGSS
Além dos scripts que aparecem na lista de scripts do editor, também existem mais scripts internos do RGSS, por exemplo: Cache, Bitmap, Window, Sprite, entre outros. Alguns deles estão expostos em suas respectivas páginas no arquivo help, outros não podem ser consultados, porém eles podem ser editados. Para editá-los, é utilizado o procedimento padrão para mexer em qualquer classe ou módulo („class Nome_da_Classe‟ ou „module Nome_do_Módulo‟). Cada uma destas classes são essenciais para que o jogo rode corretamente, por exemplo: „Input‟ permite a entrada de teclas do teclado/joystick, sem ele, os scripts não iriam saber quando o jogador aperta uma tecla; outro bom exemplo é o da classe „Bitmap‟, que permite exibir imagems, sem esta classe, não seria possível a exibição de nenhum tipo de imagem. As funções de cada uma das classes internas do RGSS serão explicadas

mais detalhadamente em aulas futuras. Segue abaixo a função básica das principais classes internas:
Classes Padrões do Ruby: Array: Permite o armazenamento de vários valores em uma única variável. Exception: Possui todas as informações necessárias para utilização de uma exceção. FalseClass: Pseudo-valor „false‟. (visto na aula 02) Hash: Permite o armazenamento de vários valores em uma única variável. File: Classe que permite o acesso aos conteúdos externos do jogo. (arquivos da pasta) MatchData: Gerencia o uso de Expressões Regulares. (Permite o uso de Ragexp) Class: Superclasse de todas as classes. Possui as informações necessárias para o uso de uma classe. NilClass: Pseudo-valor „nil‟, utilizado para quando uma variável não tem qualquer valor. Numeric: Superclasse de todas as classes que possuem um valor numérico. Integer: Classe que permite o uso de Números Inteiros. (..., -3, -2, 1, 0, 1, 2, 3, ...) Bignum: Integers (números inteiros) de valor extremamente grandes. Fixnum: Integers (números inteiros) que não são Bignums. Float: Classe que permite o uso de Números Racionais. (..., 0.8, 0.9, 1.0, 1.1, 1.2, ...) Range: Valor utilizado geralmente em estruturas „for‟. Armazena vários valores em uma ordem. Proc: Utilizado para salvar uma variável, e chamá-la quando for necessário. Ragexp: A expressão regular utilizada em Ruby. String: Permite o uso de valores escritos (texto). Symbol: Permite o uso de expressões símbolo. Time: Controla o tempo (tempo real) utilizado em scripts como “Tempo Real”. TrueClass: Pseudo-valor „true‟. (visto na aula 02) Classes Internas do RGSS: Bitmap: Exibe uma imagem, geralmente utilizado pelas classes Sprite e Plane. Color: Classe utilizada para mudar as cores principalmente de Bitmaps de Textos. Font: Permite o acesso às fontes do Windows para poder exibir textos. Plane: Semelhante à Sprite, com poucas diferenças. Rect: Utilizado para selecionar uma área do bitmap. Sprite: Gerencia as imagens em geral exibidas pelo jogo. Table: Utilizado como arrays multidimensionais (3D), arrays comuns não suportam tantos dados. Tilemap: Gerencia os tiles do mapa. Tone: Permite a mudança de tom de cor da imagem. (geralmente utilizado em battlers e characters) Viewport: Permite uma imagem ficar exibida por cima de uma outra. Window: Possui todas as informações necessárias para exibir uma janelinha padrão do jogo. RGSSError: Gerencia os erros padrões que possam ocorrer nas classes internas do RGSS. RPG::Sprite: Add-on de Sprite. Tem a mesma função que Sprite, porém, mais efeitos. (somente RMXP) RPG::Weather: Permite o uso do comando “opções de clima” do RPGMaker. (somente RMXP) Módulos Padrões do Ruby: Comparable: Permite o uso de condições de comparações. (==, >, <,

etc.) Enumerable: Contém informações necessárias para o desempenho correto de algumas classes. Errno: Contém informações sobre os erros que podem ocorrer nos scripts. FileTest: Permite verificar se um determinado arquivo realmente existe. Kernel: Superclasse de Object, que é a superclasse de todas as classes. Marshal: Facilita a leitura de arquivos do jogo. (utilizado principalmente em „load‟ e „save‟) Math: Permite a utilização de Floats. Módulos Internos do RGSS: Audio: Gerencia os arquivos de áudio. Graphics: Gerencia tudo que é exibido na tela, além da contagem de tempo. Input: Gerencia a entrada de teclas do teclado/joystick. RPG: Gerencia todas as outras informações do jogo, que não são scripts. (mapas, database, etc.) RPG::Cache: Facilita a leitura de arquivos gráficos do jogo. (no RMVX, se chama apenas „Cache‟)

Aula 6 – Métodos e Classes
Índice de Tópicos: 1.0 – Classes 2.0 – Métodos

Tópico 1.0 - Classes
O que são Classes? Como foi dito no início das aulas, Ruby é uma linguagem interpretada por objetos, as Classes são estes Objetos. A função das variáveis é alojar determinados valores, qualquer valor que possa ser representado por uma variável é uma classe. Definido uma Classe Classes são na verdade Constantes, variáveis fixas com determinados dados em si, portanto cada classe deve ter seu nome começando com uma letra maiúscula. Assim como as variáveis, as classes também devem ser declaradas, para criar ou alterar uma classe é utilizado o comando 'class' seguido do nome da classe e logo depois das alterações feitas naquela classe utiliza-se um 'end' para definir o fim das alterações feitas naquela classe. Exemplo:
classe Nova end

Como não existe nenhuma classe chamada Nova, eu estou declarando-a. Note que se for utilizando o método 'p' em 'Nova' antes de sua declaração (desta forma: 'p Nova') correrá um erro, já que a constante 'Nova' ainda não foi declarada, porém, se for utilizado este mesmo comando após a declaração da classe, o programa irá detectar a constante e irá exibir "Nova" na janelinha, pois o que foi enviado ao método Nova foi apenas a constante Nova. Somente com a classe Nova não iremos conseguir muita coisa, vamos criar uma nova variável logo após a declaração da classe nova, chamarei-a de 'classe_nova', mas você pode nomeá-la como bem entender.
class Nova end classe_nova = Nova.new

Utilizando o método 'new' eu fiz com que 'classe_nova' se transformasse em um novo objeto da classe Nova, ou uma outra Nova. OBS1: Métodos serão vistos ainda nesta aula. OBS2: O método 'new'(assim como alguns outros métodos básicos) é provido à todas as classes automaticamente. Para que fique mais claro o que eu fiz acima vou dar um exemplo:
ary = [2, 4] str = "texto"

Acima eu criei duas variáveis, cada um como um novo objeto das classes Array e String; ou seja, eu defini as duas novas variáveis como novas classes Array e String sem alterar as constantes. Foi o mesmo que eu fiz em 'classe_nova = Nova.new'. A única diferença é que Array e String são classes padrões do Ruby e por isso podem ser criadas desta forma mais fácil, porém, agora não à diferença alguma entre Array, String e Nova. Abaixo, mais um exemplo:
ary = Array.new str = String.new

Acima eu criei uma nova Array e uma nova String, se você utilizar o método 'p' para verificar os valores de 'ary' e 'str' os retornos serão: '[]' e ' "" '; pois serão uma Array e uma String recém criadas, sem nenhum valor nelas, logo, o exemplo acima seria o mesmo que utilizar o seguinte código:
ary = [] str = ""

OBS: Note que, nestes dois exemplos acima, se você utilizar o método 'print' ao envéz de 'p' não será exibido nada, pois 'print' lê os dados da forma como o programa irá exibir no jogo, e um texto vazio (String vazia, "") e um grupo de valores sem nenhum valor (Array vazia, []) não são nada. Agora que já expliquei a função do método 'new' e a diferença entre a constante e sua utilização, podemos voltar à nossa nova classe, a 'Nova'. Vou citar novamente o exemplo para recuperarmos a concentração no mesmo:
class Nova end classe_nova = Nova.new

Se você utilizar o método 'p' em 'classe_nova' após sua declaração irá obter o seguinte resultado: '#'(ou algum semelhante), isto ocorre porque tudo que nós fisemos até agora foi criar uma nova variável com o valor de Nova, porém, a classe Nova está totalmente vazia, por isto o programa lê a classe desta forma.

Tópico 2.0 - Métodos
Métodos são o que fasem as classes funcionarem, sem eles a programação não seria possível. Basicamente os métodos são como comandos que fasem as classes funcionarem, sem eles as classes seriam inúteis, assim como sem as classes os métodos perderiam grande parte de seu "poder". Cada método tem sua função específica, que pode ter um grande e importante papel no seu jogo, assim como pode também ser algo bem simples. Assim como as variáveis, os métodos precisam ser declarados, geralmente se utilizam métodos dentro das classes, mas também podem ser utilizados fora das classes. Métodos declarados dentro das classes pertencem única e exclusivamente àquela classe, se você deseja utilizar este método a partir de outra classe deverá copiar o método e colar nesta outra classe. Para declarar um método você deve utilizar a palavra 'def', seguida do nome do método que você está criando, e depois do conteúdo do método um 'end' para definir o fim do

método. O nome do método deve ser constituído de apenas letras minúsculas e underlines(_). Exemplo:
def nome_do_método end

Para chamar um método já declarado, deve-se chamar simplesmente pelo nome do mesmo, no caso do exemplo acima, para chamar o método declarado deveria ser utilizado a simples expressão "nome_do_método". Quando um método é chamado, ele irá executar todos os comandos que estiverem dentrod ele. Exemplo de uso de um método: (Você copiar o exemplo abaixo para seu editor e testar o jogo para ver o que acontecerá)
def aumentar_variavel variavel += 20 end variavel = 10 aumentar_variavel p variavel # => 30

No exemplo acima, foi executado o comando 'variavel += 20' quando foi chamado o código 'aumentar_variavel', logo, subentende-se que quando um método é chamado todo o código que estava dentro dele fosse para o local onde o método foi chamado. Métodos também podem chamar outros métodos dentro de seu código, mas nunca podem chamar a si mesmos, neste caso ocorreria um erro. Exemplo:
def aumentar_variavel variavel += 20 aumentar_mais_ainda end def aumentar_mais_ainda variavel += 30 end variavel = 10 aumentar_variavel aumentar_mais_ainda p variavel # => 90

Se você não entendeu o porquê de 'variavel' ter o valor de 90 no final do código, vou esplicar mais detalhadamente o que aconteceu: (Se entendeu, pode pular esta parte de verde) Primeiro, foram declarados os métodos 'aumentar_variavel' e 'aumentar_mais_ainda', 'aumentar_variavel' irá aumentar o valor de 'variavel' em 20 e depois irá chamar o método 'aumentar_mais_ainda' que, por sua vez, aumenta em 30 a 'variavel', logo, o método 'aumentar_variável' terá a função de aumentar 'variavel' em 50. Depois, 'variavel' foi declarado como '10' (Se esta linha não existir, haverá um erro ao chamar um dos métodos, pois 'variável' não estará declarada ainda) Então é chamado o método 'aumentar_variavel', que aumenta o valor de 'variavel' em 50, passando seu valor para

60 (porque 'variavel' já tinha o valor de 10, e 10 + 50 = 60). E em seguida é chamado o método 'aumentar_mais_ainda', que aumenta o valor de 'variavel' em 30, passando seu valor para 90. Substituição de Métodos Se você tantar declarar um método já declarado, o método anterior será apagado, e o novo ficará no lugar. Exemplo:
def aumentar_variavel variavel += 20 aumentar_mais_ainda end def aumentar_mais_ainda variavel += 30 end def aumentar_variavel variavel -= 20 end variavel = 10 aumentar_variavel aumentar_mais_ainda p variavel # => 20

Quebra de Métodos/Retorno Você pode "quebrar" a execução de um método utilizando o comando "return". Quando "return" for executado, nenhum código que vir depois dele num mesmo método será executado. Exemplo:
def aumentar_variavel variavel += 20 if variavel == 30 return end variavel += 40 end variavel = 10 aumentar_variavel p variavel # => 30

No exemplo acima, o comando "return" que está no método 'aumentar_variavel' será executado se o valor de 'variavel' for igual a 30, como 'variavel' foi declarada como 10 e antes da condição o valor é aumentado em 20, a expressão condicional retornará true e assim a condição será executada, então o comando 'return' fará com que a execução do método seja "quebrada" e assim, o comando 'variavel += 40' não será executado. Se você alterar o valor da declaração de 'variavel', a condição retornará true, e assim, o comando 'return' não será executado, e sim o comando 'variavel += 40'. O comando "return" não serve somente para quebrar a execução do método, mas também servirá para retornar um determinado valor que for utilizado juntamente com ele. Como você já aprendeu sobre retorno na lição sobre condições, retorno é quando o

comando é substituido pelo valor de retorno, no caos dos métodos, o comando de chamar o método será substituido pelo valor de retorno. Exemplo:
def vinte return 20 end variavel = vinte p vatiavel # => 20 p vinte # => 20

É claro que, como o método vinte será substituído por '20', eu poderia utilizá-lo de várias formas, como por exemplo, esta:
def vinte return 20 end variavel = 50 + vinte

Outro exemplo de retorno:
def metodo1 return "Dark" end def metodo2 return "Chocobo" end var1 var2 var3 var4 var5 = = = = = metodo1 + metodo2 "Dark" + metodo2 metodo1 + "Chocobo" "Dark" + "Chocobo" "DarkChocobo"

Todas as 5 variáveis(var1, var2, var3, var4 e var5) terão um mesmo valor em comum, a string "DarkChocobo". Eviando Valores aos Métodos Também é possível enviar determinados valores ao chamar os métodos. Alguns métodos necessitam de alguns valores para serem executados corretamente. Para que um o necessite de um valor você deve, ao declará-lo, declarar também variáveis locais dentro de um parênteses, logo após o nome do método(as para isto apenas nomeie as variáveis separando-as por vírgulas). Exemplos de métodos que necessitam de um ou mais valores:
def metodo1(valor) end def metodo2(valor1, valor2, valor3) end

OBS: Cada método pode necessitar de quantos valores for necessário. Para chamar um método que precisa de algum valor, você deve determinar este valor logo após chamar o método (separados por um espaço); você pode usar qualquer tipo de valor. Quando um método necessitar de mais de um valor, você deve usar vírgulas para selará-los.

Exemplos:
metodo1 1 metodo1 "string" metodo1 [1, "array"] metodo2(1, 2, 3) metodo2(0, "texto", ["array"])

OBS: Note que em alguns exemplos foram usados parênteses e em outros não, não é obrigatório o uso de parênteses ao enviar os valores aos métodos, porém, usando-os, você deixa o seu script mais organizado, por isto é muito comum encontrá-los em exemplos como este. Quando um valor é enviado para um método desta forma, o método faz com que as variáveis locais que você declarou tomem o valor dos valores enviados ao método. Exemplo:
def meu_nome(str) p str + "Chocobo" end meu_nome("Dark")

No exemplo acima, a mensagem que será exibida é "DarkChocobo", pois ao chamar o método 'meu_nome' enviando a string "Dark", você fará com que o método 'meu_nome' seja executado considerando que 'str' seja "Dark", e assim 'str + "Chocobo"' será "DarkChocobo". Outro exemplo de envio de valores aos métodos:
def juntar_arrays(a, b) return a + b end ary1 = [1, 2, 3, 4] ary2 = [5, 6, 7, 8] p juntar_arrays(ary1, ary2) # => [1, 2, 3, 4, 5, 6, 7, 8]

Aula 7 - Sprites
A classe Sprite representa uma imagem, ela possui vários métodos e propriedades.
@var = Sprite.new(viewport) @var.bitmap = RPG::Cache.picture("nome") # RPG Maker XP @var.bitmap = Cache.picture("nome") # RPG Maker VX

No exemplo acima foi considerado o sprite como uma picture, porém ele pode ser um ícone, um character, etc. Tudo que for gráfico e estiver no jogo. O argumento viewport não é obrigratório, ele está implícito.

Tópico 1.0 - Métodos
bitmap => Cria a imagem. disposed? => Retorna true se a imagem foi deletada. update => Atualiza a imagem. widht/height => Respectivamente, largura e altura da imagem.

Tópico 2.0 - Propriedades
viewport(view) => Indica o viewport que a imagem será criada. visible => true/false para exibir a imagem. x/y/z => Respectivamente, posição X, Y e prioridade. zoom_x/zoom_y => Respectivamente zoom na coordenada X e Y. angle = 0~360 => Angulo da imagem. mirror => true para inverter a imagem. opacity = 0~255 => Transparencia da imagem. color/tone => Respectivamente a tonalidade e cor. blend_type = 0/1/2 => Tipo de imagem, normal, multiplicar e inverter

Há também os comandos:
wave_amp (RGSS2) wave_length (RGSS2) wave_speed (RGSS2) wave_phase (RGSS2)

Estes comandos dão uma espécie de onda na imagem, a imagem fica ondulada, como é o caso nas batalhas.
wave_amp = n => Amplitude da onda. wave_lenght = n => Frequencia da onda. wave_speed = n => Velocidade do movimento. wave_phase = 0~360

A classe Sprite é bem útil, ele é usada em menus,batalhas, windows, etc. Esta classe é uma das que voce pode usar de qualquer forma, além de possuir uma grande quantidade de métodos, teste modificar no Scene_Title a sprite do título, colocando esses métodos e efeitos de onda, voce pode consultar outros scripts do maker.

Aula 8 - Plane
A classe Plane é capaz de realizar movimentos em imagens, tanto vertical como horizontal. Esta classe, assim como Sprite dependem da Bitmap, portanto para criar a imagem, usamos o método Bitmap, e depois definimos como quisermos, Sprite, Plane, etc.
@var = Plane.new @var.bitmap = Cache.picture("nome")

Tópico 1.0 - Métodos
dispose => Apaga a imagem. disposed? => Verifica se a imagem está apagada, retorna true se ela estiver. bitmap => Criar imagem. viewport => Refere-se ao viewport da imagem, a camada. ox -= 1 => O comando principal, ele move a imagem na coordenada X. oy += 3=> o comando principal, ele move a imagem na coordenada Y. z = 55 => Prioridade. opacity = 90 => Opacidade da imagem. zoom_x = 1.2 => Zoom na coordenada X. zoom_y 0.5 => Zoom na coordenada Y. blend_type => 0: normal - 1: Multiplicar - 2: Inverter tone => Refere-se a tonalidade da imagem. color => Refere-se a cor da imagem.

OBS: Note que estes exemplos que usam números, são só exemplos!

Tópico 2.0 - Exemplos
Você pode tomar como exemplo o da aula do Bitmap. Eu vou citar outro bem simples. Vá no Scene_Title e procure no def create_title_graphic e na linha:
@sprite = Sprite.new

Esta linha indica que a variável @sprite é um Sprite, porém bastar trocar por isto:
@sprite = Plane.new

Teste o jogo e voce verá que nada mudou... Bem, o legal vem agora! Vá no def update e depois do super escreva:
@sprite.ox -=2 @sprite.oy += 2

Agora teste e veja que a imagem começa a subir na direção direita, a velocidade é o 2, significa que a cada frame a imagem sobe 2 pixels e vai para direita 2 pixels. Basta usar sua criatividade, este comando é bem útil, e dá um efeito muito bom em menus, por exemplo.

Aula 9 - Bitmap
A classe Bitmap serve para nós criamos coisas relacionadas a imagens e gráficos, não necessariamente imagens, esta aula fala sobre o comando Bitmap, porem usa como exemplos Sprite e Plane, que serão estudados mais a frente. OBS 1: O Sprite e Plane, podem ser classificados como parentes proximos da Bitmap, porque eles são digamos que, filhos dela, herdam alguns métodos. Basicamente, uma imagem pode ser carregada, editada, e deletada com códigos simples e fáceis, é só saber usar os métodos. Vamos começar com o sprite. O que é um Sprite? São 'filhas' da classe Bitmap, elas são cópias dela, a imagem propriamente dita.

Tópico 1.0 - Sintaxe
@var = Sprite.new @var.bitmap = Cache.picture("nome_do_arquivo")

OBS 1: A ultima parte só é válida para o VX, que usa o método Cache.picture. OBS 2: Cache.picture é apenas um exemplo, porque além dele, existe também: Cache.animation, Cache.battler, Cache.face.... Para ver é só ir ao módulo 'Cache'. OBS 3: Não precisa informar o formato da imagem.

Tópico 2.0 - Métodos
z = integer => prioridade da imagem, quanto maior, mais visivel ficará. dispose => apaga a imagem. width e height = integer => muda o comprimento e altura respectivamente. blur e radial_blur => dão uma distorçao na imagem. clear => limpa a imagem. draw_text(x, y, largura, altura, text) => escreve um texto. (text = string)

Esses são os mais usados, há outros também, como o rect, disposed?, blt... Consule-os no arquivo anexado do RGSS.

Aula 10 - Rect
Nesta aula, vou falar sobre o comando Rect, que serve para criar retângulos. Vamos lá! Lembrando que vamos usar uma window como exemplo. Para criar um retângulo, use o código:
@variavel = Rect.new(x, y, largura, altura)

Para preencher o retângulo, usamos:
self.contents.fill_rect(rect, cor)

Ou seja, rect significa a variável em que esta o rect, que no caso é @variável. E cor significa a cor do rect, pode ser Color.new(red,green,blue) ou pelas cores do Window_Base: normal_color, system_color, crisis_color,etc... Ou, desta forma:
self.contents.fill_rect(x, y, largura, altura, cor)

Neste método, você não precisa criar uma variável pro rect, o comando já cria um rect com os dados que você fornece. Podemos também usar o gradient_fill_rect, que da um efeito bem legal de gradiente, ele mistura duas cores e forma um gráfico:
self.contents.gradient_fill_rect(rect, cor1, cor2)

OBS: Desta forma, nós precisaremos da variável que representa o Rect. Ou, da outra forma, que não precisa de variáveis:
self.contents.gradient_fill_rect(x, y, largura, altura, cor1, cor2)

Vou dar um exemplo de um rect com gradiente:

Neste exemplo, o código cria a janela e o rect. Apenas faça isso e crie um evento com o Código: Window_Jao.new Tentem atribuir um valor para o rect, por exemplo: @largura = 50 * @width / 100. Onde 50 e um valor qualquer e width é a largura do rect, e / 100 significa porcentagem. É assim que funcionam as barras de HP/SP, basta ver o cálculo na Window_Base.

Aula 11 - Viewport
Índice de Tópicos: Tópico 1.0 – Sintaxe Tópico 2.0 – Métodos Tópico 3.0 – Exemplos A classe Viewport é muito importante, ela "fatia" a imagem, ou seja, definimogs qual o tamanho da imagem, altura, largura e posição x/y. Com ela, podemos fazer muitas coisas interessantes, principalmente com sprites e planes.

Tópico 1.0 - Sintaxe
@viewport = Viewport.new(X, Y, Largura, Altura) # assim @viewport = Viewport.new(rect) # ou assim

Todas as formas são iguais, só muda que a segunda precisa de uma variável que representa Rect.

Tópico 2.0 - Métodos
dispose => Apaga o viewport. disposed? => Se a imagem estiver apagada, retorna true. flash(cor, tempo) => Define o flash e o tempo que ocorrerá no viewport, se cor for nil, o viewport irá desaparecer no flash. visible => Mostrar o viewport (true) e não mostrar (false). tone/color => Tom e cor do viewport. z => Prioridade do viewport, se múltiplos objetos usam a mesma prioridade, o mais recente terá mais prioridade.

Tópico 3.0 - Exemplo
Vamos agora falar do que interessa, na verdade há várias formas de usar este comando, eu vou usar no Title, por isso, crie um novo jogo e vá ao Scene_Title. Vá no "def create_title_graphic" e substitua-o por isto:
def create_title_graphic @v1 = Viewport.new(0, 0, 260, 416) @v2 = Viewport.new(284, 0, 260, 416) @sprite2 = Plane.new(@v2) @sprite2.bitmap = Cache.system("Title") @sprite = Plane.new(@v1) @sprite.bitmap = Cache.system("Title") end

Agora vá no def update e logo abaixo do super, escreva:
@sprite.ox += 2 @sprite2.ox -= 2

Se você testar, vai ver que ficou uma coisa bem louca, basicamente viewports fazem isso. Porém, eu fiz uma demonstração bem básica do poder que eles têm. Os viewports fazem basicamente isso: Cortam o objeto com o tamanho que voce decidiu altura e largura, e colocam-no na posição x e y. Para atribuir um viewport a o objeto, é só fazer como eu disse:
@objeto = Plane.new(@var_do_viewport) # Lembrando que Plane é um exemplo.

O interessante seria misturar tudo como eu fiz, por exemplo, coloquei viewports e Planes no script, que dá um efeito muito interessante, não acha? Principalmente se voce mesmo fizer uma imagem bem legal, imagina os efeitos que o viewport e plane podem fazer!

Aula 12 - Windows
Começaremos a estudar sobre as Windows, também chamadas de janelas, praticamente são a base dos scripts visuais. Ou seja, sua importância é muito grande. Na figura abaixo, vamos identificar janelas. A partir daqui começaremos a fazer nossos scripts, por mais simples que sejam, mostram que vocês evoluíram. Vamos aprender como criar uma janela básica. Primeiramente devemos saber o que é herança. Em uma de nossas aulas falamos um pouco sobre isso. Para criar uma janela devemos fazer herança. Neste caso será com a Window_Base.
class Teste < Window_Base def initialize super(x,y,altura,largura) refresh end def refresh self.contents.draw_text(0,0,self.width,self.height,”texto”) end end

Note que há dois métodos na classe, ou seja, as janelas normalmente utilizam um, mas para organizar usamos dois. Por exemplo, o def initialize serve para nós organizarmos as variáveis e opções da janela, e o refresh serve para digitarmos o texto. Toda vez que quisermos criar uma janela, temos que usar herança, sem ela não dá! Portanto geralmente usamos a Window_Base como pai da nova classe. Toda window tem que ter a seguinte base:
class Seu_Nome < Window_Base def initialize super(10,10,100,200) end end

No super, apenas substitui as variáveis de posição x, posição y, largura e altura por números quaisquer. A base da janela são textos, ou seja, usaremos muito o comando draw_text.
self.contents.draw_text(4, WLH * 0, 92, WLH, Vocab::weapon1)

(Exemplo extraído da classe Window_Equip do VX.) Em outras aulas, vimos que alguns métodos necessitam de valores, também chamados de argumentos, devemos seguir esta regra, o método draw_text requer 5 argumentos (que são separados por virgula); posição x, posição y, largura do texto, altura do texto e texto. Onde texto deve estar dentro de aspas, ou seja , uma string. Bom, vamos começar então a usá-las, de uma forma bem simples, mas que dá um efeito bem legal de início. Crie uma classe e escreva o código:

class Window_Jão < Window_Base def initialize super(10,10,300,60) self.contents.draw_text(0,0,300,30,"Digite seu texto aqui!") end end

Logo após, vá ao script Scene_Map e no def start coloque antes do end:
@jao = Window_Jão.new

No def terminate coloque depois do @message_window.dispose:
@jao.dispose

Finalmente, no def update depois do @message_window.update:
@jao.update

Isso faz com que automaticamente a janela entre no mapa sem ter que chamarmos, e fica infinitamente lá. Teste o jogo e veja a window. Antes de prosseguir, um detalhe, como vimos, na CLASSE da janela, usamos o self. Mas se usarmos em outro script, como no scene map, veremos que vai dar erro, porque o self indica a classe em si, e o RGSS não vai saber diferenciar, portanto tudo que formos fazer com a janela, fazemos na sua VARIÁVEL. Agora chegaremos a uma parte interessante, o que dá vida a janela, os métodos. Citarei alguns, pois são diversos, estes métodos são da Window_Base, caso queira ver todos seus métodos, basta consultá-la e ver os seus def‟s. No def initialize, logo abaixo do super, coloque os códigos.
self.opacity = 150 self.visible = true self.back_opacity = 10 self.contents_opacity = 150 # # # # opacidade da janela - 0~255 visibilidade da janela opacidade do interior da janela conteúdo da janela (texto por exemplo)

Esses métodos, são os responsáveis por alterar a estética da janela, e se você ver no Window_Base, ela é filha da Window que é uma classe interna do ruby, ou seja ela está embutida lá. Portanto, toda janela criada que possua herança da base poderá ter estes métodos. Em suma:
self.opacity = 0-255 indica a opacidade total da janela (exceto o seu conteúdo) self.visible = true/false indica se a janela esta ou não visível self.back_opacity = 0-255 indica a opacidade do interior, e não da borda da windowskin self.contents_opacity = 0-255 indica a opacidade de todo o conteúdo da janela

Lembrem-se de que você pode pegar qualquer def (método) da Window_Base e jogar nessa janela, é muito aconselhável você fazer isso. Podemos concluir que:

1. self.contents_opacity = 0 é igual a: self.visible = false porque ambos estão nulos. A diferença é que a opacidade total pode-se alterar entre 0 e 255 e a visible é totalmente visível, ou não. 2. Vimos que para criar janelas, precisamos de um super, que indica sua posição x, posição y, largura e altura; 3. Precisamos de herança para que a janela seja criada; 4. Colocar métodos do script Window e Window_Base; 5. Não usar o self num outro script, e sim criar uma variável; 6. E aprenderemos mais sobre elas na próxima aula, que vai ser sobre Scenes, que envolverá as janelas.

Aula 13 - Scenes
O que são Scenes? Scenes são na tradução bruta, um conjunto de windows, em que há interação entre elas. Para que eu uso elas? Bom, por exemplo, a Scene_Menu é um conjunto de janelas, que podemos interagir para escolher o que fazer, acessar itens,habilidades,status,salvar,etc... As scenes servem para organizar e facilitar o trabalho dos scripters. Tá, mas o que eu tenho que fazer? Na verdade você tem que criar uma Window, e na Scene chamá-la através de uma variável correspondente a Window. Bom, para iniciar é preciso dizer que Scenes é o que chamamos de classe artificial, porque não muda em nada o nome do script ser Scene_Menu ou Cena_Menu (lembrando que se o nome for Cena_Menu teremos que chamá-lo sempre com este nome), Scene suponhamos que seja só para orientar. Vamos usar Scenes, ou seja, quase todos scripts que usam interação com Windows, animações, etc são Scenes, lembrando que há outros nomes – no RGSS o nome da classe não importa -, como você já deve saber, nos orientamos pelo script, pelo seu nome – ou nome da class -, portanto, tenha muito cuidado com isso, pode ser que, ele não tenha nome de Scene, mas seja uma Scene ou vice-versa. Como disse, Scenes é um nome que só serve para diferenciar ou classificar scripts. Para usar uma Scene, tomarei base o RGSS2 que usa uma classe Base, a Scene_Base, uma coisa que no XP não existia. Se você estiver usando o VX e quiser criar uma Scene, use a herança < Scene_Base. Depois crie um def initialize para organizar dados parciais, como declarar uma variável para Windows, depois vem o método main, onde tudo ocorre na Scene, há vários outros, como o update, não sei dizer ao certo se os métodos „main,initialize e update‟ são “oficiais” ou são inventados para classificar como o nome Scene e Window. Há certos casos que precisamos usar o update para por exemplo, animar uma Scene ou atualizar após algum método ser chamado. Eu costumo fazer em meus menus uma animação, que servirá de exemplo para esta aula... Vá no def update, tomemos como exemplo a variável time, que se refere a janela de tempo;
@time.y -= 5 if @time.y <= 366 @time.y = 366 end

Nela, o código @time.y -= 5 significa que ela subirá na posição y em velocidade 5, e se a posição y for menor ou igual a 366, ela para em 366, assim como todas outras, isso serve para que se ela for maior/menor que 366, ela não continue subindo eternamente pela tela, e pare na posição 366y.

Aula 14 - Comandos de Windows
Para começar, toda Window herda métodos das windows: Command,Selectable ou Base. Segue a ordem: Window > Window_Base > Window_Selectable > Window_Command A classe "Window" esta oculta no RGSS. A window_base serve para qualquer uso de windows, tanto para textos, imagens,etc, exceto comandos e seleções, por isso existe a Selectable para selecionar itens, como os scripts Scene_Item e Skill. E a Command, serve logicamente para criar comandos pelas janelas, como é o caso da Scene_Title, End e a janela de comandos do Menu. Como diferenciá-las? Simples, a Window_Base tem tudo, menos comandos e seleções, a Selectable geralmente tem muitas seleções, como é o caso dos itens, que são diversos, já a Command apresenta comandos específicos, por exemplo, você cria a janela pelo código:
@var = Window_Command.new(largura,["comando1","..."])

Já as outras, geralmente são criadas por classe, mas podem ser criadas por variáveis (isso pode ser um pouco complexo, mas não é, basta saber usar argumentos). Não vou comentar nas minhas aulas sobre a Selectable, pois não tem muito pra se falar. Nesta vou começar falando da Base, mostrando os comandos. Vamos lá! Logo de cara, no inicio do script, você vê o def initialize, e um código dentro dos parênteses, isso é chamado argumento, são códigos que precisam ser especificados quando chamamos uma classe. Então deduzimos que para chamar a Window_Base precisamos especificar a posição X e Y e a largura e altura da janela. Há também comandos como 'self.', isto indica que a ação será feita na própria classe, neste caso a Window. O exemplo: self.back_opacity = 200 indica que a opacidade da janela será 200. Uma pergunta, por que especificar com o self e não usando variáveis? Simples, porque se usássemos uma variável, teríamos que usar em toda classe filha da base, o self indica que a ação ocorrerá com a classe em si, e não com a classe em um devido momento, visto que podemos usar a mesma Window em várias Scenes, como no caso a Window_Help. Tá, chega de enrolação, vamos para os métodos! O método draw_icon e novo no VX, infelizmente no XP não havia. Para desenhar um ícone na Window, basta usar: draw_icon(numero do ícone, x, y). O numero do ícone significa que você deve especificar o ícone, porque como vimos, o ícone é uma imagem só, feita com vários ícones, o RPG Maker automaticamente divide os ícones, então teremos que contar o ícone. O método draw_face, também novo no VX, não existe no XP, ele desenha uma face

qualquer, desde que especificada: draw_face(face_name, face_index, x, y) face_name indica o nome do arquivo, que deve ser expresso em aspas,face_index é o id da face, vide o numero do ícone, e o X e Y nem precisa explicar. O método draw_character desenha o gráfico do personagem,
draw_character(character_name, character_index, x, y). A mesma

explicação do draw_face. O método draw_actor_hp(actor, x, y) Desenha o gráfico do HP do herói, lembrando que a variável actor deve ser especificada (eu não sei como é no VX, mas no XP é: actor = $game_actors[id]). O método draw_currency_value(value, x, y, width) serve para você escrever o valor exato e atual de uma certa coisa, no caso é para Gold, veja que o Gold se refere a
$game_party.gold

Por fim, há o mais conhecido, o draw_text, ele deve ser feito com o self.contents:
self.contents.draw_text(x, y, largura, altura,"texto")

Há também o opacity, que indica a transparência da janela, podemos usar tanto o self como uma variável. OBS: self é uma pseudo-variável, você não pode usar self em uma Scene, porque não esta especificando qual janela você quer alterar. Em uma Scene, devemos usar o opacity na variável que retrata a janela. O z indica a prioridade, quanto maior, mais prioridade terá. E por fim, o visible = true/false indica que quando false, a janela não será visível, e quando true, será.

Quem preferir baixar aqui está o link Biblia DO RGSS em PDF

Creditos ao Jão e DarkChocobo
Maverick~ (eu) por arrumar os BBCodes e postar

1 Biblia RGSS [Tópico 3] 23/8/2012, 17:16

Maverick ~