Inimigos

O inimigo deve ser um evento no mapa, no local onde você desejar.
Ele dever ter:

1) Gráfico -->
2) Estar com a opção ''processo paralelo" marcada  -->
3) E com alguns comandos escritos:

Escreva com o comando ''comentário'' o seguinte:

[deny_player]

Assim quando o inimigo morrer e você pisar no local onde ele estava, ele não vai atrapalhar a sua passagem.

* Se o seu inimigo tiver de andar pelo mapa, você deve ir ao comando ''comentários'' e escrever o seguinte:

[turtle]

Esse comando fará seu inimigo andar de um lado para o outro no mapa.

Caso você queria que o seu inimigo fique parado no mapa, basta não colocar esse comando.

4) Nome: Pense num nome para esse tipo de inimigo... Por exemplo, "Inimigo_tipo_1"
Agora vá ao comando ''chamar script'' e escreva apenas o nome do seu inimigo (sem aspas), exemplo inimigo_tipo_1.
Seu evento do inimigo deve estar assim:


Agora é hora de programarmos o seu inimigo!
Abra o editor de scripts e lá em baixo na opção 'Main' clique com o lado direito do mouse e vá em ''Inserir novo script'' e coloque o nome de "Inimigos".
Vamos escrever aqui os comandos do nosso inimigo.

Primeiramente pense... o que ele vai ter?

I) Pulamos nele e ele morre
II) Encostamos nele e nós quem morremos
III) Ele morre se cair nos buracos das fases

Vamos passar essas três informações pros comandos do jogo?

Primeiramente defina no editor de scripts seu novo inimigo!
Para isso, utilize o comando ''def'' e na frente do comando escreva o nome que você deu ao seu inimigo, no caso do exemplo: inimigo_tipo_1.
Encerre o def com um ''end'' para fechar esse bloco:


def inimigo_tipo_1
  

  
  end

Dentro do comando ''def'' iremos colocar em prática a programação de nosso inimigo.
Primeiro vamos verificar se o inimigo não foi morto, ou seja, se ele ainda está no mapa. Para fazer isso, utilizamos um comando de condição chamado ''if''. Ele irá verificar se o que estipulamos está acontecendo ou não.
No caso, o ''acontecimento'', a condição, é verificar se o inimigo está vivo.
O comando que indica se o evento está ativo ou não vai ser o comando de transparência, ou seja, se o inimigo estiver transparente ele não está ativo no jogo, ''morreu'', se não estiver transparente, ele está ativo.

Crie o comando de condição iniciando com o if e fechando com o end:


def inimigo_tipo_1
  if
  
end
  
  end

Podemos também utilizar o comando ''else'' que irá nos dizer se a condição não foi satisfeita, ou seja, nesse caso, se o evento está transparente.
Coloque entre o if e o end o comando ''else'':

def inimigo_tipo_1
  if
  
  else  
    
end
  
  end



Agora no comando de condição, na frente dele, você irá escrever o seguinte: "este evento não está transparente".
Claro, não literalmente em português, mas em linguagem de código.
Para se referir a ''este evento'' escrevemos: self_event. e para dizer que a transparência (transparent) está ''desativada'', dizemos que ela está ''falsa'' (false)

def inimigo_tipo_1
  if self_event.transparent == false
  
  else  
    
end
  
  end

O sinal de '==' é um comparador. Ele compara, verifica, se o que está sendo colocando após ele é verdadeiro ou falso.
É como se você pudesse substituir o ''=='' pela palavra "está", meio que dizendo ''tal coisa está de tal forma"
Ou seja, o código: if self_event.transparent == false; sendo traduzido pro português fica:

"se este evento está com a transparência desativada"...

Dentro desse bloco de condição nós iremos colocar o que irá acontecer se a transparência do inimigo for falsa, ou seja, se o inimigo está ativo no mapa, não morreu.

Podemos criar três coisas dentro desse bloco, lembra-se?

I) Pulamos nele e ele morre
II) Encostamos nele e nós quem morremos
III) Ele morre se cair nos buracos das fases

Vamos criar as condições cima em ordem, pode ser?

