Como pego uma posição dentro de um Collider e acesso ela?

Olá pessoal, tudo bem?

Não sei se é a melhor maneira de se fazer isto, mas estou criando um assistente para tiro.

Criei um Box Collider no meu player e sempre que o Inimigo atravessar este Box, o collider pega a posição de onde ele está, porém como faço parar o tiro ir em direção a ela?

Da maneira que estou fazendo agora, a arma está pegando a posição do Vector3 mas está atirando em um lugar aleatório no mundo do jogo e não na posição do Box.

Por enquanto o Script está assim: 

Código:

private void OnTriggerEnter(Collider other)
    {
        if (other.gameObject.CompareTag("Carro"))
        {
        GameObject gHit = other.gameObject;
        Transform tHit = gHit.transform;
        Enemyposition = new Vector3(tHit.position.x,
                                    tHit.position.y,
                                    tHit.position.z
                                    );
        Debug.Log(Enemyposition);
        }
    }

    public void Shoot()
    {

        AT.audioTiros.Play();

        
        Ray ray = new Ray(attackPoint.transform.position, Enemyposition);
        RaycastHit hit;
        Vector3 targetPoint;
        if(Physics.Raycast(attackPoint.transform.position, Enemyposition, out hit)){          
            targetPoint = hit.point;
        } else {
            targetPoint = ray.GetPoint(180);
        }

Não seria mais simples manter registro dos inimigos, usando uma lista ou array?
Com isso você não dependeria do inimigo passar no colisor e nem precisaria encher a cena com colisores...
Isso é pro jogo estilo Rocket League?
mantendo o registro dos jogadores, você pode por exemplo calcular o ângulo pra cada um deles, e com base na direção do joystick, pegar o inimigo com o ângulo mais próximo do que você tentou mirar.
Sobre o raycast, é desnecessário, imagina que você travou a mira no inimigo x, se você disparar um raycast na posição dele é meio óbvio que vai acertar, então dá pra poupar uns ciclos de cpu e só dar dano usando a própria referencia que você pegou usando o ângulo.
Raycast só é válido se o player tiver que mirar, mas se ainda quiser insistir no sistema atual, basta alterar essa linha

Código:

Ray ray = new Ray(attackPoint.transform.position, Enemyposition);

mas fazendo new Ray((Enemyposition - attackPoint.transform.position).normalized);
aí sim você vai ter uma direção.

E aqui:

Código:

if(Physics.Raycast(attackPoint.transform.position, Enemyposition, out hit)){

Você vai passar o ray que criou mais um valor máximo de distancia, e o out hit

Eai Fagner, tudo bom?

Cara, é esse jogo mesmo, acabei tendo alguns problemas no trabalho nos últimos meses e tive que dar uma parada no projeto e voltei a algumas semanas atrás.
Cara, sobre esta maneira que você indicou de fazer a mira, você teria algum arquivo em blog ou fórum, etc que me ajudasse a fazer esta mira da maneira que você indicou? A minha ideia é que a mira do carro se conecte-se minimamente ao inimigo, apenas quando ele estiver em uma área pequena em frente ao Player. Como uma assistência de mira mesmo. 

Vou pesquisar também sobre esta mira da maneira que você indicou. 

Mais uma vez, muito obrigado pela ajuda de sempre.

Isso aqui deve servir de base pra ti:

Código:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class AimAssist : MonoBehaviour
{
    public List<Transform> inimigos;
    public float lockAngulo = 10;
    public Transform target;

    private void Update()
    {
        if (ValidarAssist())
        {
            //Já encontrei o inimigo a minha frente (target), ele está no angulo limite e posso atirar nele;
            //Variável target contem a referencia do inimigo que eu posso atirar;
        }
        else
        {
            //Não posso atirar;
        }
    }

    private bool ValidarAssist()
    {
        float anguloRetorno;
        Transform inimigoAtual = EncontrarInimigo(out anguloRetorno);//Aqui recebo o transform do inimigo com menor angulo, e no out vem o valor que calculei no outro metodo, evita um novo calculo :)
       
        if (anguloRetorno < lockAngulo)
        {
            if (inimigoAtual != null)
            {
                target = inimigoAtual;
            }
        }
        else
        {
            target = null;
        }

        return anguloRetorno < lockAngulo; //Se o angulo atual for menor que o limite, posso lockar no inimigo;
    }

    private Transform EncontrarInimigo(out float anguloRetorno) //anguloRetorno recebe o melhor angulo e passa pro metodo que chamou o Encontrar Inimigo.
    {
        float melhorAngulo = float.MaxValue; //Inicia com o valor maximo
        int indiceInimigoSelecionado = -1;

        for (int i = 0; i < inimigos.Count; i++)
        {
            float angulo = Vector3.Angle(transform.forward, (inimigos[i].position - transform.position).normalized); //Angulo entre a frente do carro do jogador e a direcao pro inimigo (i)

            if (angulo < melhorAngulo) //Se o angulo do inimigo atual for menor que o valor armazenado, salvo o novo valor e guardo o indice desse inimigo;
            {
                melhorAngulo = angulo;
                indiceInimigoSelecionado = i;               
            }
        }

        anguloRetorno = melhorAngulo;

        if (indiceInimigoSelecionado != -1) //Apenas pra não dar erro, caso não tenha mais nenhum inimigo vivo.
        {
            return inimigos[indiceInimigoSelecionado];
        }
        else
        {
            return null;
        }
    }

    #region Debug

    private void OnDrawGizmos()
    {
        if (target != null)
        {
            Gizmos.DrawLine(target.position, transform.position);
        }

        //Desenha os limites do angulo do Assist
        Quaternion rot = Quaternion.Euler(0, lockAngulo, 0);
        Gizmos.DrawLine(transform.position, rot * transform.forward * 20);
        rot = Quaternion.Euler(0, -lockAngulo, 0);
        Gizmos.DrawLine(transform.position, rot * transform.forward * 20);
    }

    #endregion
}

Fagner muito obrigado cara. Tu é o melhor. rsrs

Eu só estou dando uma estudada em como implementar este sistema, retirar o Ray como você indicou e acessar os Players instanciados nesta List de inimigos. Mas tu já me deu um excelente caminho.

Fagner, desculpa mas só queria perturbar você com mais um detalhe. 

No Código você criou tem uma lista de inimigos no início correto. Eu estava tendo um pouquinho de dificuldade de entender a implementação deste código, então peguei este tutorial  que é bem parecido com o código que você passou, fui comparando cada passa para não só usar o código mas também entender como ele funciona. 

Mas estou com uma dúvida em relação ao seu List no início.

Vamos lá, por enquanto no meu game os Carros dos jogadores são instanciados, por enquanto são apenas 4 player, todos os carros estão usando a TAG "Carro" então, ao ser instanciados ele criam uma lista com a Tag correto? Ficando Carro[0], Carro[1], Carro[2], Carro[3].

Além disso, fiz um mecanismo para passar uma Layer para cada Carro ao ser instânciado. Ficando Player 1, Player 2, Player 3 e Player 4.

Pela List que você passou no seu código, como eu consigo fazer com que este código pegue todos os carros que foram instanciados, e use eles como alvo? (Menos o carro pertencente a arma que esta com ele.) 

Quando eu faço em jogo, se eu pegar o carro e colocar no componente correspondente ele passa a seguir, mas ainda não sei como fazer isso automaticamente.

Ainda está usando o Mirror?
Se sim, basta preencher a lista na OnStartAuthority();
Esse método só é chamado no objeto que você tem autoridade, no caso, apenas seu veiculo.

Também dá pra fazer assim:

Código:

using System.Collections.Generic;
using UnityEngine;

public class AimAssist : MonoBehaviour
{
    public List<Transform> inimigos;

    private void Start()
    {
        Carro meuCarro = GetComponent<Carro>();//PEgo o carro em que esse script está

        Carro[] carros = FindObjectsOfType<Carro>(); //Pego todos os carros na cena;

        for (int i = 0; i < carros.Length; i++)//Percorro todos os carros, se não for o meu, adiciono à lista.
        {
            if (carros[i] != meuCarro)
            {
                inimigos.Add(carros[i].transform);
            }
        }
    }
}

Eu criei o array de transform, mas talvez seja mais conveniente criar o array usando o script do veiculo como tipo, dessa forma você ainda tem acesso ao transform, mas facilita caso queira acessar algum atributo do veiculo, como a vida, etc.
Afinal você não vai querer continuar lockando a mira num carro que já morreu.

#edit:
Não lembrei que inimigos era uma lista, atualizei o code.

Pior que não cara, rsrsrs

Na verdade eu quero e pretendo ainda voltar nisso, mas eu sou muito ruim no básico na programação cara, estava me sentindo dando um passo muito maior do que minhas pernas pensando em modo online no jogo agora, sabe? 

Mas eu ainda estou tentando fazer um protótipo jogável para decidir o que fazer depois disso. Como eu te falei, eu fiquei um bom tempo se mexer no projeto por causa do trabalho e voltei a pouco. 

É isso cara, ainda estou meio na dúvida do que fazer. O que eu quero de fato é terminar esse protótipo e depois decidir se eu abandono ou sigo em frente. De qualquer maneira, até aqui, todo esse estudo foi muito bom pois aprendi muito em relação a modelagem 3D para jogos.

Eu tinha mandado a resposta antes de você editar. rs

Cara, mais uma vez muito obrigado, tu é o melhor rsrsrs.

Pior que vendo o código parece tudo tão fácil, é impressionante. 

Vlw mesmo.