[TUTORIAL] Campo de visão dos inimigos (Enemy FOV) com Raycast ou OverlapSphere

Olá pessoal, elaborei um sisteminha legalzinho para que inimigos possam ter um "Campo de visão" ajustável, com distância e tudo mais.

Vídeo tutorial: 



ATENÇÃO!!! Para fazer a colisão do navMesh agent com o alvo que ele está seguindo, em vez de adicionar Rigidbody e um colisor, basta adicionar um "NavMeshObstacle".

Script FOVInimigos:

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 AISimples

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;
            }
        }
    }
}



^^ Valeu, vai ajudar muito <3

Muito bom!!

Marcos e o seguinte. este script  no meu caso esta dando erro quando vou compilar o jogo.
no unity ele esta funcionando certo, o inimigo esta seguindo, se não detecta o player ele volta para o estado inicial, o problema esta na hora do build.
estou usando Unity  2017.4.8f1.
link da imagem dos erros: https://mega.nz/#!VkwADKSS!79I8GUvUKk8OG4eYdET4hB0uQmA37zmAYCW5ETFVp4c

lauderson escreveu:Marcos e o seguinte. este script  no meu caso esta dando erro quando vou compilar o jogo.
no unity ele esta funcionando certo, o inimigo esta seguindo, se não detecta o player ele volta para o estado inicial, o problema esta na hora do build.
estou usando Unity  2017.4.8f1.
link da imagem dos erros: https://mega.nz/#!VkwADKSS!79I8GUvUKk8OG4eYdET4hB0uQmA37zmAYCW5ETFVp4c

Atualizei o código 'FOVInimigos'...  Tente agora

Agora sim esta compilando o jogo

Mano com ponho waypoint nessa ai ?

Nekas escreveu:Mano com ponho waypoint nessa ai ?

Pra quem tem dúvida de como colocar WayPoints nesse código de IA onde o inimigo se movimenta, fiz algumas alterações nele.

Basta ir no Inspection do Script e colocar a quantidade de WayPoints e jogar lá dentro desse vetor

Código:

[size=16][i]// Código de Marcos Schultz, modificado por Vitin Ruas - Unity 2020 LTS - Windows 10 v1909[/i]
[i]// 25/07/2021[/i]

[i]// Modificações: Adicionando WayPoints para o NavMesh e alterando o que já tem existente para o funcionando do script.[/i]
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;

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

    [i]// WayPoints[/i]
    public Transform[] wayPoints;
    private int currentWayPoint;
    public float distanceWayPoint;
    [i]//[/i]
    public FOVInimigos _cabeca;
    NavMeshAgent _navMesh;
    Transform alvo;
    Vector3 posicInicialDaAI;
    Vector3 ultimaPosicConhecida;
    float timerProcura;

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

    void Start(){
        [i]// WayPoint sorteado logo de início[/i]
        RandomWayPoints();
        _navMesh = GetComponent<NavMeshAgent>();
        alvo = null;
        ultimaPosicConhecida = Vector3.zero;
        _estadoAI = estadoDaAI.andando;
        posicInicialDaAI = transform.position;
        timerProcura = 0;
    }

    void Update(){
        distanceWayPoint = Vector3.Distance(wayPoints[currentWayPoint].transform.position, transform.position);
        if (_cabeca) {
            switch (_estadoAI) {
                [i]// ALTERADO!!!!!!![/i]
                [i]// Invés do personagem voltar para a sua posição atual, passará por waypoints[/i]
                case estadoDaAI.andando:
                    [i]// Quando esse estado é chamado, o destino do navmesh (_navmesh.destination) é o atual waypoint sorteado pela void RandomWayPoints[/i]
                    _navMesh.destination = wayPoints[currentWayPoint].transform.position;
                    [i]// Se o inimigo chegar a uma distância de "2 metros", será sorteado um novo WayPoint[/i]
                    if (distanceWayPoint < 2)
                    {
                        RandomWayPoints();
                        _estadoAI = estadoDaAI.andando;
                    }
                    [i]// Cause a cabeca veja o Player, ele sai do estado andando para o estado de perseguicao[/i]
                    if (_cabeca.inimigosVisiveis.Count > 0) {
                        alvo = _cabeca.inimigosVisiveis[0];
                        ultimaPosicConhecida = alvo.position;
                        _estadoAI = estadoDaAI.seguindo;
                    }
                    break;
                    [i]// Seguindo o Player[/i]
                case estadoDaAI.seguindo:
                    _navMesh.SetDestination(alvo.position);
                    if (!_cabeca.inimigosVisiveis.Contains(alvo)) {
                        ultimaPosicConhecida = alvo.position;
                        _estadoAI = estadoDaAI.procurandoAlvoPerdido;
                    }
                    break;
                    [i]// Procurando por alguns segundos o alvo, após perdê-lo[/i]
                case estadoDaAI.procurandoAlvoPerdido:
                    _navMesh.SetDestination(ultimaPosicConhecida);
                    timerProcura += Time.deltaTime;
                    if (timerProcura > 5) {
                        timerProcura = 0;
                        _estadoAI = estadoDaAI.andando;
                        break;
                    }
                    if (_cabeca.inimigosVisiveis.Count > 0) {
                        alvo = _cabeca.inimigosVisiveis[0];
                        ultimaPosicConhecida = alvo.position;
                        _estadoAI = estadoDaAI.seguindo;
                    }
                    break;
            }
        }
    }

    [i]// Sortear um novo WayPoint para o inimigo seguir[/i]
    void RandomWayPoints()
    {
        currentWayPoint = Random.Range(0, wayPoints.Length);
    }
}
[/size]

Tem como fazer a visão atravessar só algumas paredes específicas?

Mozinhas2 escreveu:Tem como fazer a visão atravessar só algumas paredes específicas?

Sim basta usar LayerMask nos raycasts.

Ai por exemplo, eu tenho a Layer dos inimigos e uma de obstaculos. eu selecionando essas 2 em um LayerMask e adicionando isso no Raycast, o Raycast, só vai detectar objetos que estejam nessas duas layers, ai uma parede fora delas, seria ignorada.

Mas(ninguém perguntou),  considero essa Implementação de uma detecção de inimigos com ângulo meio exagerada.


Essa aqui é bem mais simples... apesar de essa aqui não conter também a parte de AI, é só a detecção mesmo.

Essa aqui é de um livro, o motivo de ser apenas a detecção é interessante, sendo apenas a parte de detecção caso o seu modelo seja rigado e animado , tu pode colocar o script no bone do olho, assim a detecção fica mais fiel, além dela poder ser usado em varias AIs diferentes. 

Livro: Hands-On Unity 2021 Game Development