Problema em criar tiros múltiplos

Bom dia,

estou tendo problema para criar 3 tiros ao mesmo tempo, sendo que um será instanciado em linha reta, outro será inclinado em 20 graus para cima e outro em 20 graus para baixo.

o script é esse:

Código:

public void Attack2() {
        if (shootCooldown <= 0) {
            shootCooldown = shootingRate;

            for (int i = 0; i <= 3; i++) {
                // Tiro na inclinaçao 0 graus
                var tiro2 = Resources.Load("Prefabs/player/Tiro2");            //Busca o nome do prefab
                Instantiate(tiro2, pontoTiro2.position, Quaternion.Euler(new Vector3(0, 0, 20)));  //Cria o tiro2
            }


        }
    }

quando simulo o jogo, estão sendo instanciados 4 tiros ao invés de 3 apenas, e todos eles saem em 20 graus para cima.
como fazer para o tiro sair inclinado em 20 graus para baixo e um reto?

e onde está o erro de sairem 4 tiros e não 3, sendo que o i <= 3?

Tente criar 3 comandos instantiate e apenas mude o vector 3 de cada um Ex 20 0 -20espero q funcione

para instanciar os tiro inclinados:

explicação: o for irá iniciar em -1 em vez de 0, e verificará até 2, a inclinação será multiplicada pelo int do for:

>>o for começa com -1 que é menor do que 2, então o código será executado e a inclinação será 20° vezes o -1 do for que resultará em -20° de inclinação, após o código ser executado o for irá incrementar o int com +1 agora o int é = 0

>>depois da primeira execução do for, o int será igual a 0 então a inclinação será 20 vezes 0 que resultará em 0° (sem inclinção), após a execução o for irá incrementar +1  agora o int é = 1

>>o int é igual a 1 que ainda está na condição menor que 2, então o for é executado novamente, agr a inclinação será 20 vezes o int que é = 1  resultando em 20° e o int será incrementado novamente ficando igual a 2 que está fora da condição do for fechando-o com um belo laçinho de veludo penteado e um beijinho carinhoso


[list=linenums]
[*]       
[*]if (shootCooldown <= 0) {

[*]            shootCooldown = shootingRate;


[*]            for (int i = -1; i < 2; i++) {

[*]                // Tiro na inclinaçao 0 graus

[*]                var tiro2 = Resources.Load("Prefabs/player/Tiro2");             //Busca o nome do prefab

[*]                Instantiate(tiro2, pontoTiro2.position, Quaternion.Euler(new Vector3(0, 0, 20*i)));   //Cria o tiro2

[*]            }



[*]        }

[*]    }

[/list]

DuViDoSo34, foi isso mesmo que eu fiz aqui e funcionou.
Mas imagina eu querer fazer varios tiros em 360 graus, uns 18 tiros por exemplo? Ia ter que escrever 18 vezes, aí o script ia ficar gigantesco.
Uma vez eu vi um script que usava o 'for' do jeito que eu  pus, for (int i = 0; i <= 3; i++)  , até cheguei a testar e funcionou, mas perdi esse script porque fiquei muito tempo sem mexer na unity, e não lembro onde encontrei na internet.
tinha mais linhas nele e nao me recordo.

com váriso comando eu fiz assim:
public void Attack () {
        if (shootCooldown <= 0) {
            shootCooldown = shootingRate;

            // Tiro na inclinaçao 0 graus
            var tiroReto = Resources.Load("Prefabs/player/Tiro2");             //Busca o nome do prefab
            Instantiate(tiroReto, pontoTiro2.position, Quaternion.Euler(new Vector3(0, 0, 0)));   //Cria o tiro reto

            // Tiro na inclinaçao 20 graus
            var tiroCima = Resources.Load("Prefabs/player/Tiro2");             //Busca o nome do prefab
            Instantiate(tiroCima, pontoTiro2.position, Quaternion.Euler(new Vector3(0, 0, 20)));   //Cria o tiro em 20 graus

            // Tiro na inclinaçao -20 graus
            var tiroBaixo = Resources.Load("Prefabs/player/Tiro2");             //Busca o nome do prefab
            Instantiate(tiroBaixo, pontoTiro2.position, Quaternion.Euler(new Vector3(0, 0, -20)));   //Cria o tiro em -20 graus
        }
    }


JailtonUnity, seu script funcionou legall, valeu!!

Um jeito fácil e compacto par instanciar quantos tiros você quiser é o seguinte:

Digamos que quero 8 tiros com angulações no eixo z: seria o mesmo esquema mudando apenas os valores.

for (int i = -4; i < 4; i++) {

var tiro2 = Resources.Load("Prefabs/player/Tiro2"); //Busca o nome do prefab
Instantiate(tiro2, pontoTiro2.position, Quaternion.Euler(new Vector3(0, 0, 10*i)));
}



E se eu quisesse instanciar esses mesmos tiros mas com a mesma angulação, porem um pouco randomizada, se a angulação era de 10 em 10 graus, ela poderia flutuar para 8 no 1 tiro e17 no segundo, etc. Mas respeitando um valor maximo de flutuação da angulação definida:

//variável q define o quanto poderá ser desviado a angulação padrão
Public Int valor = 4;

for (int i = -4; i < 4; i++) {
// Tiro na inclinaçao 0 graus
var tiro2 = Resources.Load("Prefabs/player/Tiro2"); //Busca o nome do prefab
Instantiate(tiro2, pontoTiro2.position, Quaternion.Euler(new Vector3(0, 0, Random.Range(10-valor, 10+valor)*i ))); //o range poderia retornar um valor entre 6 e 14 em vez de uma angulação fixa de 10°
}

Boa Jailton valeu pela dica!!!  ^^

Desculpem postar sem esperar as 24 hs, é só resolver isso o quanto antes.

Jailton, e caso eu queira inclinar os 3 tiros ao mesmo tempo (ou mais tiros, depende do nº que eu optar) mais para cima ou mais para baixo, como na imagem:



lembrei que no script que eu perdi tinha um comando que fazia isso.

Marc7 escreveu:Desculpem postar sem esperar as 24 hs, é só resolver isso o quanto antes.

Jailton, e caso eu queira inclinar os 3 tiros ao mesmo tempo (ou mais tiros, depende do nº que eu optar) mais para cima ou mais para baixo, como na imagem:



lembrei que no script que eu perdi tinha um comando que fazia isso.

eu reformulei o código, veja:

Código:

    public int quant_tiros = 3; //quantidade de tiros
    public float inclinacao = 20; //graus de inclinacao
    public float inclinacao_geral = 20; //rotacao geral


    void Start()
    {
        InstanciarTiros();
    }


    void InstanciarTiros()
    {
        GameObject[] tiros = new GameObject[quant_tiros]; //definindo um array com tamanho equivalente a "quant_tiros"
        tiros[0] = Resources.Load("Prefabs/player/Tiro1", typeof(GameObject)) as GameObject; //alocando o tiro 1
        tiros[1] = Resources.Load("Prefabs/player/Tiro2", typeof(GameObject)) as GameObject; //alocando o tiro 2
        tiros[2] = Resources.Load("Prefabs/player/Tiro3", typeof(GameObject)) as GameObject; //alocando o tiro 3

        for (int i = 0; i < quant_tiros; i++)
        {
            //instancia os tiros alocando-os em uma variável para ser rotacionado posteriormente
            GameObject tiros_instances = Instantiate(tiros[i], transform.position, Quaternion.Euler(new Vector3(0, 0, inclinacao * i))) as GameObject;
            tiros_instances.transform.Rotate(0, 0, inclinacao_geral);
        }
    }