Ataque no inimigo

[Koreha]

Estou fazendo um jogo e nele o ataque básico do personagem é um corte que dura aproximadamente um segundo. Queria saber como fazer esse corte poder atingir vários inimigos, mas com cada inimigo sendo atingido somente uma vez pelo mesmo corte.

[Midgard]

Olá, Boa Tarde,

Acredito que a melhor forma de realizar isso seja com a função collision_line( x1, y1, x2, y2, obj, prec, notme ) já que se trata de um corte(imagino algo como alcance de uma espada), mais tarde posso fazer uma engine exemplificando o trabalho em conjunto com alarm, pois desta forma tem como tratar que se ocorrer a colisão em algum dos pontos da área determinada pela linha de colisão, o obj inimigo receberá o efeito da colisão um única vez.

lib da collision_line: http://docs.yoyogames.com/source/dadios ... _line.html

[Koreha]

Olá, Boa Tarde,

Acredito que a melhor forma de realizar isso seja com a função collision_line( x1, y1, x2, y2, obj, prec, notme ) já que se trata de um corte(imagino algo como alcance de uma espada), mais tarde posso fazer uma engine exemplificando o trabalho em conjunto com alarm, pois desta forma tem como tratar que se ocorrer a colisão em algum dos pontos da área determinada pela linha de colisão, o obj inimigo receberá o efeito da colisão um única vez.

lib da collision_line: http://docs.yoyogames.com/source/dadios ... _line.html

Acredito que não botei dados suficientes para a compreensão plena no problema. O que ocorre é o seguinte:
Quando o jogador aperta a tecla "A" ele cria um corte na frente dele com o instance_create();
Neste corte botei os seguintes códigos:
Create:

Código: Selecionar todos

image_angle = 30

image_alpha = 1

Step:

Código: Selecionar todos

image_alpha -= 0.05
image_xscale += 0.125
if image_alpha <= 0 {
    instance_destroy()
}

             Isso faz com que o corte dure aproximadamente 1 segundo. E o problema que vem com isso é que no evento de colisão entre o obj_corte e o obj_inimigo, presente no obj_inimigo, usei o seguinte código:

Código: Selecionar todos

vida -= 1

               Com isso, a cada step o corte dá 1 de dano no inimigo, fazendo com que este morra com um só corte. Para resolver esse problema pensei em utilizar alarms, mas me deparei com outro problema: o corte dura 1 segundo, mas o jogador pode cortar a cada meio segundo. Isso faria com que existissem duas instâncias do obj_corte na tela ao mesmo tempo e a segunda não cortasse o inimigo no tempo certo (que seria quando o botão "A" é apertado). Isso causaria um desconforto no jogador, por isso desconsiderei. 

Com isso tudo queria saber: como fazer com que o obj_corte atinja o inimigo uma única vez, com ele continuando capaz de atingir outros inimigos?

[Midgard]

Bom dia,

Hum, entendi o que deseja fazer logicamente, você precisa de algo que cheque se em algum momento as instancias criadas já colidiram, acho que é possível da seguinte maneira(não é uma boa solução):

Você pode em um script que inicie a variáveis globais, criar uma variável global com o valor 0(instAtk - instancia de ataque), usaremos ela de forma incremental de forma que o valor não se repita, a menos que limpemos seu conteúdo.

Ao clicar em b para este ataque - no create do objeto ataque cria uma variável instAtkLoc que recebe o valor da global(insATK) e a global. insATK recebe +1 .

No create do obj_inimigo crie instAtkIni com valor zero.
na colisão  verifique com um if se o valor do   instAtkIni é menor que obj_atk instAtkLoc, se a condição for verdadeira hp inimigo recebe -1 e instAtkIni recebe instAtkLoc


Desta forma o ataque não causará dano novamente a um objeto que já teve colisão, porém se aumentarmos o tempo do ataque em 5 segundos, se ataques forem feitos simultâneos e o obj inimigo colidir primeiro com a instância do segundo ataque, ele não será afetado pelo dano do primeiro ataque.

Como resolver isso com esta lógica demonstrada?
Bom o obj_inimigo teria que gravar num array, os valores das instancias do objatk que ele já colidiu, aí na verificação iria ter que verificar se tal valor está contido no array, mas esta operação iria se assemelhar a um sort, o que consumiria processamento....

Achei diferente esta forma de ataque, pois num rpg por exemplo quando se tem um ataque que aplique dano a mais de um personagem ao mesmo tempo, no momento do ataque ele afetaria quem teve colisão, se for constante possibilitando que conforme o inimigo vai encostando vai recebendo dano, é aplicado a quem já recebeu o dano e a quem ainda não recebeu o dano. Interessante, est solução que coloquei é bem mais ou menos, mas como vi que ainda não lhe apresentaram mais nenhuma, boa sorte! :)

[Superbomber]

Eu já fiz algo que precisei resolver o mesmo problema.

No inimigo, crie uma variável hited e inicie seu valor como false.

No step, faça algo como isso:

Código: Selecionar todos

if( !place_meeting(obj_corte, x, y) ){ // se NÃO estiver colidindo...
   hited = false;
} else if( !hited ){ // se estiver colidingo e hited = false
   hited = true;
   life.  -= 5;
}

Quando verificar se foi atacado, verifique se hited é false.
Ao ser atacado mude hited para true, e quando não estiver mais sendo atacado mude hited para false.

Pode usar alarm para mudar o hited para false, mas isso vai depender da situação de seu jogo.

Bye.

[saim]

O que eu tentaria fazer é manter uma array com todas as intâncias do objeto corte. Assim, uma nova intância entraria na array causando o dano, ao passo que instâncias que já estivessem na array não fariam nada.
No segundo step de colisão, o código já teria a instância "cadastrada" e a ignoraria.
<create>

Código: Selecionar todos

nCortes = 0; // pro loop "for", na colisão

<colisão>

Código: Selecionar todos

var i, novoCorte;
novoCorte = true; // verifica se o corte é novo ou existente
for(i = 0; i < nCortes; i += 1){ // verifica na array se já existe o corte
if arrayCortes[i] = other . id{ // se o corte já está na array
novoCorte = false;      // muda a variável, pro código não fazer nada
}
}
// nesse ponto, se a variável "novoCorte" ainda for "true", o corte será novo
if (novoCorte == true){
vida -= 1; // causa o dano
arrayCortes[nCortes] = other . id; // coloca o corte na array, pra não causar dano no próximo step
nCortes += 1; // aumenta o tamanho da array
}

Pode parecer que a array vai ficar muito grande e o loop vai consumir memória, mas um bom gameplay não requer mais que 10 golpes pra um inimigo-padrão morrer. Um boss, que requer mais golpes, ainda não deve chegar num tamanho significativo da array (além de aparecer em momentos com menos instâncias de inimigos na tela).

XXXXXXXXXXXX

Outra solução bem mais simples seria fazer o golpe atuar apenas no primeiro step, mas isso pode ir de encontro ao gameplay que você imaginou.

[Dust]

Bem... eu acho que o tópico ja foi resolvido kkk
Mas eu simplesmente usaria um draw_sprite_ext() com uma sprite de uma daquelas faixas de corte brancas, depois era só checar se o inimigo estava proximo do player, e então dava um hit por meio de uma variavel. O problema seria resolvido em poucas linhas.

[Koreha]

Obrigado pela ajuda de todos, mas desisti por ora de implementar esse sistema. Decidi fazer o corte dar dano no instante em que é criado, ou seja, ele só funciona por 1 frame/step e depois disso ele deixa de causar dano. Mesmo assim agradeço.