enemyAllScript.cs

using UnityEngine;
using UnityEngine.AI;


public class enemyAllScript : MonoBehaviour
{

    // The enemy is an agent
    [SerializeField] private NavMeshAgent agent;
    [SerializeField] private Transform player;
    [SerializeField] private LayerMask whatIsPlayer;

    // For patrolling
    [SerializeField] private float speed = 5f;
    private Vector3 lastPosition;
    private float currentSpeed;
    private Vector3 randomDirection;
    [SerializeField] private float moveDuration = 2f;
    private float patrolTimer = 0f;
    private Vector3 patrolDirection;

    // Checking for sight
    private Vector3 directionToPlayer;
    private bool isInSight = false;

    // For attacking
    [SerializeField] private float timeBetweenAttacks;
    private bool alreadyAttacked;

    // States
    [SerializeField] private float sightRange, attackRange;
    private bool playerInSightRange, playerInAttackRange;

    public float health = 50f;
    private float initialHealth;
    [SerializeField] private GameObject enemy;


    [Header("Attack Settings")]
    public float attackDamage = 20f;

    [Header("Ranged attack settings")]
    [SerializeField] private GameObject projectilePrefab;
    [SerializeField] private Transform attackPoint;
    [SerializeField] private float projectileSpeed = 1f;

    // difficulty adjustments
    public float damageMultiplier = 1f;
    private float healthMultiplier = 1f;


    private void Start()
    {
        agent = GetComponent<NavMeshAgent>();
        player = GameObject.Find("Player").transform;
        string difficulty = PlayerPrefs.GetString("GameDifficulty", "NORMAL");
        ApplyDifficultySettings(difficulty);
        lastPosition = Vector3.zero;
        initialHealth = health;

        SetDirection();
    }

    private void ApplyDifficultySettings(string difficulty)
    {
        switch (difficulty)
        {
            case "EASY":
                healthMultiplier = 0.75f;
                damageMultiplier = 0.75f;
                
                break;
            
            case "NORMAL":
                healthMultiplier = 1f;
                damageMultiplier = 1f;

                break;
            case "HARD":
                healthMultiplier = 1.5f;
                damageMultiplier = 1.5f;

                break;
            default:
                break;
        }
        
        health *= healthMultiplier;
        initialHealth *= health;
    }

    private void Update()
    {
        playerInSightRange = Physics.CheckSphere(transform.position, sightRange, whatIsPlayer);
        playerInAttackRange = Physics.CheckSphere(transform.position, attackRange, whatIsPlayer);
        
        currentSpeed = Vector3.Distance(transform.position, lastPosition) / Time.deltaTime;
        lastPosition = transform.position;
        isInSight = PlayerInSight();

        if ((!playerInSightRange && !playerInAttackRange) || !isInSight) Patrolling();
        if (playerInSightRange && !playerInAttackRange && isInSight) ChasePlayer();
        if (playerInSightRange && playerInAttackRange && isInSight) AttackPlayer();
    }


    private void Patrolling()
    {
        patrolTimer += Time.deltaTime;

        transform.position += patrolDirection * speed * Time.deltaTime;

        if (patrolTimer >= moveDuration)
        {
            SetDirection();
            patrolTimer = 0f;
        }

        if (currentSpeed < 0.5)
        {
            SetDirection();
        }

    }

    private bool PlayerInSight()
    {
        directionToPlayer = (player.position - transform.position).normalized;
        if (Physics.Raycast(transform.position, directionToPlayer, out RaycastHit hit, sightRange))
        {
            if (hit.transform == player)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
    private void SetDirection()
    {
        float randomX = Random.Range(-1f, 1f);
        float randomZ = Random.Range(-1f, 1f);
        patrolDirection = new Vector3(randomX, 0, randomZ).normalized;

        transform.LookAt(transform.position + patrolDirection);
    }


    private void ChasePlayer()
    {
        agent.SetDestination(player.position);
    }

    private void AttackPlayer()
    {
        agent.SetDestination(transform.position);
        transform.LookAt(player);

        if (!alreadyAttacked)
        {
            RangedAttack();
            alreadyAttacked = true;
            Invoke(nameof(ResetAttack), timeBetweenAttacks);
        }
    }

    private void RangedAttack()
    {
        if (projectilePrefab != null && attackPoint != null)
        {
            GameObject projectile = Instantiate(projectilePrefab, attackPoint.position, Quaternion.identity);

            // get the projectile damage component and set its reference to this enemy
            projectileDamage projectileDamageScript = projectile.GetComponent<projectileDamage>();
            if (projectileDamageScript != null)
            {
                projectileDamageScript.enemyScript = this;
                projectileDamageScript.damage = attackDamage; // set base damage
            }


            Rigidbody projectileRb = projectile.GetComponent<Rigidbody>();

            if (projectileRb != null)
            {
                // calculate direction to player
                Vector3 directionToPlayer = (player.position - attackPoint.position).normalized;

                // add force
                projectileRb.AddForce(directionToPlayer * projectileSpeed, ForceMode.Impulse);

            }
        }
    }

    private void ResetAttack()
    {
        alreadyAttacked = false;
    }

    public void TakeDamage(float damage)
    {
        health -= damage;
        if (health <= 0f)
        {
            Die();
        }
    }

    private void Die()
    {
        enemy.SetActive(false);
    }

    public void RespawnEnemy()
    {
        health = initialHealth; // reset the enemy's health
    }
}