Ajuda com IA

Galera o marcos criou esse script aqui de raio de visão de um IA, porem o script do inimigo é muito simples, como eu posso colocar essa FOV (o script de visão) nesse outro script?


-----------------
SCRIPT FOV
-----------------

Código:

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

public class FOVInimigos : MonoBehaviour {

    [Header("Geral")]
    public Transform cabecaInimigo;
    public enum TipoDeColisao {
        RayCast, OverlapSphere
    };
    public TipoDeColisao _tipoDeColisao = TipoDeColisao.RayCast;
    public enum TipoDeChecagem {
        _10PorSegundo, _20PorSegundo, OTempoTodo
    };
    public TipoDeChecagem _tipoDeChecagem = TipoDeChecagem.OTempoTodo;
    [Range(1, 50)]
    public float distanciaDeVisao = 10;

    [Header("OverlapSphere")]
    public LayerMask layersDosInimigos = 2;
    public bool desenharEsfera = true;

    [Header("Raycast")]
    public string tagDosInimigos = "Respawn";
    [Range(2, 180)]
    public float raiosExtraPorCamada = 20;
    [Range(5, 180)]
    public float anguloDeVisao = 120;
    [Range(1, 10)]
    public int numeroDeCamadas = 3;
    [Range(0.02f, 0.15f)]
    public float distanciaEntreCamadas = 0.1f;
    //
    [Space(10)]
    public List<Transform> inimigosVisiveis = new List<Transform>();
    List<Transform> listaTemporariaDeColisoes = new List<Transform>();
    LayerMask layerObstaculos;
    float timerChecagem = 0;

    private void Start() {
        timerChecagem = 0;
        if (!cabecaInimigo) {
            cabecaInimigo = transform;
        }
        // o operador ~ inverte o estado dos bits (0 passa a ser 1, e vice versa)
        layerObstaculos = ~layersDosInimigos;
    }

    void Update() {
        if (_tipoDeChecagem == TipoDeChecagem._10PorSegundo) {
            timerChecagem += Time.deltaTime;
            if (timerChecagem >= 0.1f) {
                timerChecagem = 0;
                ChecarInimigos();
            }
        }
        if (_tipoDeChecagem == TipoDeChecagem._20PorSegundo) {
            timerChecagem += Time.deltaTime;
            if (timerChecagem >= 0.05f) {
                timerChecagem = 0;
                ChecarInimigos();
            }
        }
        if (_tipoDeChecagem == TipoDeChecagem.OTempoTodo) {
            ChecarInimigos();
        }
    }

