Centro RPG Maker

Atualização 24/03/2024

Me alegra saber que as aulas a seguir foram de grande utilidade para vários membros da comunidade que hoje se tornaram programadores profissionais e alcançaram rumos elevados em suas carreiras de desenvolvedores de jogos. Dito isso, foi tudo graças aos esforços de cada indivíduo em aprender programação, as aulas serviram apenas como um pontapé inicial, uma direção para aqueles que não souberam por onde começar e/ou sentiam-se intimidados por conta da complexidade que é o mundo dos códigos.

Eu criei estas aulas há muito tempo atrás, quando ainda era novato nessa área mas ansioso para compartilhar o que havia aprendido, dado que eram tempos onde conteúdo desse tipo em português era escasso, uma realidade completamente diferente do que vemos hoje em 2024. O trabalho é amador, contém alguns erros e várias coisas que eu faria diferente hoje em dia, porém me falta o mesmo tempo que antes.

Infelizmente estas aulas estão em um canal associado a uma conta que eu já pretendia me livrar faz alguns anos. Felizmente o nosso amigo @SC19 fez um backup delas aqui onde estarei redirecionando todos os links. Você também pode baixar todas as aulas aqui para arquivamento e/ou consumo offline.

Vale notar que o ícone da aula 4 se perdeu e não está incluso abaixo, porém a aula está acessível nos links acima.

Tópico Original

◆ Introdução

Eu havia mencionado que faria umas aulas de programação pro pessoal, e já venho aqui deixar o tópico preparativo.
As aulas que serão postadas aqui serão de Ruby. O intuito é fazer elas o mais curtas possível, sem enrolar muito e indo direto ao assunto.
Aproveite para tirar suas dúvidas sobre as aulas aqui também.

◆ Aulas Básicas

◆ Aulas Intermediárias

◆ Aulas Avançadas

Muito legal, vou acompanhar, e tipo tem como gravar umas aulas focando na programação do maker, tipo palavras reservadas que só tem no maker. Como por exemplo eu posso ser um mestre em Ruby, mas nunca ter visto o rpgmaker, não teria dificuldades de certo modo também? Vejo aulas de Ruby, mas não vejo falar da programação do próprio maker.

Claro que sim, assim que chegar a hora e eu tiver ensinado as coisas necessárias, estarei ensinando coisas sobre como criar janelas, sprites, scenes e até mesmo estarei ensinando como criar scripts para o maker em si. Mas até lá, vou ensinando o básico pra não acabar ensinando as coisas pela metade ^^

Já peguei meu tilibra (46 folhas) o/ Só aguardando o início

A próxima aula está prestes a sair, fiquem de olho :D

Segunda aula lançada. Na próxima estaremos aprendendo a fazer condições, como if, else e elsif.
Nesta aula eu tive alguns probleminhas com o timing das coisas, me perdoem ;-;

Ainda não consegui assistir pela carroça, vulgo celular.

Edit:
Aulas excelentes! Para quem não tem noção nenhuma o/ estão bem claras.
Na segunda, quando você começa a explicar sobre as operações, não coube na tela o que você digitou no script, mas ficou bem explicado. Eu é que tenho problemas sérios com números. Para fazer contas simples eu preciso de gráficos, desenhos haha

Muito boa sua proposta! irei assistir suas aulas em breve! ^^

Poe: Haha' imagine a minha na hora de editar. É uma tristeza.

bruno: Eu agradeço, se tiver qualquer dúvida, não hesite em questionar aqui :)

Opa!me atrasei um pouco pro inicio das aulas. :T.T: :T.T:
Assisti as duas primeira e foi muito fácil de entender tudo ensinado.
Estou animado pra próximas aulas alisson sensei :lol:

A aula de condições está pronta, galera!
Se tiverem alguma dúvida, basta deixarem aqui.

E acabamos de aprender um truque muito bom para não precisar colocar condições dentro das condições dentro das condições do evento. Dúvida: Se eu precisar fazer algo semelhante ao último exemplo, funciona se escrever todo o código no "Chamar Script"?

Fui mexer no gerador e fiz bagunça. Estou reinstalando o maker para testar essas aulas :x

Tudo o que aprendemos nessa última aula funciona perfeitamente no chamar script.
Caso for usar switches e variáveis, você pode usar $game_switches[número] e $game_variables[número] durante as condições para checar diversas coisas sem precisar fazer várias condições.

A propósito, no comando de condições, não sei se repararam, mas há uma opção de "script" nele. Vocês podem usar aquilo também :)

Aula número 4 lançada com sucesso.
Nesta aula, aprenderemos o uso do Case e teremos uma pequena introdução aos métodos.

Opa! Só passando para continuar os estudos.
Case então é um modo de aplicar várias condições à uma mesma variável, certo? E sobre os métodos, entendi porque sempre ficam separadinhos nos scripts, prontos para serem chamados o/

Moço. Disponibiliza esse videos para download haha Meu aTubeCath* não está funcionando.

Exatamente!
Ao contrário do if, o case é mais utilizado para realizar inúmeras condições em uma variável.
Pode deixar que vou colocar xD

Como faço faculdade de Ciência da Computação, até a aula 3, eu já meio que sabia né rs só que em Ruby é elsif não else if. Vou assistir a aula 4 daqui a pouco, acho que agora começa!

Sim, em ruby é elsif ao invés de else if, como nas outras linguagens, o que acaba confundindo muitos que migram de outras, haha'
E pode acompanhar, daqui pra frente o bicho começa :v

Quinta aula lançada. Dessa vez eu tentei cobrir um pouco sobre os argumentos dos métodos.

Métodos e Funções são tipo Bolacha e Biscoito, para esclarecer.

Darei um jeito de disponibilizar as aulas para download assim que possível.

Ta bem fácil de entender suas aulas hehe, espero poder ver mais delas.
hummm caped baldy... acho que entendi a referencia.

Fico feliz em saber disso :)
melhor herói hauhau

