pastemyst

StateMachine pasty

(at edit #0)

present

StateMachine.cs

C#copy raw

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

public class StateMachine : MonoBehaviour
{
    private StateMachine stateMachine;
    public Grunt_bite.BaseState biteActiveState;
    public Grunt_gun.BaseState gunActiveState;
    internal object activeState;
    [SerializeField] private Path path;
    private Enemy_1 enemy;

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));
                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 to; " + newState.GetType().Name);
        // Check if there is a currently active state
        Grunt_gun.PatrolState patrolState = null;

if (gunActiveState != null)
        {
            gunActiveState.Exit();// Call the Exit method of the currently active state
        }

gunActiveState = newState;// Set the new state as the active state

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)
            {
                // Create a new instance of PatrolState with the same path and enemy
                patrolState = gunActiveState as Grunt_gun.PatrolState;
                gunActiveState = new Grunt_gun.PatrolState(patrolState.path, GetComponent<Enemy_1>());
            }
            // 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
            {
                patrolState = gunActiveState as Grunt_gun.PatrolState;
                gunActiveState = new Grunt_gun.PatrolState(patrolState.path, GetComponent<Enemy_1>());   
                gunActiveState.Enter(); // Enter AttackState                
            }

//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>()));
            //}
        }

}
}

public enum EnemyType 
{
    Grunt_bite,
    Grunt_gun,

}

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)
        {
            this.path = path;
        }

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.");
                    stateMachine.ChangeGunState(new AttackState(enemy));// Change the current state to AttackState, passing the enemy object
                    Debug.Log("Player is currently detected");                   
                }      
                else
                {
                   Debug.Log("player no longer detected");
                }
            }
        }

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

}
}

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;
        private GameObject player;
        [SerializeField]
        private NavMeshAgent agent;
        [SerializeField]
        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
                {

}
                agent = GetComponent<NavMeshAgent>();
                stateMachine.Initialize(path, EnemyType.Grunt_gun);
                
            }
            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;
        }

}
}

AttackState.cs

C#copy raw

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

public class AttackState : BaseState
    {
        private readonly Enemy_1 enemy;
        private float moveTimer;
        private float losePlayerTimer = 0;
        private float shotTimer;
        [SerializeField] private Path path;
        public AttackState(Enemy_1 enemy)
        {
           this.enemy = enemy;
        }
        
        public override void Enter()
        {
            Debug.Log("Entering AttackState");
        }
        public override void Exit()
        {

}
        public override void Perform()
        {
            Debug.Log("AttackState Perform() method executed");
            
            
                if (enemy.CanSeePlayer())
                {
                    Debug.Log("Player detected in AttackState");
                    losePlayerTimer = 0;
                    moveTimer += Time.deltaTime;
                    shotTimer += Time.deltaTime;
                    enemy.transform.LookAt(enemy.Player.transform);

if (shotTimer > enemy.fireRate)
                    {
                        Shoot();
                    }
                    if (moveTimer > Random.Range(3, 7))
                    {
                        enemy.Agent.SetDestination(enemy.transform.position + (Random.insideUnitSphere * 5));
                        moveTimer = 0;
                    }
                }
                else
                {
                    Debug.Log("Player not detected in AttackState");
                    Debug.Log("Player lost in AttackState. Transitioning back to PatrolState");
                    losePlayerTimer += Time.deltaTime;
                    if (losePlayerTimer > 8)
                    {                        
                            enemy.TransitionToPatrolState();                                              
                    }
                }
            
        }

public void Shoot()
        {
            Transform Fuzil = enemy.Fuzil;
            GameObject bullet = GameObject.Instantiate(Resources.Load("Prefabs/bullet") as GameObject, Fuzil.position, enemy.transform.rotation);
            Vector3 shootDirection = (enemy.Player.transform.position - Fuzil.transform.position).normalized;
            bullet.GetComponent<Rigidbody>().velocity = Quaternion.AngleAxis(Random.Range(-3f, 3f), Vector3.up) * shootDirection * 40;
            Debug.Log("Shoot");
            shotTimer = 0;
        }

internal bool CanSeePlayer()
        {
            throw new System.NotImplementedException();
        }

void Start()
        {

}

void Update()
        {

}
    }
}

created at:

stats: 539 lines, 1355 words, 17.69kb