    private void ChecarInimigos() {
        if (_tipoDeColisao == TipoDeColisao.RayCast) {
            float limiteCamadas = numeroDeCamadas * 0.5f;
            for (int x = 0; x <= raiosExtraPorCamada; x++) {
                for (float y = -limiteCamadas + 0.5f; y <= limiteCamadas; y++) {
                    float angleToRay = x * (anguloDeVisao / raiosExtraPorCamada) + ((180.0f - anguloDeVisao) * 0.5f);
                    Vector3 directionMultipl = (-cabecaInimigo.right) + (cabecaInimigo.up * y * distanciaEntreCamadas);
                    Vector3 rayDirection = Quaternion.AngleAxis(angleToRay, cabecaInimigo.up) * directionMultipl;
                    //
                    RaycastHit hitRaycast;
                    if (Physics.Raycast(cabecaInimigo.position, rayDirection, out hitRaycast, distanciaDeVisao)) {
                        if (!hitRaycast.transform.IsChildOf(transform.root) && !hitRaycast.collider.isTrigger) {
                            if (hitRaycast.collider.gameObject.CompareTag(tagDosInimigos)) {
                                Debug.DrawLine(cabecaInimigo.position, hitRaycast.point, Color.red);
                                //
                                if (!listaTemporariaDeColisoes.Contains(hitRaycast.transform)) {
                                    listaTemporariaDeColisoes.Add(hitRaycast.transform);
                                }
                                if (!inimigosVisiveis.Contains(hitRaycast.transform)) {
                                    inimigosVisiveis.Add(hitRaycast.transform);
                                }
                            }
                        }
                    } else {
                        Debug.DrawRay(cabecaInimigo.position, rayDirection * distanciaDeVisao, Color.green);
                    }
                }
            }
        }
        if (_tipoDeColisao == TipoDeColisao.OverlapSphere) {
            Collider[] alvosNoRaioDeAlcance = Physics.OverlapSphere(cabecaInimigo.position, distanciaDeVisao, layersDosInimigos);
            foreach (Collider targetCollider in alvosNoRaioDeAlcance) {
                Transform alvo = targetCollider.transform;
                Vector3 direcaoDoAlvo = (alvo.position - cabecaInimigo.position).normalized;
                if (Vector3.Angle(cabecaInimigo.forward, direcaoDoAlvo) < (anguloDeVisao / 2.0f)) {
                    float distanciaDoAlvo = Vector3.Distance(transform.position, alvo.position);
                    if (!Physics.Raycast(cabecaInimigo.position, direcaoDoAlvo, distanciaDoAlvo, layerObstaculos)) {
                        if (!alvo.transform.IsChildOf(cabecaInimigo.root)) {
                            if (!listaTemporariaDeColisoes.Contains(alvo)) {
                                listaTemporariaDeColisoes.Add(alvo);
                            }
                            if (!inimigosVisiveis.Contains(alvo)) {
                                inimigosVisiveis.Add(alvo);
                            }
                        }
                    }
                }
            }
            for (int x = 0; x < inimigosVisiveis.Count; x++) {
                Debug.DrawLine(cabecaInimigo.position, inimigosVisiveis[x].position, Color.blue);
            }
        }
        //remove da lista inimigos que não estão visiveis
        for (int x = 0; x < inimigosVisiveis.Count; x++) {
            if (!listaTemporariaDeColisoes.Contains(inimigosVisiveis[x])) {
                inimigosVisiveis.Remove(inimigosVisiveis[x]);
            }
        }
        listaTemporariaDeColisoes.Clear();
    }

    #if UNITY_EDITOR
    private void OnDrawGizmosSelected() {
        if (_tipoDeColisao == TipoDeColisao.OverlapSphere) {
            if (desenharEsfera) {
                Gizmos.color = Color.white;
                Gizmos.DrawWireSphere(cabecaInimigo.position, distanciaDeVisao);
            }
            Gizmos.color = Color.green;
            float angleToRay1 = (180.0f - anguloDeVisao) * 0.5f;
            float angleToRay2 = anguloDeVisao + (180.0f - anguloDeVisao) * 0.5f;
            Vector3 rayDirection1 = Quaternion.AngleAxis(angleToRay1, cabecaInimigo.up) * (-transform.right);
            Vector3 rayDirection2 = Quaternion.AngleAxis(angleToRay2, cabecaInimigo.up) * (-transform.right);
            Gizmos.DrawRay(cabecaInimigo.position, rayDirection1 * distanciaDeVisao);
            Gizmos.DrawRay(cabecaInimigo.position, rayDirection2 * distanciaDeVisao);
            //
            UnityEditor.Handles.color = Color.green;
            float angle = Vector3.Angle(transform.forward, rayDirection1);
            Vector3 pos = cabecaInimigo.position + (cabecaInimigo.forward * distanciaDeVisao * Mathf.Cos(angle * Mathf.Deg2Rad));
            UnityEditor.Handles.DrawWireDisc(pos, cabecaInimigo.transform.forward, distanciaDeVisao * Mathf.Sin(angle * Mathf.Deg2Rad));
        }
    }
    #endif
}

------------------------
SCRIPT DA INTELIGENCIA AI
------------------------

Código:

using UnityEngine;
using System.Collections;


public class INTELIGENCIA2 : MonoBehaviour
{
    public Transform Player;
    private UnityEngine.AI.NavMeshAgent naveMesh;
    public float DistanciaDoPlayer, DistanciaDoAIPoint;
    public float DistanciaDePercepcao = 30, DistanciaDeSeguir = 20, DistanciaDeAtacar = 2, VelocidadeDePasseio = 3, VelocidadeDePerseguicao = 6, TempoPorAtaque = 1.5f, DanoDoInimigo = 40;
    private bool VendoOPlayer;
    public Transform[] DestinosAleatorios;
    private int AIPointAtual;
    private bool PerseguindoAlgo, contadorPerseguindoAlgo, atacandoAlgo, contadorOlhar;
    private float cronometroDaPerseguicao, cronometroAtaque, cronometroOlhar;
    public bool BPassear, BOlhar, BPerseguir, BAtacar;

