Upload 18 files

Scripts/Actor.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class Actor : MonoBehaviour
+{
+    public GameObject target;
+    public List<string> actorTypes;
+    public List<Objective> objectiveList; 
+    private Outline outline;
+    public GameObject prefabReference;
+
+    void Start()
+    {
+        target = gameObject;
+        outline = GetComponent<Outline>();
+        ActorManager.Instance.RegisterActor(this);
+    }
+
+    public bool HasType(string type)
+    {
+        return actorTypes.Contains(type);
+    }
+
+    void Update()
+    {
+        if (outline == null || !this) return;
+        outline.enabled = ShouldHighlight();
+    }
+
+
+    private bool ShouldHighlight()
+    {
+        if (ObjectiveManager.Instance == null) return false;
+
+        foreach (var activeObjective in ObjectiveManager.Instance.activeObjectives)
+        {
+            if (objectiveList.Contains(activeObjective.objective))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+}

Scripts/ActorManager.cs

@@ -0,0 +1,80 @@
+using UnityEngine;
+using System.Collections.Generic;
+
+[System.Serializable]
+public class ActorData
+{
+    public GameObject prefab;
+    public Vector3 originalPosition;
+    public Quaternion originalRotation;
+}
+
+
+public class ActorManager : MonoBehaviour
+{
+    public static ActorManager Instance;
+
+    private Dictionary<Actor, ActorData> actorOriginals = new();
+    private List<Actor> activeActors = new();
+
+    void Awake()
+    {
+        if (Instance != null && Instance != this)
+            Destroy(gameObject);
+        else
+            Instance = this;
+    }
+
+    public void RegisterActor(Actor actor)
+    {
+        if (actorOriginals.ContainsKey(actor)) return;
+
+        GameObject clone = Instantiate(actor.gameObject);
+        clone.SetActive(false);
+        clone.transform.SetParent(transform);
+
+        actorOriginals[actor] = new ActorData
+        {
+            prefab = actor.prefabReference,
+            originalPosition = actor.transform.position,
+            originalRotation = actor.transform.rotation
+        };
+
+        activeActors.Add(actor);
+    }
+
+    public void ResetActor(Actor actor)
+    {
+        if (!actorOriginals.TryGetValue(actor, out var data)) return;
+
+        Destroy(actor.gameObject);
+
+        GameObject newActorGO = Instantiate(data.prefab, data.originalPosition, data.originalRotation);
+        newActorGO.SetActive(true);
+
+        Actor newActor = newActorGO.GetComponent<Actor>();
+        actorOriginals.Remove(actor);
+        actorOriginals[newActor] = data;
+
+        activeActors.Remove(actor);
+        activeActors.Add(newActor);
+    }
+
+    public void ResetAllForObjective(Objective obj)
+    {
+        List<Actor> toReset = new();
+
+        foreach (var actor in activeActors)
+        {
+            if (actor != null && actor.objectiveList.Contains(obj))
+            {
+                toReset.Add(actor);
+            }
+        }
+
+        foreach (var actor in toReset)
+        {
+            ResetActor(actor);
+        }
+    }
+}

Scripts/AudioManager.cs

@@ -0,0 +1,82 @@
+    using UnityEngine;
+    using UnityEngine.Audio;
+    using System.Collections;
+
+    public class AudioManager : MonoBehaviour
+    {
+        public static AudioManager Instance { get; private set; }
+
+        public AudioMixer mixer;
+        public AudioSource musicSource;
+        public string musicVolumeParam = "MusicVolume";
+        public float fadeDuration = 1.0f;
+
+        [Range(-80f, 0f)] public float targetVolume = 0f; // 0 dB = full volume
+        [Range(-80f, 0f)] public float muteVolume = -80f;
+
+        private Coroutine currentFadeCoroutine;
+
+        public string radioEQParam = "RadioEQ";
+        public float radioEQOnGain = 0f;      // 0 dB
+        public float radioEQOffGain = -80f;   // Essentially muted
+
+    private void Awake()
+        {
+            if (Instance != null && Instance != this)
+            {
+                Destroy(gameObject);
+                return;
+            }
+
+            Instance = this;
+            DontDestroyOnLoad(gameObject);
+        }
+
+        private void Start()
+        {
+            if (!musicSource.isPlaying)
+            {
+                musicSource.Play();
+            }
+
+            mixer.SetFloat(musicVolumeParam, muteVolume);
+        }
+
+        public void FadeGameTheme(bool fadeIn, bool instant = false)
+        {
+            if (currentFadeCoroutine != null)
+                StopCoroutine(currentFadeCoroutine);
+
+            if (instant)
+            {
+                mixer.SetFloat(musicVolumeParam, fadeIn ? targetVolume : muteVolume);
+            }
+            else
+            {
+                currentFadeCoroutine = StartCoroutine(FadeMixerGroupVolume(fadeIn));
+            }
+        }
+
+        public void ToggleRadioEQ(bool on)
+        {
+        float gain = on ? radioEQOnGain : radioEQOffGain;
+        mixer.SetFloat(radioEQParam, gain);
+        }
+
+    private IEnumerator FadeMixerGroupVolume(bool fadeIn)
+        {
+            mixer.GetFloat(musicVolumeParam, out float startVolume);
+            float endVolume = fadeIn ? targetVolume : muteVolume;
+
+            float time = 0f;
+            while (time < fadeDuration)
+            {
+                float newVolume = Mathf.Lerp(startVolume, endVolume, time / fadeDuration);
+                mixer.SetFloat(musicVolumeParam, newVolume);
+                time += Time.deltaTime;
+                yield return null;
+            }
+
+            mixer.SetFloat(musicVolumeParam, endVolume);
+        }
+    }

Scripts/CrabHandler.cs

@@ -0,0 +1,429 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.AI;
+using UnityEngine.Animations.Rigging;
+
+public class CrabHandler : MonoBehaviour
+{
+    [Copyable] public Transform target;
+    private NavMeshAgent agent;
+
+    [Copyable] public float standStillRadius = 10.0f;
+    [Copyable] public float fleeRadius = 6.0f;
+    [Copyable] public float superSpeedRadius = 3.0f;
+    [Copyable] public float raycastLength = 2.0f;
+
+    private Quaternion targetRotation;
+    [Copyable] public bool shouldFlee = true;
+    [Copyable] public float normalSpeed = 3.5f;
+    [Copyable] public float superSpeed = 8.0f;
+
+    [Copyable] public bool isCarryingObject = false;
+    private GameObject carriedObject;
+    private GameManager gm;
+    [Copyable] public CrabBehavior crabBehavior;
+    [Copyable] public string targetingType;
+
+    [SerializeField] private bool startWithAgentDisabled = false;
+    private Animator animator;
+    private Rig carryRig;
+
+    void Start()
+    {
+        if (target == null)
+            target = GameObject.FindGameObjectWithTag("Player").transform;
+
+        agent = GetComponent<NavMeshAgent>();
+        agent.speed = normalSpeed;
+        gm = FindObjectOfType<GameManager>();
+
+        if (startWithAgentDisabled)
+        {
+            DisableAgentStuff();
+        }
+
+        if (carriedObject == null)
+        {
+            foreach (Transform child in transform)
+            {
+                if (child.CompareTag("PickUp"))
+                {
+                    carriedObject = child.gameObject;
+                    break; 
+                }
+            }
+        }
+
+        animator = GetComponentInChildren<Animator>();
+        carryRig = GetComponentInChildren<Rig>();
+    }
+
+
+    void Update()
+    {
+        isCarryingObject = HasChildWithTag("PickUp");
+
+        if (!string.IsNullOrEmpty(targetingType))
+        {
+            target = FindNearestTarget(targetingType);
+        }
+
+        CarryObject();
+
+        if (target != null)
+        {
+            float distanceToPlayer = Vector3.Distance(target.position, transform.position);
+            Vector3 directionToPlayer = (target.position - agent.transform.position).normalized;
+
+            switch (crabBehavior)
+            {
+                case CrabBehavior.Flee:
+                    HandleFleeBehavior(distanceToPlayer, directionToPlayer);
+                    break;
+
+                case CrabBehavior.Follow:
+                    HandleFollowBehavior(distanceToPlayer);
+                    break;
+
+                case CrabBehavior.PickingUp:
+                    HandlePickingUpBehavior(distanceToPlayer, directionToPlayer);
+                    break;
+
+                case CrabBehavior.GoTo:
+                    HandleGotoBehavior(distanceToPlayer, directionToPlayer);
+                    break;
+
+                case CrabBehavior.DropItem:
+                    DropObject();
+                    break;
+
+                case CrabBehavior.StandStill:
+                    HandleStandStillBehavior();
+                    break;
+
+            }
+
+
+        }
+        else {
+            target = transform;
+        }
+
+        if (animator != null && agent != null)
+        {
+            float currentSpeed = agent.velocity.magnitude;
+            animator.SetFloat("CrabSpeed", currentSpeed);
+        }
+
+    }
+
+    void HandleFleeBehavior(float distanceToPlayer, Vector3 directionToPlayer)
+    {
+
+        if (distanceToPlayer > standStillRadius)
+        {
+            agent.ResetPath();
+            return;
+        }
+        else
+        {
+            agent.isStopped = false;
+        }
+        
+        if (distanceToPlayer < superSpeedRadius)
+        {
+            agent.speed = superSpeed;
+        }
+        else
+        {
+            agent.speed = normalSpeed;
+        }
+
+        Vector3 targetPosition = agent.transform.position - directionToPlayer * fleeRadius;
+
+        NavMeshHit hit;
+        if (NavMesh.SamplePosition(targetPosition, out hit, fleeRadius, NavMesh.AllAreas))
+        {
+            agent.SetDestination(hit.position);
+        }
+    }
+
+    void HandleFollowBehavior(float distanceToPlayer)
+    {
+        Vector3 followTargetPosition = target.position;
+
+        NavMeshHit hit;
+        if (NavMesh.SamplePosition(followTargetPosition, out hit, fleeRadius, NavMesh.AllAreas))
+        {
+            agent.SetDestination(hit.position);
+        }
+
+        if (distanceToPlayer <= superSpeedRadius)
+        {
+            agent.isStopped = true;
+        }
+        else
+        {
+            agent.isStopped = false;
+        }
+
+        agent.speed = normalSpeed;
+    }
+
+    private float pickupRange = 2f;
+
+    void HandlePickingUpBehavior(float distanceToObject, Vector3 directionToObject)
+    {
+        if (target == null) return;
+
+        agent.isStopped = false;
+
+        if (distanceToObject > pickupRange)
+        {
+            Debug.Log("HELP ME IM IN GREAT PAIN");
+            agent.SetDestination(target.position);
+            agent.speed = normalSpeed;
+            return;
+        }
+
+        if (!isCarryingObject && target.CompareTag("PickUp"))
+        {
+            Debug.Log("Attempting pickup");
+            PickUpObject(target.gameObject);
+        }
+    }
+
+    void HandleGotoBehavior(float distanceToObject, Vector3 directionToObject)
+    {
+        agent.isStopped = false;
+
+        if (distanceToObject > 0.5f)
+        {
+            Debug.Log("HELP ME IM IN GREAT PAIN");
+            agent.SetDestination(target.position);
+            agent.speed = normalSpeed;
+        }
+    }
+
+    void HandleStandStillBehavior()
+    {
+        agent.isStopped = true;
+        agent.velocity = Vector3.zero;
+    }
+
+    void HandleGroundAlignmentAndRotation(Vector3 directionToPlayer)
+    {
+        RaycastHit groundHit;
+        if (Physics.Raycast(transform.position, Vector3.down, out groundHit, raycastLength))
+        {
+            Vector3 groundNormal = groundHit.normal;
+            targetRotation = Quaternion.FromToRotation(transform.up, groundNormal) * transform.rotation;
+            transform.rotation = targetRotation;
+        }
+
+        Vector3 directionToFace;
+        if (shouldFlee)
+        {
+            directionToFace = -directionToPlayer;
+        }
+        else
+        {
+            directionToFace = directionToPlayer;
+        }
+
+        directionToFace.y = 0;
+        Quaternion targetPlayerRotation = Quaternion.LookRotation(directionToFace);
+
+        transform.rotation = Quaternion.Slerp(transform.rotation, targetPlayerRotation, Time.deltaTime * 5f);
+    }
+
+    public void ApplyBoardTextEffects(List<string> confirmedWords)
+    {
+        targetingType = "";
+
+        foreach (string word in confirmedWords)
+        {
+            GameManager.WordEffect effect = gm.GetEffectForWord(word);
+
+            if (effect != null)
+            {
+                if (effect.affectFlee)
+                {
+                    if (effect.crabBehavior == CrabBehavior.Flee)
+                    {
+                        crabBehavior = CrabBehavior.Flee;
+                    }
+                    else if (effect.crabBehavior == CrabBehavior.Follow)
+                    {
+                        crabBehavior = CrabBehavior.Follow;
+                    }
+                    else if (effect.crabBehavior == CrabBehavior.PickingUp)
+                    {
+                        crabBehavior = CrabBehavior.PickingUp;
+                    }
+                    else if (effect.crabBehavior == CrabBehavior.DropItem)
+                    {
+                        crabBehavior = CrabBehavior.DropItem;
+                    }
+                    else if (effect.crabBehavior == CrabBehavior.StandStill)
+                    {
+                        crabBehavior = CrabBehavior.StandStill;
+                    }
+                    else if (effect.crabBehavior == CrabBehavior.GoTo)
+                    {
+                        crabBehavior = CrabBehavior.GoTo;
+                    }
+                }
+
+                if (effect.affectTarget)
+                {
+                    if (effect._target != null)
+                    {
+                        target = effect._target.transform;
+                    }
+                    else if (!string.IsNullOrEmpty(effect.targetType))
+                    {
+                        targetingType = effect.targetType;
+                        target = FindNearestTarget(effect.targetType);
+                    }
+                }
+            }
+        }
+    }
+
+
+
+    private Transform FindNearestTarget(string targetType)
+    {
+        Actor[] actors = FindObjectsOfType<Actor>();
+        Transform nearestTarget = null;
+        float shortestDistance = Mathf.Infinity;
+
+        foreach (Actor actor in actors)
+        {
+            Transform actorTransform = actor.transform;
+
+            if (actor.HasType(targetType) && !IsSelfOrAncestor(actorTransform))
+            {
+                float distance = Vector3.Distance(transform.position, actorTransform.position);
+                if (distance < shortestDistance)
+                {
+                    shortestDistance = distance;
+                    nearestTarget = actorTransform;
+                }
+            }
+        }
+
+        return nearestTarget;
+    }
+
+    private bool IsSelfOrAncestor(Transform other)
+    {
+        Transform current = transform;
+        while (current != null)
+        {
+            if (other == current)
+                return true;
+            current = current.parent;
+        }
+        return false;
+    }
+
+    void PickUpObject(GameObject obj)
+    {
+        carriedObject = obj;
+        obj.transform.SetParent(transform);
+        carriedObject.transform.position = transform.position + new Vector3(0, 0.8f, 0);
+        carriedObject.transform.localRotation = Quaternion.identity;
+
+        Collider objCollider = obj.GetComponent<Collider>();
+        if (objCollider != null) objCollider.enabled = false;
+
+        Rigidbody rb = obj.GetComponent<Rigidbody>();
+        if (rb != null) rb.isKinematic = true;
+
+            NavMeshAgent agent = obj.GetComponent<NavMeshAgent>();
+            if (agent != null)
+            {
+                agent.isStopped = true;
+                agent.updatePosition = false;
+                agent.updateRotation = false;
+            }
+    }
+
+
+    void DropObject()
+    {
+        if (carriedObject != null)
+        {
+            carriedObject.transform.SetParent(null);
+            Vector3 dropOffset = transform.forward * 1.5f + Vector3.down * 0.2f;
+            carriedObject.transform.position = transform.position + dropOffset;
+
+            Collider col = carriedObject.GetComponent<Collider>();
+            if (col != null)
+            {
+                col.enabled = true;
+            }
+
+            Rigidbody rb = carriedObject.GetComponent<Rigidbody>();
+            if (rb == null)
+            {
+                rb = carriedObject.AddComponent<Rigidbody>();
+            }
+
+            EquipInteract equip = carriedObject.GetComponent<EquipInteract>();
+            if (equip != null) {
+                equip.interactable = true;
+            }
+
+            rb.isKinematic = false;
+            rb.linearVelocity = Vector3.down * 2f;
+
+            NavMeshAgent agent = carriedObject.GetComponent<NavMeshAgent>();
+            if (agent != null)
+            {
+                agent.isStopped = false;
+                agent.updatePosition = true;
+                agent.updateRotation = true;
+            }
+
+            carriedObject = null;
+
+            crabBehavior = CrabBehavior.Follow;
+        }
+    }
+
+    void DisableAgentStuff()
+    {
+        if (agent != null)
+        {
+            agent.isStopped = true;
+            agent.updatePosition = false;
+            agent.updateRotation = false;
+        }
+    }
+
+    void CarryObject()
+    {
+        if (carryRig != null)
+        {
+            carryRig.weight = isCarryingObject ? 1f : 0f;
+        }
+    }
+
+    bool HasChildWithTag(string tag)
+    {
+        foreach (Transform child in transform)
+        {
+            if (child.CompareTag(tag))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+}

Scripts/CrabInteract.cs

@@ -0,0 +1,29 @@
+using UnityEngine;
+
+public class CrabInteract : InteractHandler
+{
+    public GameObject commandUIPrefab;
+    public LogManager logman;
+
+    private GameObject currentUI;
+
+    void Start()
+    {
+        logman = FindObjectOfType<LogManager>();
+    }
+
+    public override void InteractLogic()
+    {
+        if (currentUI == null) 
+        {
+            currentUI = Instantiate(commandUIPrefab);
+            currentUI.GetComponent<CrabInterface>().crab = GetComponent<CrabHandler>();
+            logman.SetCrabInterface(commandUIPrefab.GetComponent<CrabInterface>());
+        }
+
+        logman.ToggleLogMenu(true);
+
+        base.InteractLogic();
+        interactable = true;
+    }
+}

Scripts/CrabInterface.cs

@@ -0,0 +1,154 @@
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.InputSystem;
+using System.Collections.Generic;
+using TMPro;
+
+public class CrabInterface : MonoBehaviour
+{
+    public TextMeshProUGUI boardText; 
+    public Button clearButton;
+    public Button confirmButton;
+    public CrabHandler crab;
+    private HashSet<string> displayedWords = new HashSet<string>();
+    private const int maxWords = 2;
+    private GameManager gm;
+    public Animator animator;
+    public SpriteRenderer spriteRender;
+
+    private void Start()
+    {
+        GameObject uiCamObj = GameObject.FindGameObjectWithTag("UI");
+        Canvas canvas = GetComponent<Canvas>();
+        canvas.renderMode = RenderMode.ScreenSpaceCamera;
+        canvas.worldCamera = uiCamObj.GetComponent<Camera>();
+        canvas.planeDistance = 1f;
+        canvas.sortingLayerName = "UI";
+        canvas.sortingOrder = 500;
+
+        var renderers = GetComponentsInChildren<SpriteRenderer>();
+        foreach (var renderer in renderers)
+        {
+            renderer.sortingLayerName = "UI";
+            renderer.sortingOrder += 500;
+        }
+
+
+        LogManager logManager = FindObjectOfType<LogManager>();
+        gm = FindObjectOfType<GameManager>();
+
+        if (logManager != null)
+        {
+            logManager.SetCrabInterface(this); 
+        }
+
+        if (clearButton != null)
+        {
+            clearButton.onClick.AddListener(ClearBoard);
+        }
+
+        if (confirmButton != null)
+        {
+            confirmButton.onClick.AddListener(ConfirmBoardText);
+        }
+
+
+    }
+
+    private void Update()
+    {
+        
+    }
+
+    public void AddWordToBoard(string word)
+    {
+        if (displayedWords.Count >= maxWords)
+        {
+            return; 
+        }
+
+        if (!displayedWords.Contains(word))
+        {
+            displayedWords.Add(word);
+            boardText.text = string.Join(", ", displayedWords);
+            GameManager.WordEffect effect = gm.GetEffectForWord(word);
+
+            if (effect != null)
+            {
+                if (effect.affectFlee) {
+                  
+                    switch (effect.crabBehavior)
+                    {
+                        case CrabBehavior.Flee:
+                        case CrabBehavior.GoTo:
+                        case CrabBehavior.Follow:
+                            SetBehavior(1);
+                            Debug.Log("WE FOLLOW MUSK ON TWITTER");
+                            break;
+                        case CrabBehavior.PickingUp:
+                            SetBehavior(4);
+                            Debug.Log("WE PICK UP THE PHONE");
+                            break;
+                        case CrabBehavior.DropItem:
+                            SetBehavior(3);
+                            Debug.Log("WE DROP TILTED TOWERS");
+                            break;
+                        case CrabBehavior.StandStill:
+                            SetBehavior(2);
+                            Debug.Log("FREEZE!");
+                            break;
+                        default:
+                            SetBehavior(0); 
+                            break;
+                    }
+                }
+
+                if (effect.affectTarget)
+                {
+                    spriteRender.sprite = effect.wordSprite;
+
+                    if (spriteRender.sprite != null) {
+                        float targetSize = 7f;
+                        Vector2 spriteSize = effect.wordSprite.bounds.size;
+
+                        float scaleFactor = targetSize / Mathf.Max(spriteSize.x, spriteSize.y);
+                        spriteRender.transform.localScale = new Vector3(scaleFactor, scaleFactor, 1);
+                    }
+                }
+
+            }
+            else
+            {
+                Debug.Log("MISSING MY LOVE");
+            }
+        }
+    }
+
+    public void SetBehavior(int behavior)
+    {
+        if (animator != null)
+        {
+            animator.SetFloat("BehaviorIndex", behavior);
+        }
+    }
+
+    public void ClearBoard()
+    {
+        displayedWords.Clear();
+        boardText.text = "";
+        SetBehavior(0);
+        spriteRender.sprite = null;
+    }
+
+    public void ConfirmBoardText()
+    {
+        if (crab == null || gm == null)
+        {
+            return;
+        }
+
+        List<string> wordsList = new List<string>(displayedWords);
+        crab.ApplyBoardTextEffects(wordsList);
+        ClearBoard();
+    }
+}

Scripts/EquipmentController.cs

@@ -0,0 +1,95 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.Events;
+
+public class EquipmentController : MonoBehaviour
+{
+    public enum EquipmentType
+    {
+       None,
+       Weapon,
+       Tool,
+       Objective,
+    }
+
+    [Header("Information")]
+    [Tooltip("The name that will be displayed in the UI for this Equipment")]
+    public string EquipmentName;
+
+    [Tooltip("The image that will be displayed in the UI for this Equipment")]
+    public Image EquipmentIcon;
+
+    [Tooltip("The root object for the weapon, this is what will be deactivated when the weapon isn't active")]
+    public GameObject EquipmentRoot;
+
+    [Tooltip("The transform for the correct hand positioning of the equipment")]
+    public Transform EquipmentOffset;
+
+    [Tooltip("Tip of the Equipment, where the projectiles are shot (If a weapon")]
+    public Transform WeaponMuzzle;
+
+    [Tooltip("The type of Equipment wil affect how it is utilized")]
+    public EquipmentType EquipType;
+
+    [Tooltip("Check if Equipment is equipped")]
+    public bool Equipped;
+
+    [Tooltip("Maximum amount of ammo in the gun")]
+    public int MaxAmmo = 6;
+    public float CurrentAmmo = 6;
+
+    [Tooltip("The projectile prefab")] public GameObject ProjectilePrefab;
+    private StarterAssetsInputs _input;
+
+    // Start is called once before the first execution of Update after the MonoBehaviour is created
+    void Start()
+    {
+        _input = FindObjectOfType<StarterAssetsInputs>();
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+        switch (EquipType)
+        {
+            case EquipmentType.None:
+                // Maybe do nothing or add idle behavior
+                break;
+
+            case EquipmentType.Weapon:
+                if (Equipped)
+                {
+                    // Example: Shooting logic, checking for input, etc.
+                    Debug.Log("Weapon equipped.");
+                    // if (_input.shoot) { Fire(); }
+                }
+                break;
+
+            case EquipmentType.Tool:
+                if (Equipped)
+                {
+                    // Example: Use tool logic, maybe scanning or interacting
+                    Debug.Log("Tool equipped.");
+                    if (_input.aim) {
+                        Instantiate(ProjectilePrefab, transform);
+                    }
+                }
+                break;
+
+            case EquipmentType.Objective:
+                if (Equipped)
+                {
+                    // Example: Carry or activate objective
+                    Debug.Log("Objective equipped.");
+                }
+                break;
+
+            default:
+                Debug.LogWarning("Unknown EquipmentType");
+                break;
+        }
+    }
+
+}

Scripts/FirstPersonController.cs

@@ -0,0 +1,142 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+[RequireComponent(typeof(CharacterController))]
+public class FirstPersonController : MonoBehaviour
+{
+    [Header("Player")]
+    public float moveSpeed = 4.0f;
+    public float sprintSpeed = 6.0f;
+    public float crouchSpeed = 2.0f;
+    public float jumpHeight = 1.2f;
+    public float gravity = -15.0f;
+
+    [Header("Camera")]
+    public Transform cameraTransform;
+    public float cameraSensitivity = 1.0f;
+    public float maxCameraAngle = 85f;
+
+    [Header("Ground Check")]
+    public float groundCheckDistance = 0.4f;
+    public float groundCheckRadius = 0.3f;
+    public LayerMask groundLayer;
+    public bool isGrounded;
+
+    private float _fallTimeoutDelta;
+    private float _jumpTimeoutDelta;
+    private const float _terminalVelocity = 53.0f;
+
+    [Space(10)]
+    public float JumpTimeout = 0.1f;
+    public float FallTimeout = 0.15f;
+
+    private CharacterController controller;
+    private StarterAssetsInputs input;
+
+    private Vector3 velocity;
+    private float cameraPitch = 0f;
+    bool canMove = true;
+
+    private void Awake()
+    {
+        controller = GetComponent<CharacterController>();
+        input = GetComponent<StarterAssetsInputs>();
+    }
+
+    void Start()
+    {
+        _jumpTimeoutDelta = JumpTimeout;
+        _fallTimeoutDelta = FallTimeout;
+    }
+
+    private void OnDrawGizmos()
+    {
+        if (!Application.isPlaying) return;
+
+        Gizmos.color = isGrounded ? Color.green : Color.red;
+
+        Vector3 checkPosition = transform.position + Vector3.down * (controller.height / 2f) + controller.center;
+        Gizmos.DrawWireSphere(checkPosition, groundCheckRadius);
+    }
+
+    private void Update()
+    {
+        GroundedCheck();
+        JumpAndGravity();
+        if (!canMove)
+            return;
+        Move();
+    }
+
+    private void LateUpdate()
+    {
+        CameraRotation();
+    }
+
+    private void GroundedCheck()
+    {
+        Vector3 spherePosition = transform.position + Vector3.down * (controller.height / 2f) + controller.center;
+        isGrounded = Physics.CheckSphere(spherePosition, groundCheckRadius, groundLayer, QueryTriggerInteraction.Ignore);
+    }
+
+    private void JumpAndGravity()
+    {
+        if (isGrounded)
+        {
+            _fallTimeoutDelta = FallTimeout;
+
+            if (velocity.y < 0.0f)
+            {
+                velocity.y = -2f;
+            }
+
+            if (input.jump && _jumpTimeoutDelta <= 0.0f)
+            {
+                velocity.y = Mathf.Sqrt(jumpHeight * -2f * gravity);
+                _jumpTimeoutDelta = JumpTimeout;
+                input.jump = false; 
+            }
+        }
+        else
+        {
+            _fallTimeoutDelta -= Time.deltaTime;
+        }
+
+        if (_jumpTimeoutDelta >= 0.0f)
+        {
+            _jumpTimeoutDelta -= Time.deltaTime;
+        }
+
+        velocity.y = Mathf.Max(velocity.y + gravity * Time.deltaTime, -_terminalVelocity);
+
+        controller.Move(velocity * Time.deltaTime);
+    }
+
+
+    private void Move()
+    {
+        float speed = input.sprint ? sprintSpeed : (input.crouch ? crouchSpeed : moveSpeed);
+
+        Vector3 move = (transform.right * input.move.x + transform.forward * input.move.y).normalized;
+        controller.Move(move * speed * Time.deltaTime);
+    }
+
+    private void CameraRotation()
+    {
+        if (input.look.sqrMagnitude >= 0.01f)
+        {
+            float mouseX = input.look.x * cameraSensitivity * Time.deltaTime;
+            float mouseY = input.look.y * cameraSensitivity * Time.deltaTime;
+
+            cameraPitch -= mouseY;
+            cameraPitch = Mathf.Clamp(cameraPitch, -maxCameraAngle, maxCameraAngle);
+            cameraTransform.localRotation = Quaternion.Euler(cameraPitch, 0f, 0f);
+
+            transform.Rotate(Vector3.up * mouseX);
+        }
+    }
+
+    public void UnlockMove(bool value) => canMove = value;
+}

Scripts/GameManager.cs

@@ -0,0 +1,101 @@
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.InputSystem;
+using System.Collections.Generic;
+using UnityEngine.Playables;
+using TMPro;
+
+public enum CrabBehavior
+{
+    Flee,
+    Follow,
+    PickingUp,
+    DropItem,
+    GoTo,
+    StandStill,
+    Race
+}
+
+public class GameManager : MonoBehaviour
+{
+    public static GameManager Instance { get; private set; }
+
+    [System.Serializable]
+    public class WordEffect
+    {
+        public string word;
+        public CrabBehavior crabBehavior;
+        public GameObject _target;
+        public string targetType;
+        public bool affectFlee = true;
+        public bool affectTarget = true;
+        public AudioClip soundword;
+        public Sprite wordSprite;
+    }
+
+    private AudioSource audioSource;
+    public PlayableDirector timelineToPlay;
+
+    public List<WordEffect> wordEffectsList = new List<WordEffect>();
+    private Dictionary<string, WordEffect> wordEffectsDictionary = new Dictionary<string, WordEffect>();
+    public Animator borders; 
+
+    void Awake()
+    {
+        // Check if the instance already exists
+        if (Instance != null && Instance != this)
+        {
+            //Destroy(gameObject); 
+        }   
+        else
+        {
+            Instance = this; 
+            //DontDestroyOnLoad(gameObject); 
+        }
+    }
+
+
+    void Start()
+    {
+        audioSource = GetComponent<AudioSource>();
+
+        foreach (var effect in wordEffectsList)
+        {
+            wordEffectsDictionary[effect.word] = effect;
+        }
+    }
+
+    public WordEffect GetEffectForWord(string word)
+    {
+        if (wordEffectsDictionary.TryGetValue(word, out WordEffect effect))
+        {
+            return effect;
+        }
+        return null; 
+    }
+
+    public void PlaySoundForWord(string word)
+    {
+        WordEffect effect = GetEffectForWord(word);
+        if (effect != null && effect.soundword != null && audioSource != null)
+        {
+            audioSource.PlayOneShot(effect.soundword);
+        }
+    }
+
+    public void OnSliderValueChanged(float value)
+    {
+        if (Mathf.Approximately(value, 100f)) // Safer float comparison
+        {
+            if (timelineToPlay != null)
+            {
+                timelineToPlay.Play();
+            }
+            else
+            {
+                Debug.LogWarning("Timeline is not assigned.");
+            }
+        }
+    }
+}
+

Scripts/InteractHandler.cs

@@ -0,0 +1,34 @@
+using UnityEngine;
+
+public class InteractHandler : MonoBehaviour
+{
+    [Copyable] public bool interactable = true;
+    [TextArea] public string tooltipText = "Press E to interact";
+    [Copyable] public Objective ObjectiveProgress;
+    [Copyable] public Objective ObjectiveStart;
+
+    public virtual void InteractLogic()
+    {
+        if (ObjectiveProgress != null)
+        {
+
+            //npcObjective.currentProgress = npcObjective.goal; 
+            ObjectiveManager.Instance.UpdateObjectiveProgress(ObjectiveProgress, 1);
+
+            Debug.Log($"Objective '{ObjectiveProgress.objectiveName}' updated or completed.");
+            ObjectiveProgress = null;
+        }
+
+        if (ObjectiveStart != null)
+        {
+
+            //npcObjective.currentProgress = npcObjective.goal; 
+            ObjectiveManager.Instance.AddObjective(ObjectiveStart, transform);
+
+            Debug.Log($"Objective '{ObjectiveStart.objectiveName}' started");
+        }
+
+        Debug.Log("Interacted with: " + gameObject.name);
+        interactable = false;
+    }
+}

Scripts/InteractManager.cs

@@ -0,0 +1,73 @@
+using UnityEngine;
+using TMPro;
+
+public class InteractManager : MonoBehaviour
+{
+    private StarterAssetsInputs _input;
+    public TextMeshProUGUI tooltip;
+
+    private InteractHandler currentHoverTarget;
+    [SerializeField] private bool canInteract = false;
+
+    void Start()
+    {
+        _input = GetComponent<StarterAssetsInputs>();
+        HideToolTip();
+    }
+
+    void Update()
+    {
+        if (!canInteract) {
+            HideToolTip();
+            return;
+        }
+
+        Ray ray = new Ray(Camera.main.transform.position, Camera.main.transform.forward);
+        RaycastHit hit;
+
+        if (Physics.Raycast(ray, out hit))
+        {
+            InteractHandler interactObject = hit.collider.GetComponent<InteractHandler>();
+
+            if (interactObject != null && interactObject.interactable)
+            {
+                // Show tooltip if it's a new object
+                if (interactObject != currentHoverTarget)
+                {
+                    currentHoverTarget = interactObject;
+                    ShowToolTip(interactObject.tooltipText);
+                }
+
+                // Interact on key press
+                if (_input != null && _input.interact)
+                {
+                   interactObject.InteractLogic();
+                }
+
+                return;
+            }
+        }
+
+        if (currentHoverTarget != null)
+        {
+            currentHoverTarget = null;
+            HideToolTip();
+        }
+    }
+
+    public void ShowToolTip(string message)
+    {
+        tooltip.text = message;
+        tooltip.gameObject.SetActive(true);
+    }
+
+    public void HideToolTip()
+    {
+        tooltip.gameObject.SetActive(false);
+    }
+
+    public void UnlockInteract(bool unlock)
+    {
+        canInteract = unlock;
+    }
+}

Scripts/LogManager.cs

@@ -0,0 +1,174 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class LogManager : MonoBehaviour
+{
+    [System.Serializable]
+    public class LogEntry
+    {
+        public string wordOfInterest;
+        public string userDefinition;
+    }
+
+    public List<LogEntry> logEntries = new List<LogEntry>();
+    public GameObject logPrefab;
+    public Transform contentPanel;
+    public GameObject logMenu;
+    private bool isLogOpen = false;
+    private InteractManager interactMan;
+
+    private StarterAssetsInputs input;
+    public ScrollRect scrollRect;
+    private CrabInterface crabInterface;
+    public Animator scrollArea;
+    
+    [Header("Audio")]
+    public AudioClip openLogSound;
+    public AudioClip closeLogSound;
+    public AudioClip confirmSound;
+    public AudioClip clearSound;
+    private AudioSource audioSource;
+
+    [Copyable] public bool canOpenLog = false;
+
+    void Start()
+    {
+        UpdateLog();
+        interactMan = GetComponent<InteractManager>();
+        input = GetComponent<StarterAssetsInputs>();
+        logMenu.SetActive(false);
+        
+        audioSource = GetComponent<AudioSource>();
+        if (audioSource == null)
+        {
+            audioSource = gameObject.AddComponent<AudioSource>();
+            audioSource.playOnAwake = false;
+        }
+    }
+
+    void Update()
+    {
+        if (!canOpenLog)
+        {
+            return;
+        }
+
+        if (input.log)
+        {
+            ToggleLogMenu(!isLogOpen);
+            input.log = false;
+        }
+    }
+
+    public void SetCrabInterface(CrabInterface newCrabInterface)
+    {
+        crabInterface = newCrabInterface;
+    }
+
+    public void ToggleLogMenu(bool open)
+    {
+        isLogOpen = open;
+        logMenu.SetActive(isLogOpen);
+        AudioManager.Instance.ToggleRadioEQ(isLogOpen);
+        if (audioSource != null)
+        {
+            if (isLogOpen && openLogSound != null)
+            {
+                audioSource.PlayOneShot(openLogSound);
+            }
+            else if (!isLogOpen && closeLogSound != null)
+            {
+                audioSource.PlayOneShot(closeLogSound);
+            }
+        }
+            
+        if (isLogOpen)
+        {
+            AudioManager.Instance.ToggleRadioEQ(isLogOpen);
+            Time.timeScale = 0f;
+            input.SetCursorState(false);
+            interactMan.UnlockInteract(false);
+            scrollArea.Play("EnterScrollArea");
+            if (scrollRect != null)
+            {
+                scrollRect.verticalNormalizedPosition = 1f;
+            }
+        }
+        else
+        {
+            if (crabInterface != null)
+            Destroy(crabInterface.gameObject);
+
+            Time.timeScale = 1f;
+            interactMan.UnlockInteract(true);
+            input.SetCursorState(true);
+        }
+    }
+
+    public void AddWord(string newWord)
+    {
+        interactMan = GetComponent<InteractManager>();
+        input = GetComponent<StarterAssetsInputs>();
+        newWord = newWord.TrimEnd('!', '.', ',', '?', ';', ':').ToLower();
+        newWord = Char.ToUpper(newWord[0]) + newWord.Substring(1);
+
+        if (logEntries.Exists(entry => entry.wordOfInterest == newWord))
+            return;
+
+        logEntries.Add(new LogEntry { wordOfInterest = newWord, userDefinition = "" });
+        UpdateLog();
+    }
+
+
+    public void UpdateLog()
+    {
+        foreach (Transform child in contentPanel)
+        {
+            Destroy(child.gameObject);
+        }
+
+        foreach (var entry in logEntries.OrderBy(e => e.wordOfInterest))
+        {
+            GameObject logInstance = Instantiate(logPrefab, contentPanel);
+            Button button = logInstance.GetComponent<Button>();
+            LogUI logUI = logInstance.GetComponent<LogUI>();
+            logUI.Setup(entry.wordOfInterest, entry.userDefinition, this);
+            button.onClick.AddListener(() => OnWordClicked(entry));
+        }
+    }
+
+    private void OnWordClicked(LogEntry entry)
+    {
+        if (crabInterface != null)
+        {
+            crabInterface.AddWordToBoard(entry.wordOfInterest);
+        }
+
+        if (GameManager.Instance != null)
+        {
+            GameManager.Instance.PlaySoundForWord(entry.wordOfInterest);
+        }
+    }
+
+    public void UpdateUserDefinition(string word, string newDefinition)
+    {
+        LogEntry entry = logEntries.Find(e => e.wordOfInterest == word);
+        if (entry != null)
+        {
+            entry.userDefinition = newDefinition;
+        }
+    }
+
+    public void StartLogManager()
+    {
+
+    }
+
+    public void UnlockLog(bool unlock)
+    {
+        canOpenLog = unlock;
+    }
+}

Scripts/LogUI.cs

@@ -0,0 +1,26 @@
+using UnityEngine;
+using UnityEngine.UI;
+using TMPro;
+
+public class LogUI : MonoBehaviour
+{
+    public TextMeshProUGUI wordText;
+    public TMP_InputField definitionInput;
+    private LogManager manager;
+    private string word;
+
+    public void Setup(string word, string definition, LogManager manager)
+    {
+        this.word = word;
+        this.manager = manager;
+        wordText.text = word;
+        definitionInput.text = definition;
+
+        definitionInput.onValueChanged.AddListener(UpdateDefinition);
+    }
+
+    private void UpdateDefinition(string userInput)
+    {
+        manager.UpdateUserDefinition(word, userInput);
+    }
+}

Scripts/PickupObject.cs

@@ -0,0 +1,49 @@
+using UnityEngine;
+
+public class PickupObject : MonoBehaviour
+{
+    [Header("Pickup Settings")]
+    public float moveSpeed = 10f; // Speed at which the object moves
+    public Vector3 holdOffset = new Vector3(0, 0, 1.5f); // Offset in front of the camera
+
+    private Transform cameraTransform; // Player's camera transform
+    private Vector3 originalPosition; // Original position of the object
+    private Quaternion originalRotation; // Original rotation of the object
+    private bool isHolding = false; // Whether the object is currently in front of the camera
+
+    void Start()
+    {
+        // Find the player's camera (assumes it's tagged as "MainCamera")
+        cameraTransform = Camera.main.transform;
+
+        // Save the original position and rotation of the object
+        originalPosition = transform.position;
+        originalRotation = transform.rotation;
+    }
+
+    void Update()
+    {
+        // Smoothly move the object to its target position
+        if (isHolding)
+        {
+            // Move the object in front of the camera
+            Vector3 targetPosition = cameraTransform.position + cameraTransform.forward * holdOffset.z + cameraTransform.up * holdOffset.y;
+            Quaternion targetRotation = Quaternion.LookRotation(cameraTransform.forward, cameraTransform.up);
+
+            transform.position = Vector3.Lerp(transform.position, targetPosition, moveSpeed * Time.deltaTime);
+            transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, moveSpeed * Time.deltaTime);
+        }
+        else
+        {
+            // Return the object to its original position
+            transform.position = Vector3.Lerp(transform.position, originalPosition, moveSpeed * Time.deltaTime);
+            transform.rotation = Quaternion.Lerp(transform.rotation, originalRotation, moveSpeed * Time.deltaTime);
+        }
+    }
+
+    // Toggle the object's hold state
+    public void ToggleHold()
+    {
+        isHolding = !isHolding;
+    }
+}

Scripts/Player.cs

@@ -0,0 +1,14 @@
+using UnityEngine;
+
+public class Player : MonoBehaviour
+{
+    public static Player Instance;
+
+    void Awake()
+    {
+        if (Instance == null)
+            Instance = this;
+        else
+            Destroy(gameObject);
+    }
+}

Scripts/ReloadScene.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+public class ReloadScene : MonoBehaviour
+{
+    void Update()
+    {
+        if (Input.GetKeyDown(KeyCode.R))
+        {
+            SceneManager.LoadScene(SceneManager.GetActiveScene().name);
+        }
+    }
+}

Scripts/StarterAssetsInputs.cs

@@ -0,0 +1,247 @@
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+
+	public class StarterAssetsInputs : MonoBehaviour
+	{
+		[Header("Character Input Values")]
+		public Vector2 move, look;
+		public bool jump, sprint, crouch, attack, aim, interact, drop, log;
+		public bool equip1, equip2, equip3;
+		public bool toggleEquip;
+		public float cycleInput;
+
+		[Header("Movement Settings")]
+		public bool analogMovement;
+
+		[Header("Mouse Cursor Settings")]
+		public bool cursorLocked = true;
+		public bool cursorInputForLook = true;
+
+		//STANDARD MOVEMENT
+
+		void Start() {
+		SetCursorState(true);
+		}
+
+		public void OnMove(InputValue value)
+		{
+			MoveInput(value.Get<Vector2>());
+		}
+
+		public void OnLook(InputValue value)
+		{
+			if(cursorInputForLook)
+			{
+				LookInput(value.Get<Vector2>());
+			}
+		}
+		
+		//SPECIAL MOVEMENT
+
+		public void OnJump(InputValue value)
+		{
+			JumpInput(value.isPressed);
+		}
+
+		public void OnSprint(InputValue value)
+		{
+			SprintInput(value.isPressed);
+		}
+
+		public void OnCrouch(InputValue value)
+		{
+			CrouchInput(value.isPressed);
+		}
+
+		//ATTACK
+
+		public void OnAttack(InputValue value)
+		{
+			AttackInput(value.isPressed);
+		}
+
+		public void OnAim(InputValue value)
+		{
+			AimInput(value.isPressed);
+		}
+
+		public void OnDrop(InputValue value)
+		{
+			DropInput(value.isPressed);
+		}
+
+		public void OnLog(InputValue value)
+		{
+			LogInput(value.isPressed);
+		}
+
+
+	// INTERACT
+
+	public void OnInteract(InputValue value)
+		{
+			InteractInput(value.isPressed);
+		}
+
+		public void OnCycle(InputValue value)
+		{
+		Vector2 scrollValue = value.Get<Vector2>();
+		cycleInput = scrollValue.y;
+
+		if (cycleInput > 0)
+		{
+			CycleForward();
+		}
+		else if (cycleInput < 0)
+		{
+			CycleBackward();
+			}
+		}
+
+		public void CycleForward()
+		{
+		if (equip1)
+			{
+				equip1 = false;
+				equip2 = true;
+				equip3 = false;
+		}
+		else if (equip2)
+			{
+				equip2 = false;
+				equip1 = true;
+				equip3 = false;
+		}
+		else
+			{
+				equip1 = true;
+				equip3 = false;
+			}
+		}
+
+		public void CycleBackward()
+		{
+			CycleForward();
+		}
+
+		public void OnToggleEquip(InputValue value)
+		{
+			ToggleEquipInput(value.isPressed);
+
+			if (value.isPressed)
+			{
+				CycleForward();
+			}
+		}
+
+		//EQUIP
+
+		public void OnEquip1(InputValue value)
+		{
+		EquipInput(1, value.isPressed);
+		}
+
+		public void OnEquip2(InputValue value)
+		{
+		EquipInput(2, value.isPressed);
+		}
+
+		public void OnEquip3(InputValue value)
+		{
+		equip1 = false;
+		equip2 = false;
+		EquipInput(3, value.isPressed);
+		}
+
+		//INPUT
+		
+		public void MoveInput(Vector2 newMoveDirection)
+		{
+			move = newMoveDirection;
+		} 
+
+		public void LookInput(Vector2 newLookDirection)
+		{
+			look = newLookDirection;
+		}
+
+		public void JumpInput(bool newJumpState)
+		{
+			jump = newJumpState;
+		}
+
+		public void SprintInput(bool newSprintState)
+		{
+			sprint = newSprintState;
+		}
+
+		public void CrouchInput(bool newCrouchState)
+		{
+			crouch = newCrouchState;
+		}
+
+		public void AttackInput(bool newAttackState)
+		{
+			attack = newAttackState;
+		}
+
+		public void AimInput(bool newAimState)
+		{
+			aim = newAimState;
+		}
+
+		public void DropInput(bool newDropState)
+		{
+			drop = newDropState;
+		}
+
+		public void LogInput(bool newLogState)
+		{
+			log = newLogState;
+		}
+
+		public void InteractInput(bool newInteractState)
+		{
+			interact = newInteractState;
+		}
+
+		public void CycleInput(float newCycleState)
+		{
+			cycleInput = newCycleState;
+		}
+
+		public void ToggleEquipInput(bool newToggleEquipState)
+		{
+			toggleEquip = newToggleEquipState;
+		}
+
+		public void EquipInput(int equipSlot, bool newState)
+		{
+			switch (equipSlot)
+			{
+			case 1:
+				equip1 = newState;
+				break;
+			case 2:
+				equip2 = newState;
+				break;
+			case 3:
+				equip3 = newState;
+				break;
+			default:
+				Debug.LogError("Invalid equipment slot");
+				break;
+			}
+		}
+
+		private void OnApplicationFocus(bool hasFocus)
+		{
+			SetCursorState(cursorLocked);
+		}
+
+		public void SetCursorState(bool newState)
+		{
+			Cursor.lockState = newState ? CursorLockMode.Locked : CursorLockMode.None;
+		}
+	}

Scripts/UICrabAnimator.cs

@@ -0,0 +1,16 @@
+using UnityEngine;
+
+public class UICrabAnimator : MonoBehaviour
+{
+    // Start is called once before the first execution of Update after the MonoBehaviour is created
+    void Start()
+    {
+        
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+        
+    }
+}