pastemyst | askHelpUnityserver

askHelpUnityserver

StateMachine.cs

C#copy raw

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Grunt_gun;
using Grunt_bite;
using System;
using UnityEngine.UIElements;

public class StateMachine : MonoBehaviour
{
    [SerializeField] private StateMachine stateMachine;
    [SerializeField] private Grunt_bite.BaseState biteActiveState;
    [SerializeField] private Grunt_gun.BaseState gunActiveState;
    internal object activeState;
    [SerializeField] private Path path;
    private Enemy_1 enemy;
    private string currentState;
    public void Initialize(Path path, EnemyType enemyType)
    {
        switch (enemyType)
        {

case EnemyType.Grunt_bite:
                ChangeBiteState(new Grunt_bite.PatrolState(path));
                break;
            case EnemyType.Grunt_gun:
                ChangeGunState(new Grunt_gun.PatrolState(path, this));
                break;
            default:
                Debug.LogError("Unsupported enemy type");
                break;
        }
    }
    
    // Start is called before the first frame update
    void Start()
    {

}
    
    // Update is called once per frame
    void Update()
    {
        Debug.Log("Current active state: " + (gunActiveState != null ? gunActiveState.GetType().Name : "None"));
        // Null checks performing actions on active states
        if (biteActiveState != null)
        {
            biteActiveState.Perform();
        }

if (gunActiveState != null)
        {
            gunActiveState.Perform();
        }
    }

public void ChangeBiteState(Grunt_bite.BaseState newState)
    {
        if (biteActiveState != null)
        {
            biteActiveState.Exit();
        }

biteActiveState = newState;

if (biteActiveState != null)
        {
            biteActiveState.stateMachine = this;

if (biteActiveState is Grunt_bite.PatrolState patrolstate)
            {
                biteActiveState = new Grunt_bite.PatrolState(patrolstate.path, GetComponent<Enemy_2>());
                biteActiveState.Enter();
            }
            else
            {
                Debug.LogError("newState to PatrolState failed");
            }
        }

}
    public void ChangeGunState(Grunt_gun.BaseState newState)
    {
        Debug.Log("Changing gun state. gunActiveState: " + (gunActiveState != null ? gunActiveState.GetType().Name : "null"));
        Debug.Log("New state: " + newState.GetType().Name);
        // Check if there is a currently active state

if (gunActiveState != null)
        {
            gunActiveState.Exit();// Call the Exit method of the currently active state
        }
        else
        {
            Debug.LogWarning("gunActiveState is null in ChangeGunState method");
        }

gunActiveState = newState;// Set the new state as the active state
        currentState = newState.GetType().Name;
        if (gunActiveState != null)// Check if the new state is not null
        {
            // Set the state machine and enemy references for the new state
            gunActiveState.stateMachine = this;
            gunActiveState.enemy = GetComponent<Enemy_1>();

// Check if the new state is a PatrolState
            if (gunActiveState is Grunt_gun.PatrolState)
            {
                Grunt_gun.PatrolState patrolState = gunActiveState as Grunt_gun.PatrolState;
                if (patrolState != null)
                {
                    gunActiveState = new Grunt_gun.PatrolState(patrolState.path, GetComponent<Enemy_1>());
                    gunActiveState.Enter();
                }
                else
                {
                    Debug.LogError("Failed to cast gunActiveState to PatrolState in ChangeGunState method");
                }
            }
            // Check if the new state is an AttackState
            else if (GetComponent<Enemy_1>().CanSeePlayer())
            {
                gunActiveState = new Grunt_gun.AttackState(enemy);
                gunActiveState.Enter();
            }
            else // check if the new state is an AttackState
            {
                Grunt_gun.PatrolState patrolState = gunActiveState as Grunt_gun.PatrolState;
                if (patrolState != null)
                {
                    gunActiveState = new Grunt_gun.PatrolState(patrolState.path, GetComponent<Enemy_1>());
                    gunActiveState.Enter(); // Enter AttackState
                }
                else
                {
                    Debug.LogError("Failed to cast gunActiveState to PatrolState in ChangeGunState method");
                }
            }
            
            { //if (stateMachine != null && stateMachine.gunActiveState != null)
              //{
              //Enemy_1 enemy = GetComponent<Enemy_1>();
              //if (enemy.CanSeePlayer())
              //{
              //Debug.Log("Player detected in " + gunActiveState.GetType().Name + ". Transitioning to AttackState");
              //stateMachine.ChangeGunState(new Grunt_gun.AttackState(GetComponent<Enemy_1>()));
              //}
              //}

//if (gunActiveState.GetType() == typeof(Grunt_gun.AttackState))
                //{
                //Grunt_gun.AttackState attackState = (Grunt_gun.AttackState)gunActiveState;
                //if (attackState.CanSeePlayer())
                //{
                //Debug.Log("Player detected in " + gunActiveState.GetType().Name + ". Transitioning to AttackState");
                //stateMachine.ChangeGunState(new Grunt_gun.AttackState(GetComponent<Enemy_1>()));
                //}
                //}

//if (gunActiveState != null && gunActiveState.CanSeePlayer())
                //{
                //Debug.Log("player detected in" + gunActiveState.GetType().Name +".transitioning to attackState");
                //StateMachine stateMachine = new StateMachine();
                //stateMachine.ChangeGunState(new Grunt_gun.AttackState(GetComponent<Enemy_1>()));
                //}
            }
        }
        else
        {
                Debug.LogError("newState is null in ChangeGunState method");
        }
        
    }
}