    void Start()
    {
        AIPointAtual = Random.Range(0, DestinosAleatorios.Length);
        naveMesh = transform.GetComponent<UnityEngine.AI.NavMeshAgent>();
    }
    void Update()
    {
        DistanciaDoPlayer = Vector3.Distance(Player.transform.position, transform.position);
        DistanciaDoAIPoint = Vector3.Distance(DestinosAleatorios[AIPointAtual].transform.position, transform.position);
        //============================== RAYCAST ===================================//
        RaycastHit hit;
        Vector3 deOnde = transform.position;
        Vector3 paraOnde = Player.transform.position;
        Vector3 direction = paraOnde - deOnde;
        if (Physics.Raycast(transform.position, direction, out hit, 1000) && DistanciaDoPlayer < DistanciaDePercepcao)
        {
            if (hit.collider.gameObject.CompareTag("Player"))
            {
                VendoOPlayer = true;
            }
            else
            {
                VendoOPlayer = false;
            }
        }
        //================ CHECHAGENS E DECISOES DO INIMIGO ================//
        if (DistanciaDoPlayer > DistanciaDePercepcao && cronometroOlhar < 5)
        {
            PerseguindoAlgo = false;
            BPassear = true;
            Passear();
        }
        if (DistanciaDoPlayer <= DistanciaDePercepcao && DistanciaDoPlayer > DistanciaDeSeguir && cronometroOlhar < 5)
        {
            if (VendoOPlayer == true)
            {
                BOlhar = true;
                Olhar();
            }
            else
            {
                BPassear = true;

                Passear();
            }
        }
        if (DistanciaDoPlayer <= DistanciaDeSeguir && DistanciaDoPlayer > DistanciaDeAtacar)
        {
            if (VendoOPlayer == true)
            {
                BPerseguir = true;
                Perseguir();
                PerseguindoAlgo = true;
            }
            else
            {
                BPassear = true;

                Passear();
            }
        }
        if (DistanciaDoPlayer <= DistanciaDeAtacar)
        {
            BAtacar = true;
            Atacar();
        }
        //COMANDOS DE PASSEAR
        if (DistanciaDoAIPoint <= 2)
        {
            AIPointAtual = Random.Range(0, DestinosAleatorios.Length);
            BPassear = true;

            Passear();
        }
        //CONTADORES DE OLHAR
        if (contadorOlhar == true)
        {
            cronometroOlhar += Time.deltaTime;
        }
        if (cronometroOlhar >= 5)
        {
            Perseguir();

        }
        if (cronometroOlhar >=
        {
            contadorOlhar = false;
            cronometroOlhar = 0;
            Perseguir();

        }
        //CONTADORES DE PERSEGUICAO
        if (contadorPerseguindoAlgo == true)
        {
            cronometroDaPerseguicao += Time.deltaTime;
        }
        if (cronometroDaPerseguicao >= 5 && VendoOPlayer == false)
        {
            contadorPerseguindoAlgo = false;
            cronometroDaPerseguicao = 0;
            PerseguindoAlgo = false;
        }
        // Freio do ATAQUE

        if (DistanciaDoPlayer <= DistanciaDeAtacar - 1)
        {
            naveMesh.destination = gameObject.transform.position;
        }

        // CONTADOR DE ATAQUE
        if (atacandoAlgo == true)
        {
            transform.LookAt(new Vector3(Player.transform.position.x, transform.position.y, Player.transform.position.z));

            cronometroAtaque += Time.deltaTime;
        }
        if (cronometroAtaque >= TempoPorAtaque && DistanciaDoPlayer <= DistanciaDeAtacar)
        {
            atacandoAlgo = true;
            cronometroAtaque = 0;



            http://PLAYER.VIDA = PLAYER.VIDA - DanoDoInimigo;
            Debug.Log("recebeuAtaque");
        }
        else if (cronometroAtaque >= TempoPorAtaque && DistanciaDoPlayer > DistanciaDeAtacar)
        {
            atacandoAlgo = false;
            cronometroAtaque = 0;
            Debug.Log("errou");
        }
    }
    void Passear()
    {

        BOlhar = false;
        BPerseguir = false;
        BAtacar = false;

        if (PerseguindoAlgo == false)
        {
            naveMesh.acceleration = 5;
            naveMesh.speed = VelocidadeDePasseio;
            naveMesh.destination = DestinosAleatorios[AIPointAtual].position;
        }
        else if (PerseguindoAlgo == true)
        {
            contadorPerseguindoAlgo = true;
        }
    }
    void Olhar()
    {
        contadorOlhar = true;

        BPassear = false;

        BPerseguir = false;
        BAtacar = false;

        naveMesh.speed = 0;
        transform.LookAt(Player);
    }
    void Perseguir()
    {
        BPassear = false;
        BOlhar = false;

        BAtacar = false;

        naveMesh.acceleration = 8;
        naveMesh.speed = VelocidadeDePerseguicao;
        naveMesh.destination = Player.position;
    }
    void Atacar()
    {
        BPassear = false;
        BOlhar = false;
        BPerseguir = false;


        atacandoAlgo = true;
    }
}



------------------------
SCRIPT SIMPLES (ANTIGO) EU NÃO QUERO ESSE!
------------------------

Código:

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

[RequireComponent(typeof(NavMeshAgent))]
public class AISimples : MonoBehaviour{