Mais uma aula excelente o/ O que mais gosto é que não chegam a três minutos. Enrolação zero.
Não peguei a referência do cabeça de ovo :(

Suas aulas são bem diretas. Estou gostando. Esperando as próximas aulas! Abraços.

Aula número 6 lançada. Nela estaremos aprendendo sobre o return.

Curiosidade: Em linguagens como C, o uso do return é obrigatório. Já em linguagens como ruby, o valor do return geralmente será a "última linha de código" de um método.

 :wow: :wow: :wow: :wow: :wow: :wow: :wow: :wow: :wow:
agora vou poder finalmente aprender isso de vez! haha!
Vou acompanhar essas aulas

Opa! Mais uma, agradecemos. Entendi, sobre o return, o seguinte:

Podemos chamar o Game Over?
             Não
             Não porque o herói está vivo
             Não por etc

Seria uma mistura de exceção, ir ao label e (talvez) apagar "método" temporário? Em linguagens de eventos haha. Uma vez que ele sai do método, o mesmo precisa ser chamado novamente, certo?

Exatamente isso, Poe. Entendeu perfeitamente, haha'
E sim, uma vez que ele sai do método, ele precisa ser chamado novamente.

Deixando meu comentário aqui só pra acompanhar, sabe como é, apesar do tempo estar bem saturado, sempre existem alguns segundos para aprender alguma coisa extra. :v

Aliás, ótima ideia essa Alisson, te amo cara. <3 asjaushahs

Aula número 7 lançada.
Arrays. O que elas são? Como funcionam? Amanhã, no Jornal Nacional Maker!

Desculpe se explicou no vídeo, mas tive que assistir em baixa qualidade e ficou difícil de ler. Há um limite máximo de elementos para uma array? E é possível alterar esses valores da mesma forma como se altera uma variável? Ex:

Mudar o segundo elemento da array X para 2, o terceiro para 1, sem alterar o primeiro.

Dependendo, são até mais práticas. Tipo, usar umas cinco arrays em um sistema e não espalhar quinze variáveis. Do mesmo modo com usamos uma variável fazendo as vezes de vários switches nos eventos.

Você pode ter infinitos elementos em arrays (não que alguém vá precisar de tanta coisa, haha)
E sim, você pode alterar qualquer elemento da array assim como altera em uma variável normal. Basta identificar o index dele (a posição do elemento, começando por 0) e começar a fazer as operações que quiser.

Ex: minha_array[0] += 1

Parabéns Alisson, as aulas realmente foram muito boas, consegui fazer altas coisinhas aqui brincando com as variáveis. Coisas que nem pensava em fazer antes de suas aulas.

Já assisti as 7 e aguardo ancioso pela próxima  :wow: :wow: :wow:

Aqui, alguns dos scripts
Aula 2

Spoiler

Código Selecionar Expand

################################################################
#As primeiras aulas de Ruby serão para testar algumas variáveis#
#executando operadores simples, e ver as igualdades            #
################################################################

num1 = 20 #Aqui eu guardei o valor da variável 1 #
num2 = 5  #Aqui foi salvo  o valor da variável 2 #
num3 = 13
num4 = 30
num5 = 100

string1 = "Acertou mizerave!"                 #As strings armazenarão os textos que     #
string2 = "ERROOOOOWWWWWW!"                   #serão exibidos na janela antes de iniciar#
string3 = "ÉÉÉÉh mais ou menos, mais ou menos"                              #o jogo, propriamente dito                #

if (num1*4)+(num2*4) == num5 && (num5/4) >= num1+5
  p string1
else
  p string2
end


[close]

Aula 4

Spoiler

Código Selecionar Expand

##################################################################
#----------------------------------------------------------------#
#Aula 4 de Ruby: Casos e Métodos --------------------------------#
##################################################################

string1 = "Um iniciante? Um noob? Não importa, boa sorte no modo fácil"
string2 = "Eu sabia que vc faria isso... você é tão Normal!"
string3 = "Eiita, esse ai ta manjando do jogo, boa sorte Veterano"
string4 = "É um bixão msm heim, jogando no modo Inferno. Espero que manje os paranaue"
string5 = "hm... mal previ seus movimentos! Espero que saiba o que ta fazendo com esse hack ai!"

game_mode = :god

case game_mode

when :easy
  p string1
when :normal
  p string2
when :hard
  p string3
when :prepare_to_die_eddition
  p string4
else
  p string5
end


[close]

Muito bem, sr.[user]Alisson[/user]. Passando aqui para te manter motivado com as aulas, porque já comecei o Laboratório de Experimentos do Poe. Comecei com o básico do básico, primeiro testando o que dá e o que não dá pra fazer. Alguns testes são óbvios, mas achei até engraçados haha

Primeira coisa que fiz, e me senti um MogHunter da vida:

Spoiler

(http://i.imgur.com/rcZFBEq.png)

[close]

Segunda, os testes óbvios. O do switch foi sacanagem.

Spoiler

[hs width=320 height=240]http://i.imgur.com/8UmMq6U.png[/hs]

[close]

Este aqui é ridículo de tão óbvio, mas tive que postar. Não aguentei  :facepalm:

Não custava tentar hahaha

[hs width=320 height=240]http://i.imgur.com/famjrPU.png[/hs]

[close]

Estou enfiando este comando em todo canto o/

Haha' ótimos testes, Poe xD
E tá aí uma curiosidade pra galera mesmo. Você pode fazer uma variável do editor segurar um texto e fazer switches segurarem números xD

As aulas continuam amanhã :D Nós vamos estar aprendendo sobre as classes e os novos tipos de variáveis.

Aula número 8 lançada! Nela estaremos aprendendo um pouco sobre as classes. o/

Huummm... Finalmente entendi o maldito def initialize que vejo em toda parte. Todas as classes precisam de um desse, certo? Quero dizer, initialize seria um comando, não um nome?

O initialize é um método que sempre é chamado automaticamente quando a classe é criada. Não é obrigatório o uso, mas se você quiser que as coisas sejam executadas automaticamente (no caso de sprites futuramente), é bom usar ele :)
Ele é praticamente o único método padrão das classes.

Citação de: Joseph Poe online 07/03/2017 às 07:19
Huummm... Finalmente entendi o maldito def initialize que vejo em toda parte. Todas as classes precisam de um desse, certo? Quero dizer, initialize seria um comando, não um nome?

Se o Alisson permite eu responder xD, não é que é necessário, é que todos já tem esse método.

Assim, no Ruby tudo é objeto, então classe também é um objeto que tem vários métodos já pré-definidos em sua criação, quando você declara uma classe ela já vem com um monte de métodos, faça o teste usando esse que é também um método:

class Obj; end
objet = Obj.new
puts objet.private_methods

E veja o que aparece, "private methods" não são "enxergado" de fora, esse é o mesmo conceito que tem em outras linguagens, o initialize está entre eles.

Então basicamente, quando você declara algo como classe, você cria um objeto que tem todos esses métodos, e no método "new", que você utiliza para instanciar, dentro dele é chamado o initialize, por isso o initialize é usado para colocar tudo que você quer quando instanciar a classe, ou seja, não é que temos que criar ele, ele já existe mesmo sem você modifica-lo, podemos colocar coisas dentro dele ou modificar o que já vem dentro dele.

Edit: Eu já estava escrevendo antes dele mandar, vou mandar outra explicação aqui  :D

Se me permitir

CitarEle é praticamente o único método padrão das classes.

Na verdade tem uns 80~ métodos padrões na classe, mas o initialize é o mais comum de ser modificado por que é o que sempre é chamado em sua instancia.


Ah e parabéns pelas aulas  :wow: , estão muito show!

Opa, permito sim u.u Até me ajuda, haha'

E sobre os outros métodos padrões, é que eles são compartilhados com os métodos do módulo (sendo que toda classe é um módulo), daí creio que o initialize seja o mais indicado, visto que é um método introduzido na própria classe Class, ao invés do módulo (sem contar o initialized? xD)
Btw, é só uma reflexão doida minha, ignore ;-;

Aula número 9 lançada, galera! Podem conferir aqui: https://youtu.be/89hr3vzXGN0
Daqui a pouco estarei adicionando ela no tópico. Apesar dela ter sido bem mais curta que as outras, estou feliz em dizer que faltam exatamente 7 aulas para que possamos terminar o básico.

Opa. Obrigado pelas respostas. Que bom que estamos terminando o básico o/
Já tive ideias pra scripts inúteis, mas que vão servir pra aprender haha

Aula número 10 lançada o/
E é uma boa ideia, Poe :D Ainda tenho um projetinho base aqui que usei quando estava aprendendo. Aquele negócio me traz umas belas lembranças.

As aulas tão vindo rapido. :lol:
To adorando cada aula, to ansioso pra chegar na parte da criação de janelas com comandos.

Entendi agora haha.
De tanto fuçar os scripts base do Ace, vi várias vezes o "Esta classe herda...". Acho que isso poupa um tempinho de digitação.

Aula número 11 lançada. Ela pode ser acessada aqui (https://youtu.be/DVaySq4_qyA).
Nela estaremos aprendendo sobre o superman.

Daqui a pouco coloco no tópico principal.

E galera, o que acham dessas setinhas no vídeo? Tá sendo útil ou atrapalha um pouco?

Super seria o que salva quando o programador faz merda? Tipo, reescreve algum valor errado...?
Sobre as setinhas, ficaram legais. Eu, particularmente, prefiro sem porque facilita pra aprender a identificar os códigos sem comentários. Mas ajuda, muito haha

É, basicamente ele vai lá no método da classe "pai" e executa tudo o que tá lá :)
Isso será bastante usado quando estivermos criando sprites, scenes e janelas futuramente.

Citação de: Alisson online 09/03/2017 às 20:05
É, basicamente ele vai lá no método da classe "pai" e executa tudo o que tá lá :)
Isso será bastante usado quando estivermos criando sprites, scenes e janelas futuramente.

