MoveCharachterScript

Script dat de Kat bestuurd in de minigame

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class MoveCharachterScript : MonoBehaviour
{
 
    [SerializeField]
    private GameObject CodeManager;
    [SerializeField]
    private GameObject Player;
 
    private List<string> objectTags = new List<string>();
 
    [SerializeField]
    private float movementDuration = 0.5f;
    [SerializeField]
    private float movementMultiplier = 1f;
    [SerializeField]
    private float rotationDuration = 0.3f;
    [SerializeField]
    private float jumpHeight = 4f;
 
    [SerializeField]
    private Animator animator;
 
    public bool isMoving = false;
    public bool canPlay = true;
 
    private float lookDirection = 0f;
 
 
    void Start()
    {
        if (CodeManager == null)
        {
            CodeManager = GameObject.FindGameObjectWithTag("PlayableCode");
        }
    }
 
 
    public void PlayGame()
    {
        if (canPlay)
        {
            canPlay = false;
            objectTags.Clear();
            foreach (Transform transform in CodeManager.transform)
            {
                objectTags.Add(transform.tag);
            }
 
 
            StartCoroutine(ExecuteMethodsSequentially(objectTags));
        }
    }
 
    private IEnumerator ExecuteMethodsSequentially(List<string> tagsToExecute)
    {
        for (int i = 0; i < tagsToExecute.Count; i++)
        {
            string tag = tagsToExecute[i];
            GameObject obj = CodeManager.transform.GetChild(i).gameObject;
            ChangeMaterialScript changeMaterialScript = obj.GetComponent<ChangeMaterialScript>();
            if (obj != null && changeMaterialScript != null)
            {
                changeMaterialScript.SetMaterialActive();
            }
 
            Invoke(tag, 0f);
            yield return new WaitForSeconds(1.5f);
 
            if (obj != null && changeMaterialScript != null)
            {
                changeMaterialScript.SetMaterialUnactive();
            }
        }
        canPlay = true;
    }
 
    private void Left()
    {
        if (!isMoving)
        {
            // Rotate the lookDirection 90 degrees to the left
            lookDirection -= 90f;
            StartCoroutine(SmoothMove(Quaternion.Euler(0, lookDirection, 0) * Vector3.forward * movementMultiplier));
        }
    }
 
    private void Right()
    {
        if (!isMoving)
        {
            // Rotate the lookDirection 90 degrees to the right
            lookDirection += 90f;
            StartCoroutine(SmoothMove(Quaternion.Euler(0, lookDirection, 0) * Vector3.forward * movementMultiplier));
        }
    }
 
    private void Backward()
    {
        if (!isMoving)
        {
            // Rotate the lookDirection 180 degrees
            lookDirection = (lookDirection + 180f) % 360f;
            StartCoroutine(SmoothMove(Quaternion.Euler(0, lookDirection, 0) * Vector3.forward * movementMultiplier));
        }
    }
 
    private void Forward()
    {
        if (!isMoving)
        {
            StartCoroutine(SmoothMove(Quaternion.Euler(0, lookDirection, 0) * Vector3.forward * movementMultiplier));
        }
    }
 
    private void Jump()
    {
        if (!isMoving)
        {
            StartCoroutine(JumpAndMove());
        }
    }
 
    private IEnumerator JumpAndMove()
    {
        isMoving = true;
 
        Vector3 startPosition = Player.transform.position;
        Vector3 endPosition = startPosition + (Quaternion.Euler(0, lookDirection, 0) * Vector3.forward * movementMultiplier * 2);
        float elapsedTime = 0f;
 
        animator.SetBool("isWalking", true);
        while (elapsedTime < movementDuration)
        {
            float normalizedTime = elapsedTime / movementDuration;
            Vector3 currentPosition = Vector3.Lerp(startPosition, endPosition, normalizedTime);
            float heightOffset = Mathf.Sin(normalizedTime * Mathf.PI) * jumpHeight;
            currentPosition.y = startPosition.y + heightOffset;
            Player.transform.position = currentPosition;
            elapsedTime += Time.deltaTime;
            yield return null;
        }
 
        Player.transform.position = endPosition;
        isMoving = false;
        animator.SetBool("isWalking", false);
    }
 
    private IEnumerator SmoothMove(Vector3 moveDirection)
    {
        isMoving = true;
 
        // Rotation
        Quaternion startRotation = Player.transform.rotation;
        Quaternion targetRotation = Quaternion.Euler(0, lookDirection, 0);
 
        float rotationElapsedTime = 0f;
 
        while (rotationElapsedTime < rotationDuration)
        {
            Player.transform.rotation = Quaternion.Slerp(startRotation, targetRotation, rotationElapsedTime / rotationDuration);
            rotationElapsedTime += Time.deltaTime;
            yield return null;
        }
 
        Player.transform.rotation = targetRotation;
 
        // Movement
        Vector3 startPosition = Player.transform.position;
        Vector3 endPosition = startPosition + moveDirection;
        float moveElapsedTime = 0f;
 
        animator.SetBool("isWalking", true);
 
        while (moveElapsedTime < movementDuration)
        {
            Player.transform.position = Vector3.Lerp(startPosition, endPosition, moveElapsedTime / movementDuration);
            moveElapsedTime += Time.deltaTime;
            yield return null;
        }
 
        Player.transform.position = endPosition;
 
        isMoving = false;
        animator.SetBool("isWalking", false);
    }
 
    public void ResetPlayer()
    {
        lookDirection = 0f;
    }
}