public enum EnemyType 
{
    Grunt_bite,
    Grunt_gun,

}

Enemy_1.cs

C#copy raw

namespace Grunt_gun
{
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    using UnityEngine.AI;

public class Enemy_1 : MonoBehaviour
    {
        private StateMachine stateMachine;
        [SerializeField]private GameObject player;
        [SerializeField]private NavMeshAgent agent;
        private string currentState;
        private float losePlayerCooldown = 3f;
        private float losePlayerTimer = 0f;

public GameObject enemy;
        public NavMeshAgent Agent { get { return agent; } }
        public GameObject Player { get { return player; } }
        public Path path;
        public Path Path { get { return path; } }
        [Header("Sight Values")]
        public float sightDistance = 20f;
        public float feildOfView = 180f;
        public float eyeHeight = 0;
        [Header("Weapon Values")]
        public Transform Fuzil;
        [Range(0.1f, 10f)]
        public float fireRate;

// Start is called before the first frame update
        void Start()
        {
            Debug.Log("Enemy_1 Start() method called.");
            player = GameObject.FindGameObjectWithTag("Player");
            enemy = gameObject;
            if (enemy != null && player != null)
            {
                stateMachine = GetComponent<StateMachine>();

if (stateMachine == null)
                {
                    Debug.LogError("StateMachine component is not found in Enemy_1.");
                }
                else
                {
                    Debug.Log("StateMachine component found in Enemy_1.");
                }
                agent = GetComponent<NavMeshAgent>();
                stateMachine.Initialize(path, EnemyType.Grunt_gun);
                
                if (agent == null)
                {
                    Debug.LogError("NavMeshAgent component is not found in Enemy_1.");
                }
            }
            else
            {
                Debug.LogError("Enemy or Player reference is null!");
            }
        }

// Update is called once per frame
        void Update()
        {
            //Debug.Log("stateMachine: " + stateMachine);
            //Debug.Log("player: " + player);
            //Debug.Log("agent: " + agent);

bool playerDetected = CanSeePlayer();
            Debug.Log("CanSeePlayer result:" + CanSeePlayer());
            // Update current state if state machine exists
            if (stateMachine != null)
            {
                //Update current state if state machine exists
                currentState = stateMachine.activeState.ToString();
            }
            else
            {
                //Update current state if state machine exists
                currentState = "None" ;
            }
            // Check if state machine and active state are not null
            if (stateMachine != null && stateMachine.activeState != null)
            {
                
                //Update current state field
                currentState = stateMachine.activeState.GetType().Name;
                // Check if active state is PatrolState
                if (stateMachine.activeState.GetType() == typeof(PatrolState))

{
                    if (enemy != null)
                    {
                        // turns activestate to patrolState, get next waypoint for patrol and set destination for navmeshAgent
                        PatrolState patrolState = (PatrolState)stateMachine.activeState;
                        Vector3 nextWaypoint = patrolState.GetNextWaypoint();
                        agent.SetDestination(nextWaypoint);
                        Debug.Log("Player detected by CanSeePlayer method");
                        if (playerDetected)// Check if player is detected
                        {
                            Debug.Log("Player detected in patrolState. changing to attackstate.");
                            stateMachine.ChangeGunState(new AttackState(this)); //transition to attackstate                           
                        }
                        else
                        {
                            Debug.Log("Player not detected by CanSeePlayer method");
                            losePlayerTimer += Time.deltaTime;// Increment losePlayerTimer
                            if (losePlayerTimer >= losePlayerCooldown)// Check if player is lost and transition to PatrolState
                            {
                                Debug.Log("Player lost, changing to patrolstate.");
                                TransitionToPatrolState();
                                losePlayerTimer = 0f;
                            }
                        }
                    }
                }
                else
                {
                    // Set current state to "None" if active state is not PatrolState
                    currentState = "None";
                }
            }
            else
            {
                Debug.LogWarning("StateMachine or activestate is null in enemy_1 update()");
            }
        }

public void TransitionToPatrolState()
        {
            stateMachine.ChangeGunState(new PatrolState(path, this));
        }

public void TransitionToAttackState()
        {
            stateMachine.ChangeGunState(new AttackState(this));
        }

public bool CanSeePlayer()

{
            if (player != null)
            {
                if (Vector3.Distance(transform.position, player.transform.position) < sightDistance)
                {
                    Vector3 targetDirection = player.transform.position - transform.position - (Vector3.up * eyeHeight);
                    float angleToPlayer = Vector3.Angle(targetDirection, transform.forward);
                     //Check if player is in field of view
                    if (angleToPlayer >= -feildOfView && angleToPlayer <= feildOfView)
                    {
                        Ray ray = new Ray(transform.position + (Vector3.up * eyeHeight), targetDirection);
                        RaycastHit hitInfo = new RaycastHit();
                        if (Physics.Raycast(ray, out hitInfo, sightDistance))
                        {
                            if (hitInfo.transform.gameObject == player)
                            {
                                //Debug.Log("Player detected by CanSeePlayer method.");
                                Debug.DrawRay(ray.origin, ray.direction * sightDistance);
                                return true;
                            }
                        }
                        //Debug.DrawRay(ray.origin, ray.direction * sightDistance, Color.red);
                        //Debug.DrawRay(ray.origin, ray.direction * sightDistance, Color.green);
                    }
                }
            }
            //Debug.Log("Player not detected by CanSeePlayer method.");
            return false;
        }

}
}