Estou esperando por isso  :wow:
Dúvida de última hora: essas aulas se aplicam ao RGSS do 2k3? É RGSS mesmo né? haha O com o Destiny Patch.

Opa, o do Destiny Patch já não é rgss não, pelo que eu me lembre, é DestinyScript (uma linguagem feita para o patch). o/

Aula número 12 lançada!
Próxima aula vai ser segunda, galera o/

Então é isso que causa a maioria das incompatibilidades? Quem sabe não dá pra consertar o/
Vou testar aqui.  :wow:

Exatamente :) Alguns scripts modificam métodos, e outro script vai lá e tenta usar esse método que foi modificado, não conseguindo fazer isso ele acaba bugando xD

Boa sorte o/

Aula número 13 lançada o/

Seriam esses os comandos que se usam em sistemas de criação? (Forja, combinação e etc) Usando o comando que lê os "itens necessários", e o outro para incluir na lista um possível item criado pelo jogador? Digo, pro caso de não estarem pré-definidos. Ou seria possível fazer algo do tipo, dando uma maior liberdade ao jogador para criar?  :sera:

Exatamente!
Geralmente se usa isso para criar uma variável dentro do item contendo valores como arrays, e quando necessário, nós alteramos esses valores e lemos eles quando for necessário. É bem usado em sistemas de cartas, também.

Existem estes três tipos de attr por questões de segurança.

Alisson isso é tudo muito maravilhoso! =3 Se estou lembrado, terão aulas de C++ também, né não?

Terão sim \o/

Aula número 14 lançada o/ (https://youtu.be/sGCTVfqbFjs)

Este é legal para aqueles puzzles irritantes que todo jogo tem  :e.e:
Mas certeza que também dá pra encaixar em qualquer coisa. o/

Aula número 15 lançada o/ (https://youtu.be/6zE_7UK5zDc)

Sabem aqueles famosos módulos de configuração? Então...

Agora entendi o clássico "Não  mexa aqui" dos scripts haha
Obs: faltou uma palavrinha "valor" na hora de explicar as constantes. Não atrapalhou em nada, só pra constar.

Exatamente xD e acabei esquecendo aquilo por desatenção mesmo, perdoem ;-;

Aulas 16 e 17 lançadas. Fico feliz em dizer que finalizamos as aulas básicas.

 :clap: :clap: :clap:
Quer dizer que, quando há algum :comando se trata de um hash? Tipo, naquelas condições de tecla pressionada e etc? E sobre o eval, seria possível transformar o código em outro valor (string, número)? Por exemplo: Em determinado sistema, o jogador pode criar o calculo de dano in game. O programador se esquece de salvar esses comandos em outro lugar, então seria possível reverter o código para mostrar a fórmula em uma janela, ainda in game?

Muita das vezes sim :) Principalmente aqueles que existem nas partes configuráveis dos scripts.
E seria possível sim. Na verdade, para converter os valores de uma variável, é bem simples, seguindo o modelo abaixo:

"1002".to_i # Converte a string em um número inteiro.
eval("0x12") # Converte o número em hexadecimal em um verdadeiro código (o sistema converte números hexadecimais em decimais).

2017.to_s # Converte o número em uma string.

10.to_f # Converte o número em números com caracteres decimais (no caso, 10 ficaria 10.0)

"hey_there".to_sym # Converte a string em um símbolo (:hey_there)


Pegamos uma fórmula de ataque simples, por exemplo:
a.atk * 4 - b.def * 2
No caso, quando ele usa o eval, "a" é a classe do atacante, então no código deve existir alguma variável chamada "a" que segura a classe do atacante.
Tendo esse conhecimento em mente, você pode fazer fórmulas bem elaboradas, como:
if a.id == 1; 150; else; 50; end
A fórmula acima checa se o número do atacante no database é 1. Se for, o dano será 150, do contrário será 50.

 Nossa, muito boa suas Aulas, [user]Alisson[/user]! Realmente elas são muito... perfeitas  :XD: Gosto bastante de aulas curtas mas que ensinam o necessário (sem enrrolação).
Essas aulas me tiraram muitas dúvidas que pairavam em minha mente.

Aguardando as próximas aulas :D

Opa, fico feliz em saber que estão ajudando :D Estou preparando as aulas intermediárias já, só não postei até agora pois minha internet me odeia ;-;

aqui seria um topco bom pra se aprender sobre ruby do zero? pq tipo se me perguntar o q é ruby nao vou saber responder ._.

Sim, as aulas focam em ensinar desde o zero, para aqueles que nunca tiveram contato com programação.
Só é requerido ter conhecimento sobre a engine, do contrário elas podem se tornar um pouco complicadas.

Amanhã 10/04 começaremos as aulas intermediárias. Espero que tenham aprendido tudo do básico, pois vamos colocar o que aprendemos em prática agora.

Otimo, ja sinto a animação fluindo nas veias :) 

Aula número 18 lançada!
Abaixo seguem algumas das propriedades da classe Sprite.