    public FOVInimigos _cabeca;
    NavMeshAgent _navMesh;
    Transform alvo;
    Vector3 posicInicialDaAI;
    Vector3 ultimaPosicConhecida;
    float timerProcura;

    enum estadoDaAI {
        parado, seguindo, procurandoAlvoPerdido
    };
    estadoDaAI _estadoAI = estadoDaAI.parado;

    void Start(){
        _navMesh = GetComponent<NavMeshAgent>();
        alvo = null;
        ultimaPosicConhecida = Vector3.zero;
        _estadoAI = estadoDaAI.parado;
        posicInicialDaAI = transform.position;
        timerProcura = 0;
    }

    void Update(){
        if (_cabeca) {
            switch (_estadoAI) {
                case estadoDaAI.parado:
                    _navMesh.SetDestination(posicInicialDaAI);
                    if (_cabeca.inimigosVisiveis.Count > 0) {
                        alvo = _cabeca.inimigosVisiveis[0];
                        ultimaPosicConhecida = alvo.position;
                        _estadoAI = estadoDaAI.seguindo;
                    }
                    break;
                case estadoDaAI.seguindo:
                    _navMesh.SetDestination(alvo.position);
                    if (!_cabeca.inimigosVisiveis.Contains(alvo)) {
                        ultimaPosicConhecida = alvo.position;
                        _estadoAI = estadoDaAI.procurandoAlvoPerdido;
                    }
                    break;
                case estadoDaAI.procurandoAlvoPerdido:
                    _navMesh.SetDestination(ultimaPosicConhecida);
                    timerProcura += Time.deltaTime;
                    if (timerProcura > 5) {
                        timerProcura = 0;
                        _estadoAI = estadoDaAI.parado;
                        break;
                    }
                    if (_cabeca.inimigosVisiveis.Count > 0) {
                        alvo = _cabeca.inimigosVisiveis[0];
                        ultimaPosicConhecida = alvo.position;
                        _estadoAI = estadoDaAI.seguindo;
                    }
                    break;
            }
        }
    }
}

Código:

using UnityEngine;
using System.Collections;


public class INTELIGENCIA2 : MonoBehaviour
{
    public Transform Player;
    private UnityEngine.AI.NavMeshAgent naveMesh;
    public float DistanciaDoPlayer, DistanciaDoAIPoint;
    public float DistanciaDePercepcao = 30, DistanciaDeSeguir = 20, DistanciaDeAtacar = 2, VelocidadeDePasseio = 3, VelocidadeDePerseguicao = 6, TempoPorAtaque = 1.5f, DanoDoInimigo = 40;
    private bool VendoOPlayer;
    public Transform[] DestinosAleatorios;
    private int AIPointAtual;
    private bool PerseguindoAlgo, contadorPerseguindoAlgo, atacandoAlgo, contadorOlhar;
    private float cronometroDaPerseguicao, cronometroAtaque, cronometroOlhar;
    public bool BPassear, BOlhar, BPerseguir, BAtacar;

