Tentando fazer um código funcionar

[Nunnu]

Parte longa e que explica pra que é este código, pode ser importante, mas não precisa ler:

Spoiler

[close]

Código: [Selecionar]

class Game_Follower < Game_Character
  def change_formation
    if Input.trigger(:C)
      chase_preceding_character = false
    end
  end
end
xD sei que tem coisa errada ai, mas quis tentar desativar em um botão o sistema de Follower atual, sei que ia dar erro e tal. Queria ver o que acontecia, iria arrumar depois substituindo com alguma outra coisa, isso é bem inicial mesmo. Mas vamos por partes, como eu faria para fazer isso dar certo?

[Brandt]

Olá gente, a 3 dias estou estudando Ruby/RGSS3,

vou tentar criar um ABS

Tá aí um par de frases que não deviam aparecer juntas.

As aulas do Khas são ótimas e tal, mas ele definitivamente não devia ter feito um ABS junto com todo o resto, acabou dando uma impressão errado pra um povo.
Mesmo que ele faça parecer fácil (porque... é ele) sistemas de batalha são impressionantemente complexos de fazer.

Mas ninguém perguntou minha opinião, então vou só te ajudar como qualquer pessoa normal faria


Não sei se entendi bem (preguiça de ler, sorry), mas se o quer é sumir/aparecer com a fila que segue o jogador, seria tipo assim:

Código: [Selecionar]

class Scene_Map < Scene_Base
  alias old_update update

  def update
    old_update
    if Input.trigger?(:X)
      $game_player.followers.visible = !$game_player.followers.visible
      $game_player.refresh
    end
  end
end

Isso faz a fila alternar de estado (aparecendo/não aparecendo) quando você clica no A no teclado.
A ideia de fazer ações no mapa ao pressionar um botão está sempre relacionada com modificar o update da Scene_Map, porque é esse o método chamado todo frame, ou seja, a quase todo momento, e por isso quando você verifica se uma tecla é pressionada pelo update você detecta cliques quase imediatamente e faz ações de acordo com isso.
Sobre a parte do $game_player.followers.visible, isso aí depende de conhecimento das classes padrão. Dê uma boa estudada nelas sempre que possível, tem bastante coisa pronta nelas que facilita demais a criação de scripts.

Se eu entendi errado e o que você quer na verdade é fazer os personagens na fila pararem de seguir os outros (ficarem pra trás) quando apertar a tecla, então fica assim:

Código: [Selecionar]

class Scene_Map < Scene_Base
  alias old_update update
  def update
    old_update
    if Input.trigger?(:X)
      for follower in $game_player.followers
        follower.follow = !follower.follow
      end
    end
  end
end

class Game_Follower < Game_Character
 
  attr_accessor :follow
 
  alias old_initialize initialize
  def initialize *args
    old_initialize *args
    @follow = true
  end
 
  alias old_chase_preceding_character chase_preceding_character
  def chase_preceding_character
    old_chase_preceding_character if follow?
  end
 
  def follow?
    @follow
  end
end

De novo, verificar pressionamento de teclas, só no update. Depois, pra ativar/desativar o chase_preceding_character, você não muda ele pra false, e sim cria uma variável (essa sim, com true ou false) e usa ela pra controlar as chamadas da função (no caso, do alias dela).

[Nunnu]

@Masked

Primeiro eu queria agradecer a ter disponibilizado um tempo para explicar tudo isso, é importante pra mim (own)

Segundo, aquele meu script era muuuito vazio, e eu sabia disso. Só fiz ele para os programadores entenderem o que eu tentei, talvez não funcionasse com a explicação (claro, eu realmente tentei acertar, mas vi que não tinha como com aquilo), então desisti e parti para perguntar em que eu estou errando.

Quando eu fiz esse tópico, eu estava bem motivado, porque ainda não tinha chegado a programar. Mas mesmo motivado eu entendia o nível da coisa. Imaginar um ABS só me fazia pensar o quão difícil seria para fazer, subestimei a programação, mas não tanto (não imagine isso como uma defesa para o que você disse, só justifiquei, porque pareceu mesmo que quando eu disse que faria um ABS, seria fácil).

A três dias (agora cinco) eu estou vendo apostilas, vídeo-aulas, e tudo mais. Tentei fazer um script de verdade com que adquiri, e... Meu Deus... que coisa difícil, não vai ter como eu fazer nada por enquanto, eu já entendia, mas entendo muito mais o quão juntar essas duas frases é inocência (eu ia falar arrogante, mas foi pura inocência). Eu por um tempo vi umas aulas de HTML5 (uma apostila da Caelum de graça, muito boa por sinal), tinha um pouco de dificuldade, mas meu deus... programar um jogo é bem diferente.

É isso, vou ler e reler o que você escreveu (eu entendi, mas tem muita coisa que eu não faço ideia que você usou, tipo esse "*args"), e tentar aprender mais tarde, com tempo. Eu vou editar isso quando eu precisar de mais alguma ajuda, vou ter que fazer isso para aprender de verdade, sinto que foi inútil tanto tempo estudando (sei que não foi, mas parece...).