sprite.x = 10                # A coordenada horizontal do sprite.
sprite.y = 10                # A coordenada vertical do sprite.
sprite.z = 10                # Indica o quão próximo da tela e o quão acima das outras o sprite estará. Em engines 3d, o z é apenas mais uma coordenada.
sprite.ox = 10               # O ponto de origem horizontal do sprite. Por padrão, o ponto de origem é no canto superior esquerdo.
sprite.oy = 10               # O ponto de origem vertical do sprite. Mesma coisa do ox.
sprite.zoom_x = 1.0          # O zoom horizontal do sprite. 1.0 é 100% do zoom, enquanto 2.0 é 2x o tamanho original.
sprite.zoom_y = 1.0          # O zoom vertical do sprite. Mesmo tipo do zoom_x.
sprite.angle = 0             # O ângulo de rotação do sprite. De 0 a 360.
sprite.opacity = 255         # A opacidade do sprite. Um valor de 0 a 255.

Opa, quase me escapa o/
Tipo, fuçando aqui nos scripts não encontrei, mas caso seja burrice minha, avise. Qual é a prioridade padrão de cada elemento? Por exemplo, na tela de título temos:

Imagem de Fundo<Windowskin<Comandos<Imagens de Título e etc

Uma vez tive um grande problema com o script de iluminação do [user]Khas[/user], porque a sombra dele - naquela demo - se sobrepunha a janelinha de opções (Sim, Não, essas coisas), mas não a de mensagens normais. Foi assim que conheci esse negócio de prioridades. E outra coisa: mover imagens é coisa pra aulas futuras? '-'

A imagem da tela de título possui um z de 100, e, como toda imagem que você cria tem um z de 0 por padrão, ela consequentemente fica atrás quando você cria. Ele define o z na linha 52 do script padrão da Scene_Title.

E se preocupa não, ainda preciso explicar sobre as scenes para que possamos brincar um pouco mais com os sprites :D Tem bastante coisa que podemos fazer após eu explicar sobre as scenes.

Outra coisa, se você criar dois sprites, o sprite que você cria por último fica acima do sprite que criou primeiro.

 :<3: Haaa, quero muito fazer algo usando essa aula, como sempre e fácil de entender com você ensinado.
:T.T: Vou sentir falta da musiquinha e da outra garota.

Mantenha esse ânimo e você estará fazendo vários scripts, meu caro.
e é a mesma garota, é apenas uma transformação, haha

Aula 19 lançada.

Recomendo que vejam o conteúdo a seguir após verem a aula.

---

Inicialização da classe RPG::BGM

RPG::BGM.new("Nome", Volume, Pitch, Posição)
"Nome" - Obviamente o nome da música. Originalmente deve se encontrar na pasta Audio/BGM.
Volume - De 0 a 100.
Pitch - O tom da música. Pode usar qualquer valor, até mesmo zero.
Posição - Desnecessário o uso. Deve ser um número de 9 dígitos, contendo a posição de onde o áudio deve ser reproduzido. Funciona apenas com arquivos OGG e WAV.


Métodos de classe:

RPG::BGM.last - Obtém o áudio que está sendo tocado atualmente. Também obtém a posição do playback.
RPG::BGM.stop - Faz o áudio atual parar.
RPG::BGM.fade(tempo) - Faz um fadeout no áudio em milissegundos.
.play(posição) - Reproduz o áudio. Não é necessário definir uma posição, a menos que você queira.
.replay - Reproduz a BGM que foi obtida em RPG::BGM.last.


Os mesmos métodos de RPG::BGM são válidos para RPG::BGS.

Inicialização da classe RPG::ME

RPG::ME.new("Nome", Volume, Pitch)


Métodos de classe:

RPG::ME.stop - Faz a ME atual parar.
RPG::ME.fade(tempo) - Faz um fadeout no ME que está sendo reproduzido atualmente em milissegundos.
.play - Reproduz um ME.


Os mesmos métodos de RPG::ME são válidos para RPG::SE, exceto fade.

---

Métodos do módulo Input:

Input.trigger?(Símbolo) - Indica se o botão Símbolo foi pressionado uma vez.
Input.press?(Símbolo) - Indica se o botão Símbolo está sendo pressionado.
Input.repeat?(Símbolo) - Indica se o botão Símbolo está sendo pressionado uma vez, repetidamente (Apenas testando vocês vão entender esse, creio eu).

Símbolo pode ser:
  :RIGHT, :LEFT, :UP, :DOWN, :A, :B, :C, :X, :Y, :L, :R, :SHIFT, :CTRL, :ALT, :F5, :F6, :F7, :F8 e :F9.


Muito boa essa o/ Agora só falta a aula sobre janelas e já poderei começar alguma coisa. Só fiquei com uma dúvida: Digamos que eu crie uma cena adicional para o menu. Eu preciso declarar novamente quais serão os SE's base que serão tocados ao escolher uma opção, ou o sistema vai identificar os que estiverem configurados no database?

Para reproduzir sons do sistema, como o som do cursor e som de confirmação, dê uma olhada no módulo Sound. É um dos primeiros módulos padrões no editor de scripts.
Se você usar algo com: Sound.play_ok ou Sound.play_cursor, ele irá detectar automaticamente o som configurado no database :D
Basta ver lá os outros sons no módulo e usar de acordo.

Aula 20 lançada.

---


SceneManager.call(scene) # Chama a scene.
SceneManager.return      # Retorna para a scene anterior.
SceneManager.goto(scene) # Vai para a scene, não deixando nenhuma scene anterior.
SceneManager.exit        # Sai do jogo.


 :wow: Ja tenho tudo que preciso pro meu primeiro script, espero poder mostrar pra você alisson-sensei.  :XD:
To adorando as aulas avançadas. :lol:

Spoiler

ORA,ORA,ORA,ORA,ORA,ORA,ORA,ORA,ORA!!!

[close]

Agora sim. Aguardem minha coleção de scripts inúteis, que já rascunhei aqui só para testar haha Achei que esse negócio das cenas era mais complicado, mas pelo vídeo nem é. Vou comparar com HTML, que tenho aprendido aos poucos:

Uma Tag com poucos atributos obrigatórios.

Haha estou doido pra ver o que estão aprontando :) Em breve a aula sai.

Spoiler

MUDAMUDAMUDAMUDAMUDAMUDAMUDAMUDA

[close]

Tem como usar as variáveis criadas no jogo, lá nos eventos, dentro dos scripts?
Por exemplo tenho a variável Energia, não tem como eu fazer:

def disable_dash?
    return false if Energia <= 5
  end

Outra coisa, tem como limitar o dash/correr, pelo chamar script? Como seria o comando? Valeu!

Citação de: Selitto online 28/04/2017 às 04:17
Tem como usar as variáveis criadas no jogo, lá nos eventos, dentro dos scripts?
Por exemplo tenho a variável Energia, não tem como eu fazer:

def disable_dash?
    return false if Energia <= 5
  end

Você pode fazer assim:
def disable_dash?
  return $game_variables[ID] > 5
end
Agora é só trocar o ID pelo número correspondente à variável Energia.

Citação de: Valentine online 28/04/2017 às 17:45
Você pode fazer assim:

