Checando distancia para atirar no mais próximo

Já tirei boas dúvidas aqui e agora venho com essa que está martelando minha cabeça.
Preciso que meu inimigo que atira e aponta para 8 direções diferentes calcule qual o obj_aliado mais próximo e passe a atirar nele. porém caso o obj_player estiver mais próximo tbm atirar no obj_player. (tanto para a bala do inimigo quanto para o inimigo eu uso point direction para que siga a direção do obj_player)

marcin_w_ escreveu:Preciso que meu inimigo (...) calcule qual o obj_aliado mais próximo e passe a atirar nele. porém caso o obj_player estiver mais próximo tbm atirar no obj_player.

Já ouviu falar em objetos parents? Parents são objetos, tipo, "chefes" dos objetos-child. Então se você manda uma ação acontecer num parent, ela acontece em todos os child. Sempre que você "fala" pra um objeto-parent, os objeto-child "escutam".
Então, se o tanto o player quanto os objetos aliados tiverem como parent o mesmo objeto (vou chamar de objeto_aliado_parent) e seu inimigo calcular qual o objeto_aliado_parent mais próximo, isso vai valer tanto pra um aliado comum quanto pro player. Não vai ter preferência.

E, pra saber qual o mais próximo, basta usar instance_nearest.

Agora, pra conseguir colocar o carinha na mira usando apenas as 8 direções, aí já é mais complicado. Mas como isso não faz parte da pergunta, vou presumir que já exista solução.

Penso que a função que vai resolver seu problema é a instance_nearest(x, y, obj);

Mais precisamente:

No código do obj_player:

Código:


vouatirar=instance_nearest(x, y, obj_aliado);


Vou tentar ser um pouco mais claro, meu jogo é basicamente um Player que se movimenta atirando em 8 direções, porém os tiros não são precisos...eu uso random (oque resolve o problema de mira das 8 direções).....o obj inimigo eh basicamente a msma coisa....porém ao invés de usar o random ...uso apenas point direction nas balas inimigas seguindo o player...e faço o obj inimigo me seguir com as direções dando assim uma solução para os tiros sairem na direção em que ele está apontando.


Minha intenção agora é fazer objetos tanto aliados quanto inimigos que batalham entre si ...

raciocinando a respeito pensei que as duas primeiras coisas que preciso saber para programar a IA dessas batalhas entre os figurantes são:

1- Fazer obj_aliado_do_inimigo identificar qual o obj_aliado mais próximo e atirar nele (vice versa)
porque nas batalhas os obj vão estar em movimento e as vezes vão parar.

2 - preciso que eles se movimentem pela batalha de forma natural..se escondam...em alguns casos recuam....em outros atiram....

no caso de usar instance_nearest...preciso de um esclarecimento melhor de como usar isso no meu caso.

desde já mais uma vez obrigado!!!

marcin_w_ escreveu:2 - preciso que eles se movimentem pela batalha de forma natural..se escondam...em alguns casos recuam....em outros atiram....

Isso requer uma IA BEM avançada. É infinitamente mais complicado que encontrar uma instância mais próxima. Quer mesmo tentar algo assim? Eu vou fazer um monte de perguntas, se quiser.

Me diz uma coisa... se o tiro segue o player, tipo, mudando de direção ao longo do tempo, qual o sentido de colocar uma margem de erro nele? Sempre ele vai atingir o alvo. O que eu recomendo é atirar na direção mais próxima e usar o erro na hora de criar o tiro. Uma vez criado, o tiro não muda de direção.

instance_nearest te retorna a id da instância mais próxima do objeto que chamou a função. Tendo a id, você tem a posição da instância. Tendo a posição, você sabe pra onde atirar.

Código:

alvo := instance_nearest(objeto_parent);
direção_do_tiro := point_direction(x, y, alvo . x, alvo . y);
with(instance_create(x, y, objeto_tiro)){
direction = -erro + random(2 * erro) + other . direção_do_tiro;
}

marcin_w_ escreveu:
no caso de usar instance_nearest...preciso de um esclarecimento melhor de como usar isso no meu caso.

Essa função (instance_nearest(x,y,obj)) vai retornar o ID do objeto (do tipo obj) mais próximo da posição x,y passadas como parâmetro.

Por exemplo, se vc quiser saber qual inimigo está mais próximo de um aliado:
Dentro do Objeto Aliado:

Código:

inimigomaisproximo=instance_nearest(x, y, obj_inimigo);

Entendeu ?

Saim, o tiro não muda de direção ao longo do percurso...

mudaria se fosse o msmo tiro...mas eu falei de dois

1-tiro player = usa direcção player apontando + random
2 tiro inimigo = usa point direction no create.

a respeito da IA, vc ja me ajudou em outras vezes de forma bem construtiva....se vc tiver paciencia para me ajudar na IA seria mt bom pra mim....vou enviar uma foto do jogo pra vc entender melhor o esquema.





Nessa imagem pode ser visto o Player no canto inferior esquerdo...2 aliados..(terceiro ta morto)....e 3 inimigos.....todos se movimentam em 8 direções...porém a unica IA q criei foi dependendo da distancia q tem um do outro eles param.....