OBS: Eu sinceramente acho que o Khas explica maaal de mais, não deveria ser um professor (me perdoe se um dia ler isso Khas, não me apedreje), mas quanto mais material eu ver melhor, além de não ter video-aulas em português sobre RGSS3 espalhada por ai.

[Brandt]

Ah, sim. Tudo isso é normal, lembro bem de quando comecei a mexer em scripts e parecia que ele ia entender o que eu queria dizer e fazer tudo funcionar mas... Nop.
E te entendo mesmo, porque o primeiro script que eu tentei fazer também era um sistema de batalha >_<
O importante é não deixar completamente de lado a ideia, foi dessa minha primeira tentativa que saiu meu primeiro script de verdade. Era bem besta e mal codificado, fiz quase tudo baseado em código já existente, então tinha umas coisas que eu usava sem saber por quê, mas funcionava, e isso que me deu vontade de continuar. Resultado: hoje eu programo até em C :P

Sobre o *args, é um recurso do Ruby chamado splatting ou splat, e serve basicamente para expandir Arrays (ou seja, transformar [1, 2, 3, 4] em 1, 2, 3, 4), por exemplo:

Código: [Selecionar]

array = [1, 2, 3, 4, 5]
a, b, c, d, e = *array
print a, b, c, d, e # => 12345
print *array        # => 12345Você também pode usar numa lista de argumentos, assim todos os argumentos que forem passados pra função vão para um argumento só, na forma de array.
Por exemplo:

Código: [Selecionar]

def fn *a
  p a
end

fn 1, 2, 3, 4, 5 #=> [1, 2, 3, 4, 5]
É bem útil para se usar junto do alias quando você quer adicionar alguma coisa em um método porque você pode usar só o *args ao invés de ter que redeclarar todos os argumentos.

Tenta dar uma olhada na área de Programação aqui do fórum, tem várias aulas de Ruby e RGSS, algumas inclusive mostrando passo-a-passo de como fazer scripts, essas aí ajudam bastante a desenvolver a prática.

O Khas não está mais entre nós (foi pra comunidade internacional, traidor...), então não se preocupe xP

[Nunnu]

@Masked

Na verdade eu estou muito motivado, apesar de eu não ter feito ideia de que era assim que se fazia aquele script, quando eu o li percebi o quão lógico aquilo era, só que é uma lógica com regras diferente das que eu quis usar. Programação basicamente é lógica livre, mas tu tem que decorar códigos e seguir as regras que o computador ou a linguagem entende. E também é parecido com Matemática (coisa que eu sou péssimo), quando tu tenta fazer a questão, não consegue, mas quando o professor resolve parece ser tão fácil.

Eu na verdade sempre estive na área de design. Photoshop, pixel art, essas coisas... Mas reconheço a utilidade da programação, e sinto necessidade de aprender. É bem complexo tudo, mas acho que eu vou conseguir.

Deixa eu ver se eu entendi o *args: Eu posso transformar [1,2,3,4,5] em 1,2,3,4,5 e vice-versa? É pra ficar mais bonito na hora do "print" e na hora de representar graficamente (dentro do jogo)? (Desculpe a burrice, é que não parece ser tão útil, acabo desconfiando do meu entendimento)

Obrigado pela sua ajuda me respondendo tudo isso.

Ah, e... estou salvo de apedrejamento, se ele não voltar.

[Brandt]

Ah, sim, o mais importante é aprender a entender a lógica do computador.

É quase isso, na verdade o *args vai um pouco além da estética do código, é que tem coisas que só funcionam com Arrays (que são um objeto só com vários outros dentro) e outras que funcionam só com listas de objetos.
Um exemplo de diferença entre usar uma array e usar uma lista:

Código: [Selecionar]

array = [1,2,3,4,5]
p array #=> [1,2,3,4,5]
p *array #=> 1
         #=> 2
         #=> 3
         #=> 4
         #=> 5
Você também não pode usar uma array comum para armazenar qualquer número de argumentos que você passe para um método, por exemplo:

Código: [Selecionar]

def f1 array
  p array
end

f1 [1,2,3,4] #=> [1,2,3,4]
f1(1, 2, 3, 4, 5, 6) #=> ArgumentError

def f2 *args
  p args
end
f2([1, 2, 3, 4], 1, 2, '...') #=> [[1, 2, 3, 4], 1, 2, '...']
f2(1, 2, 3, 4, 1, 2, '...') #=> [1,2,3,4,1,2,'...']
Isso é especialmente útil quando você quer adicionar coisas no método como no exemplo que eu dei sem ter que se preocupar quantos argumentos a função tem, o que aumenta a compatibilidade com qualquer script que modifique o método para ter um número de argumentos diferente.

Não é algo que você vá usar a todo momento, mas tem algumas situações que não dá pra escapar de usar isso aí.

[Nunnu]

@Masked

Entendi melhor agora, *args amplia as possibilidades com array, se torna bem mais útil vendo assim, obrigado pela explicação.

Esse final de semana tenho que fazer uns trabalhos na escola, mas estou com tanta vontade de estudar Ruby, ainda mais agora que vi que não sei muito.
 
Mas valeu por todo esse conhecimento que me passaste, por ora vou desistir do sistema avançado e ver o que posso aprender de mais nas aulas aleatórias que procuro.