Código Selecionar Expand

def disable_dash?
  return $game_variables[ID] > 5
end
Agora é só trocar o ID pelo número correspondente à variável Energia.

EDIT: Deu certo sim, valeu cara!
Outra dúvida como checar se o personagem está parado?

Citação de: Selitto online 28/04/2017 às 18:43

Citação de: Valentine online 28/04/2017 às 17:45
Você pode fazer assim:

Código Selecionar Expand

def disable_dash?
  return $game_variables[ID] > 5
end
Agora é só trocar o ID pelo número correspondente à variável Energia.

EDIT: Deu certo sim, valeu cara!
Outra dúvida como checar se o personagem está parado?

Assim:
unless $game_player.moving?

Citação de: Valentine online 29/04/2017 às 07:52
Assim:

Código Selecionar Expand

unless $game_player.moving?

Valeu, mas agora já fiz o restante do sistema por eventos, e ficou como eu queria. :ok:

Me perdoem pela ausência, pessoal. Tive problemas com a internet, mas fiquei ligados que estaremos continuando as aulas em breve o/
Ah, e obrigado por ajudar o Selitto, Valentine :D

Aula 21 lançada. Demorou mas chegou o/

Pô, o negócio é mais simples do que parece (até aqui). Assim que tiver um download das aulas (estou enchendo o saco, né?), vou estudar esse negócio dia e noite e pretendo criar tudo o que tenho sentido falta no Ace.  :malvado:

Vai por mim, você vai começar a programar tudo que cê quiser aehuaeh
Até eu, 99% dos scripts que uso são feitos por mim ._. E se preocupa não que ainda vou colocar elas pra download aehue

Aula 22 lançada.

Ae, agora entendo como funciona esse negócio que vivo cortando do menu. :malvado:

MDS, Alisson, você não sabe o QUANTO me ajuda.
Suas aulas são incríveis, cara!
Quem sabe, algum dia eu migre dos eventos para a terra dos códigos...
~Obrigado por dispor essas belezuras, sensei
^^

É ótimo saber que estão sendo de ajuda :)
E agora que tu sabe esse treco, cê já pode burlar os comandos do menu, Poe e.e

Aula 23, com suas duas partes lançadas.
Abaixo estarão alguns códigos de exemplo juntamente do código que usamos na aula.

Código da aula

Código Selecionar Expand

class Test_Scene < Scene_Base
 
  def start
    super
    @background = Sprite.new
    @background.bitmap = SceneManager.background_bitmap
    @my_select = My_Select.new(0, 0, 300, 200)
  end
 
end

class My_Select < Window_Selectable
 
  def initialize(x, y, width, height)
    make_command_list
    super
    draw_commands
    activate
    select(0)
  end
 
  def make_command_list
    @list = []
    commands = ["Select Me", "I am the chosen one", "Use my protag powers"]
    for i in 0...commands.size
      @list.push(commands[i])
    end
  end
 
  def draw_commands
    for i in 0...@list.size
      rect = item_rect(i)
      self.draw_text(rect, @list[i])
    end
  end
 
  def update
    super
    if Input.trigger?(:C) && self.active
      Sound.play_ok
      p @list[index]
    end
  end
 
  def item_max
    return @list.nil? ? 0 : @list.size
  end
 
end

[close]

Exemplo com ícones

Código Selecionar Expand

class Test_Scene < Scene_Base
 
  def start
    super
    @background = Sprite.new
    @background.bitmap = SceneManager.background_bitmap
    @my_select = My_Select.new(0, 0, 300, 200)
  end
 
end

class My_Select < Window_Selectable
 
  def initialize(x, y, width, height)
    make_command_list
    super
    draw_commands
    activate
    select(0)
  end
 
  def make_command_list
    @list = []
    @icons = [] # Criando um depósito de ícones apenas como exemplo.
    commands = ["Select Me", "I am the chosen one", "Use my protag powers"]
     # Vamos criar uma array de ícones de exemplo.
    icons = [18, 39, 64] # Vamos usar apenas o index dos ícones no iconset.
    for i in 0...commands.size
      @list.push(commands[i])
      @icons.push(icons[i]) # Vamos adicionar os ícones no depósito de ícones.
    end
  end
 
  def draw_commands
    for i in 0...@list.size
      rect = item_rect(i)
      self.draw_icon(@icons[i], rect.x, rect.y) # Vamos desenhar os ícones.
      rect.x += 24 # Vamos afastar o texto 24 pixels para a direita.
      self.draw_text(rect, @list[i])
    end
  end
 
  def update
    super
    if Input.trigger?(:C) && self.active
      Sound.play_ok
      p @list[index]
    end
  end
 
  def item_max
    return @list.nil? ? 0 : @list.size
  end
 
end

[close]

Exemplo usando apenas ícones

Código Selecionar Expand

class Test_Scene < Scene_Base
 
  def start
    super
    @background = Sprite.new
    @background.bitmap = SceneManager.background_bitmap
    @my_select = My_Select.new(0, 0, 300, 200)
  end
 
end

class My_Select < Window_Selectable
 
  def initialize(x, y, width, height)
    make_command_list
    super
    draw_commands
    activate
    select(0)
  end
 
  def make_command_list
    @list = []
    @icons = [] # Criando um depósito de ícones apenas como exemplo.
    commands = ["Select Me", "I am the chosen one", "Use my protag powers"]
     # Vamos criar uma array de ícones de exemplo.
    icons = [18, 39, 64] # Vamos usar apenas o index dos ícones no iconset.
    for i in 0...commands.size
      @list.push(commands[i])
      @icons.push(icons[i]) # Vamos adicionar os ícones no depósito de ícones.
    end
  end
 
  def draw_commands # Aqui nós vamos desenhar apenas os ícones.
    for i in 0...@list.size
      rect = item_rect(i)
      self.draw_icon(@icons[i], rect.x, rect.y) # Vamos desenhar os ícones.
    end
  end
 
  def item_width # A largura de uma seleção na janela.
    return 24
  end
 
  def line_height # A altura de uma linha na janela.
    return 24
  end
 
  def spacing # O espaço entre os itens horizontais na janela.
    return 4
  end
 
  def col_max # O número máximo de colunas na janela.
    return 2
  end
 
  def update
    super
    if Input.trigger?(:C) && self.active
      Sound.play_ok
      p @list[index]
    end
  end
 
  def item_max
    return @list.nil? ? 0 : @list.size
  end
 
end

[close]

Opa, mais uma. Só fiquei com uma dúvida tosca aqui. O comando que você usou para o background usa - automaticamente - a windowskin, certo? O que eu faria para incluir uma imagem? Exemplo: em uma árvore de habilidades, a posição de cada ícone está de acordo com a imagem de fundo. Tipo aquele plugin que o [user]King Gerar[/user] fez há*(?) um tempo.