PatrolState.cs

C#copy raw

namespace Grunt_gun
{

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

public class PatrolState : BaseState
    {
        private bool playerDetected;
        
        public Enemy_1 enemy;
        public Path path;
        public int waypointIndex;
        public Enemy_1 Gun { get { return enemy; } }

public PatrolState(Path path, Enemy_1 enemy)
        {
            this.path = path;
            this.enemy = enemy;

//Debug.Log("Enemy_1 initialized: " + (enemy1 != null));
        }

public PatrolState(Path path, StateMachine stateMachine)
        {
            this.path = path;
            this.stateMachine = stateMachine;

// Debug log to verify if the stateMachine reference is properly assigned
            if (this.stateMachine == null)
            {
                Debug.LogError("stateMachine reference is null in PatrolState constructor");
            }
        }

public Vector3 GetNextWaypoint()
        {
            if (waypointIndex < path.waypoints.Count)
            {
                Vector3 nextWaypointPosition = path.waypoints[waypointIndex].position;
                return nextWaypointPosition;
            }
            else
            {
                Debug.LogWarning("No waypoints");
                return Vector3.zero;
            }
        }

public override void Enter()

{

}

public override void Perform()

{
            Debug.Log("PatrolState Perform() method executed");
            if (enemy != null)
            {
                PatrolCycle();
                // Check if the player is detected by this enemy
                if (enemy.CanSeePlayer())
                {
                    Debug.Log("Player detected in PatrolState. Transitioning to AttackState.");
                    if (stateMachine != null)
                    {
                        stateMachine.ChangeGunState(new AttackState(enemy));// Change the current state to AttackState, passing the enemy object
                    }
                    else
                    {
                        Debug.LogError("StateMachine is null in PatrolState Perform() method");
                    }
                    Debug.Log("Player is currently detected");
                } 
                
                else
                {
                   Debug.Log("player no longer detected");
                }
            }
            else
            {
                Debug.LogError("Enemy_1 is null in PatrolState Perform() method");
            }
        }

public void UpdatePlayerDetected(bool detected)
        {
            playerDetected = detected;
        }

public override void Exit()

{
            if (Gun.Agent.remainingDistance < 0.2f)
            {
                if (waypointIndex < Gun.path.waypoints.Count - 1)
                    waypointIndex++;
                else
                    waypointIndex = 0;

Gun.Agent.SetDestination(Gun.Path.waypoints[waypointIndex].position);

}
        }

public void PatrolCycle()

{
            if (Gun.Agent.remainingDistance < 0.2f && !Gun.Agent.pathPending)
            {
                waypointIndex++;

if (waypointIndex >= path.waypoints.Count)
                {
                    waypointIndex = 0;
                }

Gun.Agent.SetDestination(path.waypoints[waypointIndex].position);
            }
        }

}
}

created at:

stats: 493 lines, 1304 words, 16.84kb