Primeiramente: Pular no inimigo e matá-lo.
Pense um pouco... Quando você pula sobre o inimigo você está de uma certa forma ''em cima'' dele, procede?
Como trabalhamos nesse programa com o plano cartesiano, aqui nós iremos ter como parâmetros de distâncias e colisões os eixos x e y, sendo x o eixo horizontal e o y o eixo vertical.
Quando pulamos no inimigos, ficamos sobre ele.
Então pensado-se nisto, nós devemos verificar o eixo x ou o eixo y quando pulamos no evento?
Se você respondeu o eixo y você está coberto de razão, pois o eixo y é referente à linha vertical no plano cartesiano convencional, logo, se pularmos num inimigo, estamos utilizando como parâmetro de distância o eixo vertical.

No plano cartesiano do RM, quanto mais acima, menor o valor da coordenada no eixo y.
Então se por exemplo, o inimigo se encontra na coordenada Y = 7 (por exemplo) e você estiver acima dele, muito provavelmente você estará numa coordenada Y menor que 7, por exemplo, y =5.
Então literalmente para verificarmos se estamos pulando no inimigo (está acima do inimigo) devemos dizer que o personagem ($game_player.) está numa coordenada y menor que o evento (self_event.)
Novamente vamos utilizar o comando de condição ''if'' para criarmos essa verificação (crie o else novamente também, pois depois vamos verificar se o personagem não está pulando no evento):

def inimigo_tipo_1
  if self_event.transparent == false
    if
      else
      
      end
  
  else  
    
end
  
  end
   

À frente do if vamos escrever o seguinte "coordenada y do personagem é menor que a coordenada y do evento". Claro, novamente em linguagem de programação, ficaria algo como:

$game_player.ay < self_event.ay

Seu código ficará assim:

def inimigo_tipo_1
  if self_event.transparent == false
    if  $game_player.ay < self_event.ay
      else
      
      end
  
  else  
    
end
  
  end

Mas, não basta apenas estarmos acima do evento para que ele morra, mesmo porque se o personagem estiver a qualquer local do mapa acima do evento, o inimigo morrerá, e não é isso que queremos, logo, precisamos que haja uma colisão entre o evento e o personagem quando estivermos sobre o inimigo.
O comando para verificar colisões é o seguinte: collide_with?(colisor)
Onde dentro do parênteses vamos substituir ''colisor'' pelo número do famigerado colisor.
No nosso caso, a colisão ocorrerá entre o inimigo e o personagem, então o nosso colisor é o personagem.
O personagem sempre terá o valor numérico (ID) 0, portanto o código ficará assim: collide_with?(0):
Vamos criar mais uma condição para verificarmos essa colisão:


def inimigo_tipo_1
  if self_event.transparent == false
    if  $game_player.ay < self_event.ay
           if collide_with?(0)
             end

      else
      
      end
  
  else  
    
end
  
  end

Dentro desse comando de colisão nós iremos colocar o que acontecerá quando pisarmos no evento, ou seja, o inimigo morrerá.

Primeiramente podemos ganhar pontos!
Esses pontos estarão armazenados numa variável, a variável de numeração 1.
Para definirmos uma variável simplesmente colocamos o seguinte:

$game_variables[n] onde ''n'' é o número da variável --> $game_variables[1]

Para adicionar pontos (valores) para essa variável, basta utilizar o sinal de soma "+" seguido de um sinal de igual "=".
O valor a ser adicionado deve ser escrito após o sinal de igual, no caso aqui, colocaremos para adicionar 100 pontos quando matarmos esse inimigo.
O código fica assim:

def inimigo_tipo_1
  if self_event.transparent == false
    if  $game_player.ay < self_event.ay
           if collide_with?(0)
             $game_variables[1] += 100
             end

      else
      
      end
  
  else  
    
end
  
  end

Podemos adicionar também um pequeno pulo de impulso quando pularmos sobre o inimigo, em resposta à colisão.
O comando para isso é o seguinte: $game_player.move_y(-30,2)