No caso de mostrar cada ícone de acordo com a imagem de fundo, você precisaria determinar explicitamente  as coordenadas que eles apareceriam. Eu recomendaria criar um módulo de configuração, e nele colocar os ícones + as coordenadas, e usar os valores para desenhar cada ícone. Ex:
icons = [ [32, 28, 120], [64, 20, 19] ] # [ [index, x, y], [index, x, y] ]
for i in 0...icons.size
    self.draw_icon(icons[i][0], icons[i][1], icons[i][2])
end
Esse aí foi um exemplo usando arrays, mas eu prefiro usar hash para esse caso. Ex:
icons = [ {:index => 32, :x => 28, :y => 120}, {:index => 64, :x => 20, :y => 19} ]
for i in 0...icons.size
    self.draw_icon(icons[i][:index], icons[i][:x], icons[i][:y])
end

\o/

Aula 24 lançada.

O sprite utilizado na aula pode ser obtido aqui:

Spoiler

(http://i.imgur.com/bCk0tdn.png)

[close]

Muito interessante  :sera:
No caso dos charsets normais, é preciso definir quando uma linha de frames termina? Ou isso é automático? Tipo, são três para cada direção - ou não, dependendo do sprite. É preciso definir que a linha de baixo pertence ao mesmo sprite, ou essa separação não faz diferença?

No caso dos charsets, toda vez que você muda de direção, o que muda no src_rect é a posição y, os frames horizontais continuam animando usando o src_rect.
E não seria necessário definir o número de frames na horizontal, basta você pegar a largura e dividir pelo tamanho de 1 frame.
No caso: 32 * 3 = 96 (três frames de 32 na horizontal é 96, o que seria a largura do bitmap).
96 / 32 = 3 (são três frames na horizontal), então usando este tipo de cálculo você faz um negócio automático, haha. É basicamente o que eles fazem com os iconsets.

Aula 25 lançada. Ela é uma aula rápida sobre um conceito que estaremos precisando na próxima aula.

Opa! Pergunta idiota antes de começarmos a usar 'se'troço. As :keys funcionam, basicamente, como um Label dos eventos? Digo, um marcador?

As keys funcionam de forma parecida com as labels, mas elas são usadas como identificadores.
Ao contrário das arrays, as hashes precisam de keys, ou identificadores para guardarem seus valores. E para acessar um conteúdo específico da hash, é necessário indicar a key ou o identificador do conteúdo que você quer.

É como uma biblioteca. Para acessar o conteúdo de um livro seria necessário saber o nome do livro.

Aula 26 lançada com sucesso.
Vocês podem checar o código que utilizamos na aula logo abaixo, com alguns comentários a mais:

#===============================================================================
# Módulo de Configuração
#===============================================================================
module SoundTestConfig

    #---------------------------------------------------------------------------
    # Lista de músicas.
    #---------------------------------------------------------------------------
    Sounds = {
        :battle1 => {
            :name => "Battle1",
            :author => "Enterbrain, i guess...",
            :description => "Just a battle theme.\nFor the lolz."
        },
        :battle2 => {
            :name => "Battle2",
            :author => "Hmm... Enterbrain?",
            :description => "Testing this\nthing."
        }
    }

    #---------------------------------------------------------------------------
    # Controle do volume e tom das músicas.
    #---------------------------------------------------------------------------
    Sound_Volume = 100
    Sound_Pitch = 100

end

#===============================================================================
# Resto do código
#===============================================================================
class Sound_Test < Scene_Base

    #---------------------------------------------------------------------------
    # Inicialização da cena.
    #---------------------------------------------------------------------------
    def start
        super
        @map_bgm = RPG::BGM.last
        RPG::BGM.fade(1000)
        @background = Sprite.new
        @background.bitmap = SceneManager.background_bitmap
        @help_window = Sound_Test_Help.new
        @sound_list_window = Sound_List.new(0, 0, Graphics.width * 0.5, Graphics.height - @help_window.height)
        @description_window = Sound_Test_Description.new(@sound_list_window.x + @sound_list_window.width, 0, Graphics.width * 0.5, Graphics.height - @help_window.height)
        refresh_author
        refresh_description
    end

    #---------------------------------------------------------------------------
    # Atualização do nome do autor.
    #---------------------------------------------------------------------------
    def refresh_author
        return unless @sound_list_window.current_item
        @help_window.contents.clear
        @help_window.draw_text_ex(0, 0, @sound_list_window.current_item[:author])
    end

    #---------------------------------------------------------------------------
    # Atualização da descrição.
    #---------------------------------------------------------------------------
    def refresh_description
        return unless @sound_list_window.current_item
        @description_window.contents.clear
        @description_window.draw_text_ex(0, 0, @sound_list_window.current_item[:description])
    end

    #---------------------------------------------------------------------------
    # Atualização geral da cena (atualização de frames).
    #---------------------------------------------------------------------------
    def update
        cs = @sound_list_window.current_item
        super
        refresh_author if cs != @sound_list_window.current_item
        refresh_description if cs != @sound_list_window.current_item
        if Input.trigger?(:C)
            if @sound_list_window.current_item
                RPG::BGM.new(@sound_list_window.current_item[:name], Sound_Volume, Sound_Pitch).play
            end
        end
        if Input.trigger?(:B)
            SceneManager.return
        end
    end

    #---------------------------------------------------------------------------
    # Finalização da cena.
    #---------------------------------------------------------------------------
    def terminate
        super
        @map_bgm.play(@map_bgm.pos)
    end

end

#===============================================================================
# Eu prefiro usar a Window_Selectable pois tenho mais liberdade e controle
# sobre meus comandos. Posso desenhar ícones, e o que for nela livremente.
# Mas caso você ainda não esteja conseguindo usar a selectable, pode usar
# a Window_Command no lugar (embora eu ainda recomende a selectable).
#===============================================================================
class Sound_List < Window_Selectable
    include SoundTestConfig

    #---------------------------------------------------------------------------
    # Inicialização da janela.
    #---------------------------------------------------------------------------
    def initialize(x, y, width, height)
        @list = []
        make_command_list
        super
        draw_commands
        select(0)
        activate
    end

    #---------------------------------------------------------------------------
    # Criação dos comandos.
    #---------------------------------------------------------------------------
    def make_command_list
        Sound.each_pair do |key, sound|
            @list.push(sound) if $game_system.unlocked_sounds[key]
        end
    end
   
    #---------------------------------------------------------------------------
    # Desenho dos comandos.
    #---------------------------------------------------------------------------
    def draw_commands
        for i in 0...@list.size
            rect = item_rect_for_text(i)
            draw_text(rect.x, rect.y, rect.width, rect.height, @list[i][:name])
        end
    end
   
    #---------------------------------------------------------------------------
    # O item atualmente selecionado.
    #---------------------------------------------------------------------------
    def current_item
        return @list[index]
    end
   
    #---------------------------------------------------------------------------
    # Número máximo de itens da janela.
    #---------------------------------------------------------------------------
    def item_max
        return @list.size
    end

end

class Sound_Test_Help < Window_Base

    #---------------------------------------------------------------------------
    # Inicialização da janela.
    #---------------------------------------------------------------------------
    def initialize(x = 0, y = Graphics.height - fitting_height(2), width = Graphics.width, height = fitting_height(2))
        super
    end

end

class Sound_Test_Description < Window_Base

    #---------------------------------------------------------------------------
    # Inicialização da janela.
    # Como o método é idêntico ao da window_base, sem nenhum parâmetro com
    # valores padrões (veja a Sound_Test_Help acima), você pode até deletar
    # esse initialize que não faz diferença alguma :T Só adicionei pois em
    # minha mente eu ia colocar alguma coisa nele, mas bah'
    #---------------------------------------------------------------------------
    def initialize(x, y, width, height)
        super
    end

end

#===============================================================================
# Aqui é onde nós vamos nos encarregar de adicionar comandos no Game_Interpreter
# (basicamente os comandos de chamar script).
#===============================================================================
class Game_Interpreter

    #---------------------------------------------------------------------------
    # Desbloqueio de sons.
    # O uso do * no primeiro argumento indica que você pode passar quantos
    # parâmetros você quiser, que ele vai ler todos eles e guardá-los em
    # uma array.
    # No caso, sounds é uma array dos parâmetros que você inseriu.
    #---------------------------------------------------------------------------
    def unlock_sounds(*sounds)
        for s in sounds
            $game_system.unlocked_sounds[s] = true
        end
    end

    #---------------------------------------------------------------------------
    # Bloqueio de sons.
    # Mesma coisa da descrição acima.
    #---------------------------------------------------------------------------
    def lock_sounds(*sounds)
        for s in sounds
            $game_system.unlocked_sounds[s] = false
        end
    end

end

#===============================================================================
# Aqui que nos encarregamos de criar uma variável que será salva com o jogo.
# Como a variável $game_system é global, podemos chamar suas instâncias
# em qualquer lugar. Sem falar que qualquer instância que for salva na
# $game_system será salva com o jogo.
# Porém note que, você não pode salvar nenhuma imagem (Sprite/Bitmap/Viewport)
# dentro do $game_system, visto que ele dará erro e provavelmente corromperá
# o save do jogador.
# Caso você salve uma classe dentro do $game_system, tenha certeza de que
# não exista nenhuma imagem dentro da sua classe também, pois vai dar o
# mesmo problema.
#===============================================================================
class Game_System

    #---------------------------------------------------------------------------
    # Poderemos ler, e apenas ler a variável unlocked_sounds usando
    # $game_system.unlocked_sounds.
    #---------------------------------------------------------------------------
    attr_reader :unlocked_sounds

    #---------------------------------------------------------------------------
    # Aqui nós criamos a variável de antemão no initialize.
    # Ela será uma hash.
    # Assim que o $game_system for iniciado pelo RPG Maker, nossa variável
    # será iniciada junta com todas as outras do $game_system.
    #---------------------------------------------------------------------------
    alias :sound_test_init :initialize
    def initialize
        sound_test_init
        @unlocked_sounds = {}
    end

end


[user]Alisson[/user], meu jovem. Esta é a melhor aula até agora. Ver um sistema sendo criado do zero é bem mais prático que passar por toda a teoria. Claro, sem ela ninguém ia entender nada, mas deu para entender. Enfim, dessa vez não fiquei com nenhuma dúvida e aprendi muita coisa. Até perdoo seus erros.   :U_U:

Fico feliz de saber disso, haha'
Nota-se que ainda teremos mais uma aula desse tipo, então até lá desejo boa sorte para o que quer que estejam fazendo :)