    [Header("Geral")]
    public Transform cabecaInimigo;
    public enum TipoDeColisao {
        RayCast, OverlapSphere
    };
    public TipoDeColisao _tipoDeColisao = TipoDeColisao.RayCast;
    public enum TipoDeChecagem {
        _10PorSegundo, _20PorSegundo, OTempoTodo
    };
    public TipoDeChecagem _tipoDeChecagem = TipoDeChecagem.OTempoTodo;
    [Range(1, 50)]
    public float distanciaDeVisao = 10;

    [Header("OverlapSphere")]
    public LayerMask layersDosInimigos = 2;
    public bool desenharEsfera = true;

    [Header("Raycast")]
    public string tagDosInimigos = "Respawn";
    [Range(2, 180)]
    public float raiosExtraPorCamada = 20;
    [Range(5, 180)]
    public float anguloDeVisao = 120;
    [Range(1, 10)]
    public int numeroDeCamadas = 3;
    [Range(0.02f, 0.15f)]
    public float distanciaEntreCamadas = 0.1f;
    //
    [Space(10)]
    public List<Transform> inimigosVisiveis = new List<Transform>();
    List<Transform> listaTemporariaDeColisoes = new List<Transform>();
    LayerMask layerObstaculos;
    float timerChecagem = 0;