Onde -30 e 2 são constantes que você poderá alterar.
O -30 representa a distância no eixo y que o personagem irá percorrer (quanto maior for o número que colocar, mais alto ele pulará) e 2 é o tempo decorrido em que o personagem irá pular nessa distância.
O código então está dessa forma:

def inimigo_tipo_1
  if self_event.transparent == false
    if  $game_player.ay < self_event.ay
           if collide_with?(0)
             $game_variables[1] += 100
                $game_player.move_y(-30,2)
             end

      else
      
      end
  
  else  
    
end
  
  end


Nesse momento podemos criar um método para definirmos um padrão de morte pros eventos, ou seja: a reprodução de um áudio, e tornar o inimigo transparente e atravessável.
Abaixo do último ''end'' do código, crie o novo método, vou chamá-lo de ''morte'':

def inimigo_tipo_1
  if self_event.transparent == false
    if  $game_player.ay < self_event.ay
           if collide_with?(0)
             $game_variables[1] += 100
                $game_player.move_y(-30,2)
             end

      else
      
      end
  
  else  
    
end
  
  end

def morte

end

Dentro do bloco do método ''morte'' vamos reproduzir um efeito sonoro (SE) para a morte do inimigo.
Esse áudio deve estar na pasta "Audio >> SE" do seu projeto.
O código para reproduzirmos um SE é:

RPG::SE.new("nome do arquivo de áudio", volume, tom).play

No primeiro parâmetro coloque o nome exato do arquivo de áudio do SE que você quer reproduzir (no meu caso o nome é ''drop") e em ''volume'' coloque o valor do volume do som (de zero à 100) e e tom faça o mesmo.
O meu ficou assim:

def morte
  RPG::SE.new("drop", 80, 100).play

end


Agora vamos deixar a transparência e a passabilidade desse evento ativados, escreva os comandos:

self_event.transparent = true
self_event.through = true

O método 'morte' deve estar assim:

def morte
  RPG::SE.new("drop", 80, 100).play
      self_event.transparent = true
         self_event.through = true
end

Agora volte dentro do bloco da condição de colisão, e abaixo do comando do impulso ''chame'' o método''morte'', escrevendo o comando: return seguido do nome do método.
O código deve estar assim:

def inimigo_tipo_1
  if self_event.transparent == false
    if  $game_player.ay < self_event.ay
           if collide_with?(0)
             $game_variables[1] += 100
                $game_player.move_y(-30,2)
               return morte
             end

      else
      
      end
  
  else  
    
end
  
  end

def morte
  RPG::SE.new("drop", 80, 100).play
      self_event.transparent = true
         self_event.through = true
end


Dê ok no seu código e agora na lista de scripts procure por "Game_CharacterBase".
Nas linhas 31 e 35 do código, troque onde está escrito "attr_reader" por "attr_accessor".

Após ter feito isto dê ok e rode o teste do jogo pressionando F12 em seu teclado.
Note que o inimigo está lá, se você encostar nele nada acontece, mas se pisar nele, ele morrerá.

Agora que está tudo ok, vamos fazer com que o inimigo nos mate se nós encostarmos nele?

Dentro do primeiro ''else'' no código, estamos dizendo que o personagem não está acima do evento, logo, ele não está pisando nele, portanto se encostarmos nele através de uma colisão, ele irá nos matar.
Então dentro do else vamos criar a condição de colisão novamente:

def inimigo_tipo_1
  if self_event.transparent == false
    if  $game_player.ay < self_event.ay
           if collide_with?(0)
             $game_variables[1] += 100
                $game_player.move_y(-30,2)
               return morte
             end

      else
       if collide_with?(0)
end
      
      end
  
  else  
    
end
  
  end

def morte
  RPG::SE.new("drop", 80, 100).play
      self_event.transparent = true
         self_event.through = true
end

Dentro desse bloco vamos colocar o que vai acontecer se morrermos:
1) Um SE de morte é reproduzido, no caso, meu SE se chama "morreu";
2) Somos impulsionados para cima;
3) Um método de respawn (recomeço) é chamado

Então temos o seguinte:

RPG::SE.new("morreu", 75, 100).play
$game_player.move_y(-90,2)
return respawn

O código fica assim então:

def inimigo_tipo_1
  if self_event.transparent == false
    if  $game_player.ay < self_event.ay
           if collide_with?(0)
             $game_variables[1] += 100
                $game_player.move_y(-30,2)
               return morte
             end

      else
       if collide_with?(0)
RPG::SE.new("morreu", 75, 100).play
          $game_player.move_y(-90,2)
              return respawn
end
      
      end
  
  else  
    
end
  
  end

def morte
  RPG::SE.new("drop", 80, 100).play
      self_event.transparent = true
         self_event.through = true

end


Agora vamos criar o método do respawn ao ser retornado dentro do comando de colisão, abaixo do método ''morte'':

def respawn

end

Em breve irei ensinar como criar um respawn mais personalizado, possuindo a retirada de vidas do personagem, reset de posição dos eventos, check point, e etc. Mas por enquanto vamos fazer apenas o personagem voltar para o início do mapa.

Para isso vamos utilizar o comando de teleporte: 

 $game_player.reserve_transfer(map_id, x, y, direçao)

Troque ''map_id'' pelo ID do mapa em que seu inimigo se encontra, x pela coordenada x inicial do mapa, y pela coordenada y inicial do mapa, e direção é um valor numérico que define a direção do personagem ao ser teleportado, sendo 3 virado para a direita.
Meu código ficará então:

$game_player.reserve_transfer(1, 8, 7, 3)

Vamos também adicionar um valor qualquer à uma variável que verificará se o método de respawn está ativo:

$game_variables[2] = 1

Seu método deve estar assim:

def respawn
     $game_player.reserve_transfer(1, 8, 7, 3)
          $game_variables[2] = 1
end


Nesse momento, dentro do outro 'else' restante, vamos poder verificar se o respawn foi ativo no mapa quando o inimigo estiver morto. Assim ele poderá voltar, sendo resetado.
Dentro do comando 'else', crie uma condição que verifique se a variável "2" é igual a 1:
Lembra-se do operador ''está''? ==

O código deve estar assim:

def inimigo_tipo_1
  if self_event.transparent == false
    if  $game_player.ay < self_event.ay
           if collide_with?(0)
             $game_variables[1] += 100
                $game_player.move_y(-30,2)
               return morte
             end

      else
       if collide_with?(0)
RPG::SE.new("morreu", 75, 100).play
          $game_player.move_y(-90,2)
              return respawn
end
      
      end
  
  else  
     if  $game_variables[2] == 1

end
    
end
  
  end

def morte
  RPG::SE.new("drop", 80, 100).play
      self_event.transparent = true

         self_event.through = true
end

def respawn
     $game_player.reserve_transfer(1, 8, 7, 3)
          $game_variables[2] = 1
end


Dentro dessa condição você irá deixar a transparência e a passabilidade do evento desativadas:

 self_event.transparent = false

    self_event.through = false

Por fim, seu código deve estar dessa forma:

def inimigo_tipo_1
  if self_event.transparent == false
    if  $game_player.ay < self_event.ay
           if collide_with?(0)
             $game_variables[1] += 100
                $game_player.move_y(-30,2)
               return morte
             end

      else
       if collide_with?(0)
RPG::SE.new("morreu", 75, 100).play
          $game_player.move_y(-90,2)
              return respawn
end
      
      end
  
  else  
     if  $game_variables[2] == 1
self_event.transparent = false


         self_event.through = false
end
    
end
  
  end

def morte
  RPG::SE.new("drop", 80, 100).play
      self_event.transparent = true

         self_event.through = true
end

def respawn
     $game_player.reserve_transfer(1, 8, 7, 3)
          $game_variables[2] = 1
end

Teste o jogo e veja que agora ao encostar no inimigo sem pular nele, você ''morre'' sendo recolocado no início do mapa.

O tutorial chega ao fim, mas em breve irei explicar como criar projéteis (então esse código pode ficar maior), vidas, e demais outras coisas, portanto aguarde!
Qualquer dúvida deixe aí nos comentários... Fuis...