Passando apenas para parabenizar-lhe pelo trabalho que vem fazendo.
Me recordo ainda hoje de quando você havia iniciado as aulas e mal podia esperar para finalmente poder fazer a aula de Sound Test. Que conquista, hein?  Você chegou lá e já é hora de dobrar a meta. hehe'
Parabéns, essas aulas são mais do que excelentes. É o tipo de coisa que dá brilho nos olhos de ver que ainda existe, com tanta qualidade, no cenário maker.

Aula 27 lançada com sucesso.

Opa, mais uma das boas. Agora o sr.[user]Alisson[/user] começa a revelar seus segredos. Até pesquei como acessar os arquivos na pasta do jogo o/

Edit: Fui fazer umas experiências e deu um errinho aqui:

Erro

(http://i.imgur.com/8Lv3YGc.png)

[close]

A linha em questão é justamente essa:

class Particle < Sprite

Só para constar, estou mesclando essa aula com o Scene_Title original para fins acadêmicos.  :sir:

Achei as aulas muito boas!
Principalmente por serem bem objetivas e não ficar de muito lenga-lenga pra quem já conhece programação, acho que o importante mesmo seja talvez detalhar um pouco mais nas especificidades do RGSS3, mas no geral estão muito boas principalmente pela clareza e objetividade. Parabéns!

[OFF TOPIC]
Algo que tenho sentido muito falta e não encontro em lugar algum é uma espécie de documentação detalhada do RGSS3 e que apresente todas as variáveis globais, etc. Sei lá...

Citação de: Baby..Face online 03/08/2017 às 16:53
Algo que tenho sentido muito falta e não encontro em lugar algum é uma espécie de documentação detalhada do RGSS3 e que apresente todas as variáveis globais, etc. Sei lá...

Algo como isso: http://www.rubydoc.info/gems/rpg-maker-rgss3/1.02.0

Citação de: Kyo Panda online 03/08/2017 às 17:01

Citação de: Baby..Face online 03/08/2017 às 16:53
Algo que tenho sentido muito falta e não encontro em lugar algum é uma espécie de documentação detalhada do RGSS3 e que apresente todas as variáveis globais, etc. Sei lá...

Algo como isso: http://www.rubydoc.info/gems/rpg-maker-rgss3/1.02.0

Eu já tinha visto essa documentação antes...

Porém essa documentação achei muito crua não detalha algumas coisas, nem tem as classes já implementadas de: Game_*, ou Windows_*, etc...

Não tem as variáveis globais padrões, etc...
Até o momento a melhor solução que encontrei é ler todo o código e tentar entender mesmo, além de acompanhar aulas e tutoriais.

Mas valeu

Eu agradeço, Baby..Face o/
Nestas futuras aulas eu estarei entrando mais a fundo no RGSS3, mesmo que precise incrementar a listinha no tópico principal.
Por falar nisso, ultimamente estive criando uma espécie de documentação decente pra ele. Se tudo der certo, devo lançar futuramente.

Aula 28 lançada o/
Chegamos nas aulas avançadas (ou não tão avançadas assim).

Agora sim.  :malvado:
Já começou bem. Esse script é o único no qual eu nunca fucei no Ace. E sobre a aula: seria possível salvar e carregar dados em um arquivo que não seja o arquivo padrão? Por exemplo, tua sugestão de um jogo de cartas. Digamos que o jogador queira compartilhar seu baralho com outros jogadores sem repassar seu progresso no jogo. O que seria mais fácil? Modificar esse script para criar novos tipos de arquivos de save ou criar um arquivo na pasta data pelo script / sistema de cartas, como todo bom samaritano faz?

E aproveitando que toquei no assunto, dúvida aleatória: é possível manipular os arquivos da pasta data pelo "Chamar Script"? Por exemplo, criar um arquivo e carregá-lo quando necessário.

Sim, é completamente possível.
Para ler e carregar arquivos do projeto, é recomendável usar os métodos load_data e save_data, pois eles carregam dados de projetos encriptados.

Você pode usar eles em qualquer lugar, até mesmo em chamar script.

Spoiler

(http://i.imgur.com/gKrkn7U.png)

"Gole de Metal" aehuaehae

[close]

Agora para ler arquivos que não sejam *rvdata (como txt, dat, bin, etc...), é preciso usar um certo fix:

Spoiler

Código Selecionar Expand

class << Marshal
  alias :rename_me_load :load
  def load(port, proc = nil)
    rename_me_load(port, proc)
  rescue TypeError
    if port.kind_of?(File)
      port.rewind
      port.read
    else
      port
    end
  end
end unless Marshal.respond_to?(:rename_me_load)
Recomendo que renomeie o alias rename_me_load para algo que não vá causar incompatibilidade :)

[close]

Com isso você pode carregar qualquer arquivo usando load_data, mesmo em projetos encriptados.

É possível fazer um sistema de múltiplos idiomas ou save global só com isso.

---

Obs: Para salvar em uma pasta dentro do projeto, use os / no nome do arquivo.
save_data(dados, 'Data/meus_dados.rvdata2')

Essas aulas tão me ajudando muito, obrigado por postar!

Citação de: Alisson online 25/08/2017 às 13:22
Aula 28 lançada o/
Chegamos nas aulas avançadas (ou não tão avançadas assim).

Uhuuuuuuu! Em breve vou continuar meus estudos de RGSS3  :XD:
Essas aulas são sempre muito bem-vindas pra nos aprimorarmos! Valeuzão Alisson, mais uma vez sobre aquela ajuda que tu me deste no tópico de Plantão de tira-dúvidas de RGSS em breve vou testar e comento lá! Valeus!

Aula 29 lançada.

 :math:

---

Se é possível pegar qualquer dado pelas notas, seria possível enfiar uns microcódigos também? Por exemplo: determinado item só vai executar um comando nas notas ao ser usado, certo? Dá pra colocar uma condição verificando o id do usuário pra resolver o maior problema das equipes do RM? (Saber quem usou o quê em quem).  :math:
É, dá pra fazer por eventos, mas no caso de habilidades não funciona. O RM primeiro executa os cálculos da habilidade e a animação pra depois verificar se a mesma possui algum evento comum ou efeito especial.

---

Não fomos abandonados. :*-*:

Realmente agradeço pelas palavras, May. Espero poder finalizar elas em breve. E boa sorte com as de C# também, espero ver mais delas por aí :)

E Poe, é possível fazer bastante coisa com as notas. Na próxima aula sobre Expressões Regulares eu demonstrarei como você pode extrair informações úteis de uma string, como as notas em si.

Parabéns pela iniciartiva e pelas aulas, me ajudou muito.

É um bom guia para os iniciantes.  E creio que tenha boas dicas para usuários avançados também. (Não sou usuário avançado).

Quanto ao Ruby, certa vez tentei me aventurar nesta linguagem e parei porque achei "estranha", "complicada" demais para se fazer coisas simples. Se você reparar, nem ponto e vírgula(;) se usa para especificar que um comando acabou. Tem muitas outras coisas que não me acostumo bem em Ruby(nome e ícone lindos) e poderia citar alguns mas enfim e uma coisa importante,  é que ELA é a linguagem do RPG Maker.Quer aprender? Aprende. Não quer? Não aprende. E ponto final. Gostando ou não, é a linguagem que escolheram para o RPG Maker. Quanto mais conhecimentos e linguagens de programação você souber estara no lucro.

Conhecimento em geral é sempre bem vindo.

E que programa você utilizou para fazer as vídeo aulas? (Muito boa as aulas. Simples e efetivas).

Recomenda que material a mais para se aprender de forma mais profunda sobre o Ruby voltado para o RPG Maker?

Obrigado!  :clap:

desistiu das aulas man? tava curtindo  :holmes:

Seria interessante uma aula sobre Bitwise Operators.

Opa, se preocupem não, não desisti. É que meu tempo foi engolido pelo serviço, daí tô esperando uma boa oportunidade pra me dedicar nas aulas :feelsbatman:
Antes de ensinar sobre Bitwise Operators, preciso ensinar primeiro sobre bits e como a memória funciona, coisa divertida de aprender usando ruby. Acho que vou dar uma reformada na lista das futuras aulas avançadas.

Muito obrigado SOTELIE!!! Suas aulas de Ruby estão sendo muito uteis para mim!! Eu ainda não terminei de ver todas mas está muito bem explicado! bem, eu consegui entender com facilidade

Fico feliz que tenha gostado <3 Se tiver dúvidas não hesite em perguntar o/

Porque não terminou as aulas avançadas?
Sobre:

Spoiler

Expressões Regulares
Bitwise Operators
Math
File
Zlib
Win32API
Fiber

[close]

Adoraria vê-las também.


Achei sensacional a organização das aulas, que favorece o desenvolvimento do indivíduo que esta aprendendo.(Eu no caso rs)

Olá, Wotan!

Infelizmente o template que eu usava para as aulas foi perdido com meu PC antigo, sem contar que como ando mais ocupado ultimamente fica difícil produzir elas em vídeo.
Eu poderia, no entanto, continuar elas em texto. Não apenas é minha maneira favorita de aprender programação, como é a que mais recomendo, sem falar que me daria mais liberdade em explicar os pequenos detalhes sem ter que me preocupar com tempo.

Ótimas aulas! Me ajudaram muito, muito obrigado Syureri! :XD:

Citação de: Syureri online 08/05/2020 às 16:05
Olá, Wotan!

Infelizmente o template que eu usava para as aulas foi perdido com meu PC antigo, sem contar que como ando mais ocupado ultimamente fica difícil produzir elas em vídeo.
Eu poderia, no entanto, continuar elas em texto. Não apenas é minha maneira favorita de aprender programação, como é a que mais recomendo, sem falar que me daria mais liberdade em explicar os pequenos detalhes sem ter que me preocupar com tempo.

Ah sim, certo. Realmente as aulas pelos vídeos são muito boas e pequenas, peguei muito rápido as coisas(ou quase as avançadas eu embananei um pouco maais deu certo kkkk).
Muito Obrigado pelo excelente trabalho!  :clap: :clap: :ok:

Maravilhosa sua aula, parabéns pela dedicação em nos ensinar, fico muito grato. Está bem didática peguei muito fácil as aulas e tenho até noção de outras linguagens por causa delas.

Está faltando a aula 4. Case e Métodos do módulo Básico

Citação de: kaipos.jef online 10/12/2023 às 08:55
Está faltando a aula 4. Case e Métodos do módulo Básico

Veja a Playlist na ordem:
https://www.youtube.com/@sotelie8974/playlists