É um jogo sobre a segunda guerra...de tempos em tempos trabalho nele...agora q as sprites estao em um padrão que gostei (ja redesenhei 5 vezes tudo) quero q o jogo fique mais dinamico....aberto a sugestões...abraço!

Fred, valeu tbm por esclarecer muito bem o "instance_nearest"...

---

eu utilizo bastante o depth=-y portanto os objetos tem colisões e depths mt "realistas" como passar atrás do tronco ou na frente dependendo da "altura" em que o player ou os objetos estão se movimentando...

Editado por TRFN
Evite postagens consecutivas para não infringir alguma regra. Avisado, sem alerta. Postagens Fundidas!

Primeiro, tenho que dar a dica do "edit". Triple post, cara, cuidado com isso. Fica parecendo que você está ansioso, que não sabe esperar. A gente sabe que não é o caso, mas a regra existe e tem que ser seguida. Edite o post e acrescente o que quiser acrescentar.

Quanto ao tiro, ok, tem o inimigo e tem o aliado mais próximo dele. Então o inimigo vai atirar na direção do aliado. MAS o aliado está numa direção de 165° do inimigo, que só atira de 45 em 45 graus. Eu vejo 3 alternativas de solução:
1 - Ignore a regra dos 45° e atire no ângulo certo, com um erro aleatório, pro jogo ficar um pouco mais realista. Não importa se o ângulo da imagem do inimigo está num múltiplo de 45°, se você não mencionar isso, o jogador não vai se importar.
2 - Atire no ângulo múltiplo de 45° mais próximo do desejado. Colocar um erro pra deixar o jogo realista, aqui, me parece bobagem. O jogo não é realista. Pode ser pra melhorar o visual dos tiros andando na tela, mas aí, é testar e ver.
3 - Ande até um ponto próximo em que o ângulo entre as instâncias SEJA múltiplo de 45°, pra só então, atirar. Essa é a opção complicada que eu falei, lá no começo do tópico. Porque você vai precisar traçar uma linha num ângulo próximo do que você quer, do aliado até perto do inimigo, num ângulo múltiplo de 45° e outra linha, do inimigo até essa linha, perpendicular a ela. O inimigo vai ter que se deslocar de onde está até essa intersecção. Mas, quando isso acontecer, o aliado já vai ter mudado de lugar, então você precisa PREVER onde o aliado estará pra poder atirar. Muita complicação pra um tirinho que vai em linha reta.

Minha sugestão? 2.

saim escreveu:

marcin_w_ escreveu:2 - preciso que eles se movimentem pela batalha de forma natural..se escondam...em alguns casos recuam....em outros atiram....

Isso requer uma IA BEM avançada. É infinitamente mais complicado que encontrar uma instância mais próxima. Quer mesmo tentar algo assim? Eu vou fazer um monte de perguntas, se quiser.

marcin_w_ escreveu:a respeito da IA, vc ja me ajudou em outras vezes de forma bem construtiva....se vc tiver paciencia para me ajudar na IA seria mt bom pra mim....vou enviar uma foto do jogo pra vc entender melhor o esquema.

Eu quis dizer BEM AVANÇADA MESMO. Do tipo "não tenho certeza se eu consigo fazer algo do tipo".
Pra você ver que não estou te enrolando, deixa eu externar minhas preocupações abaixo. Tem alguns conceitos que você pode pegar nos tutoriais da minha assinatura, então não vou me preocupar em explicá-los.

Primeiro, você vai ter que entender a máquina de estados finitos. Não é complicado, mas é muito importante. Porque sem ela, eu nem saberia como começar a programar isso.
Depois, você vai os definir parâmetros que mudam a atitude dos inimigos. Em que situação eles atacam? Em que situação eles recuam? Muito sizo nessa hora. Se você usar "eles recuam quando o exercito deles é menor", pode fazer os inimigos recuarem diante de um soldado sozinho, que tem um exército mosntruoso tomando café, a milhas dali. Essa é a parte mais importante da IA: definir o que causa a mudança de comportamento.
E tem a questão deles se esconderem... COMO eles vão se esconder em campo aberto? Procurar cobertura? Certo, mas cobertura contra os tiros de quem? De TODO o exército aliado? E se o exército estiver bem espalhado? O que fazer se a cobertura estiver distante?Qual o alcance de um tiro? O que é considerado um lugar "seguro"?
Até consigo pensar em alguma coisa, usando um raciocínio parecido com o A*, mas pra definir pontos de segurança (células não atingidas pela linha de fogo inimiga). Depois, usa-se o A* propriamente dito pra chegar até esse ponto. Só que o A* é lento. De quanto em quanto tempo você quer rodar o código? E até quantas instâncias podem estar ativas ao mesmo tempo, no jogo? Em que plataforma o jogo será jogado?

Vale responder "não sei" pra qualquer uma dessas perguntas. Mas se você não tiver todas as respostas, não tem como programar o jogo.
Na verdade, não estou interessado nas respostas, imediatamente, mas em mostrar que o conceito é mais difícil de implementar do que parece, a princípio.
Mas não é impossível. Se se esforçar, você consegue. Mas eu não vou te ensinar como fazer, porque eu não sei fazer.
A gente pode inventar alguma coisa juntos.