    private void Start()
    {
        AIPointAtual = Random.Range(0, DestinosAleatorios.Length);
        naveMesh = transform.GetComponent<UnityEngine.AI.NavMeshAgent>();

        timerChecagem = 0;
        if (!cabecaInimigo) {
            cabecaInimigo = transform;
        }
        // o operador ~ inverte o estado dos bits (0 passa a ser 1, e vice versa)
        layerObstaculos = ~layersDosInimigos;
    }
    void Update()
    {
        DistanciaDoPlayer = Vector3.Distance(Player.transform.position, transform.position);
        DistanciaDoAIPoint = Vector3.Distance(DestinosAleatorios[AIPointAtual].transform.position, transform.position);
        //============================== RAYCAST ===================================//
        RaycastHit hit;
        Vector3 deOnde = transform.position;
        Vector3 paraOnde = Player.transform.position;
        Vector3 direction = paraOnde - deOnde;
        if (Physics.Raycast(transform.position, direction, out hit, 1000) && DistanciaDoPlayer < DistanciaDePercepcao)
        {
            if (hit.collider.gameObject.CompareTag("Player"))
            {
                VendoOPlayer = true;
            }
            else
            {
                VendoOPlayer = false;
            }
        }
        //================ CHECHAGENS E DECISOES DO INIMIGO ================//
        if (DistanciaDoPlayer > DistanciaDePercepcao && cronometroOlhar < 5)
        {
            PerseguindoAlgo = false;
            BPassear = true;
            Passear();
        }
        if (DistanciaDoPlayer <= DistanciaDePercepcao && DistanciaDoPlayer > DistanciaDeSeguir && cronometroOlhar < 5)
        {
            if (VendoOPlayer == true)
            {
                BOlhar = true;
                Olhar();
            }
            else
            {
                BPassear = true;

                Passear();
            }
        }
        if (DistanciaDoPlayer <= DistanciaDeSeguir && DistanciaDoPlayer > DistanciaDeAtacar)
        {
            if (VendoOPlayer == true)
            {
                BPerseguir = true;
                Perseguir();
                PerseguindoAlgo = true;
            }
            else
            {
                BPassear = true;

                Passear();
            }
        }
        if (DistanciaDoPlayer <= DistanciaDeAtacar)
        {
            BAtacar = true;
            Atacar();
        }
        //COMANDOS DE PASSEAR
        if (DistanciaDoAIPoint <= 2)
        {
            AIPointAtual = Random.Range(0, DestinosAleatorios.Length);
            BPassear = true;

            Passear();
        }
        //CONTADORES DE OLHAR
        if (contadorOlhar == true)
        {
            cronometroOlhar += Time.deltaTime;
        }
        if (cronometroOlhar >= 5)
        {
            Perseguir();

        }
        if (cronometroOlhar >= Cool
        {
            contadorOlhar = false;
            cronometroOlhar = 0;
            Perseguir();

        }
        //CONTADORES DE PERSEGUICAO
        if (contadorPerseguindoAlgo == true)
        {
            cronometroDaPerseguicao += Time.deltaTime;
        }
        if (cronometroDaPerseguicao >= 5 && VendoOPlayer == false)
        {
            contadorPerseguindoAlgo = false;
            cronometroDaPerseguicao = 0;
            PerseguindoAlgo = false;
        }
        // Freio do ATAQUE

        if (DistanciaDoPlayer <= DistanciaDeAtacar - 1)
        {
            naveMesh.destination = gameObject.transform.position;
        }

        // CONTADOR DE ATAQUE
        if (atacandoAlgo == true)
        {
            transform.LookAt(new Vector3(Player.transform.position.x, transform.position.y, Player.transform.position.z));

            cronometroAtaque += Time.deltaTime;
        }
        if (cronometroAtaque >= TempoPorAtaque && DistanciaDoPlayer <= DistanciaDeAtacar)
        {
            atacandoAlgo = true;
            cronometroAtaque = 0;



            http://PLAYER.VIDA = PLAYER.VIDA - DanoDoInimigo;
            Debug.Log("recebeuAtaque");
        }
        else if (cronometroAtaque >= TempoPorAtaque && DistanciaDoPlayer > DistanciaDeAtacar)
        {
            atacandoAlgo = false;
            cronometroAtaque = 0;
            Debug.Log("errou");
        }

        if (_tipoDeChecagem == TipoDeChecagem._10PorSegundo) {
            timerChecagem += Time.deltaTime;
            if (timerChecagem >= 0.1f) {
                timerChecagem = 0;
                ChecarInimigos();
            }
        }
        if (_tipoDeChecagem == TipoDeChecagem._20PorSegundo) {
            timerChecagem += Time.deltaTime;
            if (timerChecagem >= 0.05f) {
                timerChecagem = 0;
                ChecarInimigos();
            }
        }
        if (_tipoDeChecagem == TipoDeChecagem.OTempoTodo) {
            ChecarInimigos();
        }
    }
    void Passear()
    {

        BOlhar = false;
        BPerseguir = false;
        BAtacar = false;

        if (PerseguindoAlgo == false)
        {
            naveMesh.acceleration = 5;
            naveMesh.speed = VelocidadeDePasseio;
            naveMesh.destination = DestinosAleatorios[AIPointAtual].position;
        }
        else if (PerseguindoAlgo == true)
        {
            contadorPerseguindoAlgo = true;
        }
    }
    void Olhar()
    {
        contadorOlhar = true;

        BPassear = false;

        BPerseguir = false;
        BAtacar = false;

        naveMesh.speed = 0;
        transform.LookAt(Player);
    }
    void Perseguir()
    {
        BPassear = false;
        BOlhar = false;

        BAtacar = false;

        naveMesh.acceleration = 8;
        naveMesh.speed = VelocidadeDePerseguicao;
        naveMesh.destination = Player.position;
    }
    void Atacar()
    {
        BPassear = false;
        BOlhar = false;
        BPerseguir = false;


        atacandoAlgo = true;
    }

    private void ChecarInimigos() {
        if (_tipoDeColisao == TipoDeColisao.RayCast) {
            float limiteCamadas = numeroDeCamadas * 0.5f;
            for (int x = 0; x <= raiosExtraPorCamada; x++) {
                for (float y = -limiteCamadas + 0.5f; y <= limiteCamadas; y++) {
                    float angleToRay = x * (anguloDeVisao / raiosExtraPorCamada) + ((180.0f - anguloDeVisao) * 0.5f);
                    Vector3 directionMultipl = (-cabecaInimigo.right) + (cabecaInimigo.up * y * distanciaEntreCamadas);
                    Vector3 rayDirection = Quaternion.AngleAxis(angleToRay, cabecaInimigo.up) * directionMultipl;
                    //
                    RaycastHit hitRaycast;
                    if (Physics.Raycast(cabecaInimigo.position, rayDirection, out hitRaycast, distanciaDeVisao)) {
                        if (!hitRaycast.transform.IsChildOf(transform.root) && !hitRaycast.collider.isTrigger) {
                            if (hitRaycast.collider.gameObject.CompareTag(tagDosInimigos)) {
                                Debug.DrawLine(cabecaInimigo.position, hitRaycast.point, Color.red);
                                //
                                if (!listaTemporariaDeColisoes.Contains(hitRaycast.transform)) {
                                    listaTemporariaDeColisoes.Add(hitRaycast.transform);
                                }
                                if (!inimigosVisiveis.Contains(hitRaycast.transform)) {
                                    inimigosVisiveis.Add(hitRaycast.transform);
                                }
                            }
                        }
                    } else {
                        Debug.DrawRay(cabecaInimigo.position, rayDirection * distanciaDeVisao, Color.green);
                    }
                }
            }
        }
        if (_tipoDeColisao == TipoDeColisao.OverlapSphere) {
            Collider[] alvosNoRaioDeAlcance = Physics.OverlapSphere(cabecaInimigo.position, distanciaDeVisao, layersDosInimigos);
            foreach (Collider targetCollider in alvosNoRaioDeAlcance) {
                Transform alvo = targetCollider.transform;
                Vector3 direcaoDoAlvo = (alvo.position - cabecaInimigo.position).normalized;
                if (Vector3.Angle(cabecaInimigo.forward, direcaoDoAlvo) < (anguloDeVisao / 2.0f)) {
                    float distanciaDoAlvo = Vector3.Distance(transform.position, alvo.position);
                    if (!Physics.Raycast(cabecaInimigo.position, direcaoDoAlvo, distanciaDoAlvo, layerObstaculos)) {
                        if (!alvo.transform.IsChildOf(cabecaInimigo.root)) {
                            if (!listaTemporariaDeColisoes.Contains(alvo)) {
                                listaTemporariaDeColisoes.Add(alvo);
                            }
                            if (!inimigosVisiveis.Contains(alvo)) {
                                inimigosVisiveis.Add(alvo);
                            }
                        }
                    }
                }
            }
            for (int x = 0; x < inimigosVisiveis.Count; x++) {
                Debug.DrawLine(cabecaInimigo.position, inimigosVisiveis[x].position, Color.blue);
            }
        }
        //remove da lista inimigos que não estão visiveis
        for (int x = 0; x < inimigosVisiveis.Count; x++) {
            if (!listaTemporariaDeColisoes.Contains(inimigosVisiveis[x])) {
                inimigosVisiveis.Remove(inimigosVisiveis[x]);
            }
        }
        listaTemporariaDeColisoes.Clear();
    }

    #if UNITY_EDITOR
    private void OnDrawGizmosSelected() {
        if (_tipoDeColisao == TipoDeColisao.OverlapSphere) {
            if (desenharEsfera) {
                Gizmos.color = Color.white;
                Gizmos.DrawWireSphere(cabecaInimigo.position, distanciaDeVisao);
            }
            Gizmos.color = Color.green;
            float angleToRay1 = (180.0f - anguloDeVisao) * 0.5f;
            float angleToRay2 = anguloDeVisao + (180.0f - anguloDeVisao) * 0.5f;
            Vector3 rayDirection1 = Quaternion.AngleAxis(angleToRay1, cabecaInimigo.up) * (-transform.right);
            Vector3 rayDirection2 = Quaternion.AngleAxis(angleToRay2, cabecaInimigo.up) * (-transform.right);
            Gizmos.DrawRay(cabecaInimigo.position, rayDirection1 * distanciaDeVisao);
            Gizmos.DrawRay(cabecaInimigo.position, rayDirection2 * distanciaDeVisao);
            //
            UnityEditor.Handles.color = Color.green;
            float angle = Vector3.Angle(transform.forward, rayDirection1);
            Vector3 pos = cabecaInimigo.position + (cabecaInimigo.forward * distanciaDeVisao * Mathf.Cos(angle * Mathf.Deg2Rad));
            UnityEditor.Handles.DrawWireDisc(pos, cabecaInimigo.transform.forward, distanciaDeVisao * Mathf.Sin(angle * Mathf.Deg2Rad));
        }
    }
    #endif
}

Tenta isso