🌾 Farm Life

// IInteractable.cs
// ─────────────────────────────────────────────────────────────────────────────
// This is a C# interface — not a MonoBehaviour.
// Any script that can be interacted with by the player must implement
// this interface. The player calls Interact() without caring what type
// of object it is talking to (CropPatch, Chicken, or Tree).
// ─────────────────────────────────────────────────────────────────────────────

public interface IInteractable
{
    // Called when the player presses E while standing near this object.
    // The PlayerFarmer reference is passed in so the object can access
    // the player's inventory or position if needed.
    void Interact(PlayerFarmer player);

    // Returns the prompt text shown on screen when the player is nearby.
    // Example: "Press E to Plant", "Press E to Feed Chicken"
    string GetPromptText();
}

// Inventory.cs
// ─────────────────────────────────────────────────────────────────────────────
// Tracks everything the player is carrying: feed bags, harvested crops,
// and chopped wood. Other scripts call the public methods to add or
// spend items rather than accessing the counts directly.
// ─────────────────────────────────────────────────────────────────────────────

using UnityEngine;

public class Inventory : MonoBehaviour
{
    // ── Starting quantities (tunable in the Inspector) ──────────────────
    [SerializeField] private int startingFeedBags = 0;

    // ── Private counts — other scripts use the public methods below ─────
    private int feedBags;
    private int cropsHarvested;
    private int woodChopped;

    // ── Properties — read-only access for other scripts ─────────────────
    public int FeedBags      => feedBags;
    public int CropsHarvested => cropsHarvested;
    public int WoodChopped   => woodChopped;

    // ────────────────────────────────────────────────────────────────────
    // Awake: initialise quantities from Inspector values
    // ────────────────────────────────────────────────────────────────────
    void Awake()
    {
        feedBags = startingFeedBags;
    }

    // ── Feed Bag methods ─────────────────────────────────────────────────

    public void AddFeedBag()
    {
        feedBags++;
        Debug.Log($"Picked up feed bag. Total: {feedBags}");
    }

    // Returns true if the player had a feed bag to spend, false if empty.
    public bool SpendFeedBag()
    {
        if (feedBags <= 0)
        {
            Debug.Log("No feed bags left!");
            return false;
        }
        feedBags--;
        Debug.Log($"Used feed bag. Remaining: {feedBags}");
        return true;
    }

    // ── Crop methods ─────────────────────────────────────────────────────

    public void AddCrop(int value)
    {
        cropsHarvested++;
        // Notify the GameManager to update score
        GameManager.Instance.AddScore(value);
        Debug.Log($"Harvested crop worth {value} points. Total crops: {cropsHarvested}");
    }

    // ── Wood methods ─────────────────────────────────────────────────────

    public void AddWood(int value)
    {
        woodChopped++;
        GameManager.Instance.AddScore(value);
        Debug.Log($"Chopped wood worth {value} points. Total wood: {woodChopped}");
    }
}

// PlayerFarmer.cs
// ─────────────────────────────────────────────────────────────────────────────
// Attached to the PlayerArmature. Handles interaction input and
// keeps track of which IInteractable the player is currently near.
// Movement is handled by the Starter Assets controller — we only
// add the farming interaction layer here.
// ─────────────────────────────────────────────────────────────────────────────

using UnityEngine;
using TMPro;

public class PlayerFarmer : MonoBehaviour
{
    // ── Inspector References ─────────────────────────────────────────────
    // promptText is the single TMP_Text you created in the Canvas.
    // There is no separate "panel" — we show/hide the text object directly.
    [SerializeField] private TMP_Text promptText;

    // interactionRadius controls how close the player must be to trigger a prompt.
    // Tune this in the Inspector — 2.0 is a good starting value.
    [SerializeField] private float interactionRadius = 2.0f;

    // ── Cached Components ────────────────────────────────────────────────
    private Inventory inventory;

    // ── State ────────────────────────────────────────────────────────────
    private IInteractable nearbyInteractable;

    // Mobile chop hold state — read by Tree.cs each frame
    [HideInInspector] public bool isMobileChopping = false;

    // ── Property ─────────────────────────────────────────────────────────
    public Inventory Inventory => inventory;

    // ────────────────────────────────────────────────────────────────────
    // Awake: cache the Inventory component on this same GameObject
    // ────────────────────────────────────────────────────────────────────
    void Awake()
    {
        inventory = GetComponent<Inventory>();
        if (inventory == null)
            Debug.LogError("PlayerFarmer: Inventory component missing from this GameObject!");
    }

    // ────────────────────────────────────────────────────────────────────
    // Start: hide the prompt text at game start
    // ────────────────────────────────────────────────────────────────────
    void Start()
    {
        HidePrompt();
    }

    // ────────────────────────────────────────────────────────────────────
    // Update: every frame, use Physics.OverlapSphere to find the closest
    // interactable object within interactionRadius.
    //
    // Why OverlapSphere instead of OnTriggerEnter?
    // The Starter Assets PlayerArmature uses a CharacterController, which
    // has unreliable trigger behaviour. OverlapSphere is a direct physics
    // query that works correctly regardless of how the player is set up.
    // No special collider setup is needed on the player.
    // ────────────────────────────────────────────────────────────────────
    void Update()
    {
        FindNearestInteractable();

        if (nearbyInteractable != null)
        {
            ShowPrompt(nearbyInteractable.GetPromptText());

            // Keyboard: press E once to interact
            if (Input.GetKeyDown(KeyCode.E))
                nearbyInteractable.Interact(this);
        }
        else
        {
            HidePrompt();
        }

        // FeedBag pickup: check separately each frame
        CheckFeedBagPickup();
    }

    // ────────────────────────────────────────────────────────────────────
    // FindNearestInteractable: scan all colliders within interactionRadius
    // and set nearbyInteractable to the closest IInteractable found.
    // ────────────────────────────────────────────────────────────────────
    private void FindNearestInteractable()
    {
        // QueryTriggerInteraction.Collide means we detect both trigger
        // and non-trigger colliders — works with any Asset Store prefab
        Collider[] nearby = Physics.OverlapSphere(
            transform.position,
            interactionRadius,
            Physics.AllLayers,
            QueryTriggerInteraction.Collide
        );

        IInteractable closest  = null;
        float         closestD = float.MaxValue;

        foreach (Collider col in nearby)
        {
            // Skip the player's own colliders
            if (col.transform.root == transform.root) continue;

            IInteractable interactable = col.GetComponentInParent<IInteractable>();
            if (interactable == null) continue;

            float dist = Vector3.Distance(transform.position, col.transform.position);
            if (dist < closestD)
            {
                closestD = dist;
                closest  = interactable;
            }
        }

        nearbyInteractable = closest;
    }

    // ────────────────────────────────────────────────────────────────────
    // CheckFeedBagPickup: auto-collect any FeedBag the player walks over
    // ────────────────────────────────────────────────────────────────────
    private void CheckFeedBagPickup()
    {
        Collider[] nearby = Physics.OverlapSphere(transform.position, 1.0f);
        foreach (Collider col in nearby)
        {
            if (col.CompareTag("FeedBag"))
            {
                inventory.AddFeedBag();
                Destroy(col.gameObject);
            }
        }
    }

    // ────────────────────────────────────────────────────────────────────
    // Mobile button methods — called by on-screen UI buttons
    // ────────────────────────────────────────────────────────────────────
    public void MobileInteract()
    {
        if (nearbyInteractable != null)
            nearbyInteractable.Interact(this);
    }

    public void MobileChopBegin() { isMobileChopping = true;  }
    public void MobileChopEnd()   { isMobileChopping = false; }

    // ────────────────────────────────────────────────────────────────────
    // Prompt helpers
    // ────────────────────────────────────────────────────────────────────
    private void ShowPrompt(string message)
    {
        if (promptText == null) return;
        promptText.gameObject.SetActive(true);
        promptText.text = message;
    }

    private void HidePrompt()
    {
        if (promptText != null)
            promptText.gameObject.SetActive(false);
    }

    // Called by Tree.cs before it destroys itself
    public void ClearNearbyInteractable()
    {
        nearbyInteractable = null;
        HidePrompt();
    }
}

// CropPatch.cs
// ─────────────────────────────────────────────────────────────────────────────
// Manages the lifecycle of a single crop patch.
// Implements IInteractable so the player can plant and harvest
// by pressing E when nearby.
// ─────────────────────────────────────────────────────────────────────────────

using System.Collections;
using UnityEngine;

public class CropPatch : MonoBehaviour, IInteractable
{
    // ── State Machine ────────────────────────────────────────────────────
    // An enum cleanly names each stage — much better than using magic
    // integers (0, 1, 2, 3) which are hard to read and maintain.
    public enum CropState
    {
        Empty,     // bare soil, ready to plant
        Planted,   // seed in ground, starting to grow
        Growing,   // sprouting — yellow visual
        Ready      // fully grown — green, can be harvested
    }

    // ── Inspector Settings ───────────────────────────────────────────────
    [SerializeField] private float    plantedDuration = 10f; // seconds until Growing
    [SerializeField] private float    growingDuration = 8f;  // seconds until Ready
    [SerializeField] private int      cropValue       = 10;  // score awarded on harvest
    [SerializeField] private string   cropName        = "Wheat";

    // ── Materials for each visual state ──────────────────────────────────
    // Drag these in from the Project window in the Inspector.
    [SerializeField] private Material matEmpty;    // brown soil
    [SerializeField] private Material matPlanted;  // dark, moist soil
    [SerializeField] private Material matGrowing;  // yellow/green sprout
    [SerializeField] private Material matReady;    // bright green, ready

    // ── Cached Components ────────────────────────────────────────────────
    private Renderer  patchRenderer;  // the mesh renderer on this soil patch
    private Coroutine growCoroutine;  // stored so we can stop it if needed

    // ── Current State ────────────────────────────────────────────────────
    private CropState currentState = CropState.Empty;

    // ────────────────────────────────────────────────────────────────────
    // Awake: cache the Renderer component.
    // Use GetComponentInChildren — Asset Store prefabs almost always put
    // the mesh (and its Renderer) on a child object, not the root.
    // GetComponent would miss it and return null every time.
    // ────────────────────────────────────────────────────────────────────
    void Awake()
    {
        // Search this object AND all children for a Renderer
        patchRenderer = GetComponentInChildren<Renderer>();

        if (patchRenderer == null)
            Debug.LogError($"CropPatch on {name}: No Renderer found on this object or any child!");
    }

    // ────────────────────────────────────────────────────────────────────
    // Start: ensure the patch starts in the Empty visual state
    // ────────────────────────────────────────────────────────────────────
    void Start()
    {
        SetVisualState(CropState.Empty);
    }

    // ────────────────────────────────────────────────────────────────────
    // IInteractable implementation
    // ────────────────────────────────────────────────────────────────────

    public string GetPromptText()
    {
        // Return the right prompt depending on the current state
        return currentState switch
        {
            CropState.Empty   => "Press E to Plant",
            CropState.Planted => "Growing... please wait",
            CropState.Growing => "Almost ready...",
            CropState.Ready   => $"Press E to Harvest {cropName}",
            _                  => ""
        };
    }

    public void Interact(PlayerFarmer player)
    {
        switch (currentState)
        {
            case CropState.Empty:
                Plant();        // start the growing process
                break;

            case CropState.Ready:
                Harvest(player); // give crop to player, reset patch
                break;

            // Planted/Growing states: do nothing — just show the prompt
        }
    }

    // ────────────────────────────────────────────────────────────────────
    // Plant: transition from Empty to Planted, start growing coroutine
    // ────────────────────────────────────────────────────────────────────
    private void Plant()
    {
        currentState = CropState.Planted;
        SetVisualState(CropState.Planted);
        Debug.Log($"{name}: Planted. Growing in {plantedDuration} seconds.");

        // Start the coroutine and store the reference so we could stop it
        growCoroutine = StartCoroutine(GrowSequence());
    }

    // ────────────────────────────────────────────────────────────────────
    // GrowSequence: the coroutine that advances the crop through stages.
    //
    // yield return new WaitForSeconds(t) pauses HERE and resumes after
    // t seconds — Update() and other coroutines keep running normally.
    // ────────────────────────────────────────────────────────────────────
    private IEnumerator GrowSequence()
    {
        // ── Stage 1: Planted → Growing ──────────────────────────────────
        yield return new WaitForSeconds(plantedDuration);

        currentState = CropState.Growing;
        SetVisualState(CropState.Growing);
        Debug.Log($"{name}: Now growing. Ready in {growingDuration} seconds.");

        // ── Stage 2: Growing → Ready ────────────────────────────────────
        yield return new WaitForSeconds(growingDuration);

        currentState = CropState.Ready;
        SetVisualState(CropState.Ready);
        Debug.Log($"{name}: {cropName} is ready to harvest!");
    }

    // ────────────────────────────────────────────────────────────────────
    // Harvest: add crop to inventory, reset patch to Empty
    // ────────────────────────────────────────────────────────────────────
    private void Harvest(PlayerFarmer player)
    {
        Debug.Log($"{name}: Harvested {cropName} for {cropValue} points!");
        player.Inventory.AddCrop(cropValue);

        // Reset the patch back to Empty so it can be planted again
        currentState = CropState.Empty;
        SetVisualState(CropState.Empty);
    }

    // ────────────────────────────────────────────────────────────────────
    // SetVisualState: swap the material to match the current state.
    // This provides instant, visible feedback without any animation.
    // ────────────────────────────────────────────────────────────────────
    private void SetVisualState(CropState state)
    {
        if (patchRenderer == null) return;

        patchRenderer.material = state switch
        {
            CropState.Empty   => matEmpty,
            CropState.Planted => matPlanted,
            CropState.Growing => matGrowing,
            CropState.Ready   => matReady,
            _                  => matEmpty
        };
    }
}

// Chicken.cs
// ─────────────────────────────────────────────────────────────────────────────
// A hungry chicken wanders randomly. The player feeds it by pressing E
// while holding a feed bag. After 30 seconds the chicken gets hungry again.
// ─────────────────────────────────────────────────────────────────────────────

using System.Collections;
using UnityEngine;

public class Chicken : MonoBehaviour, IInteractable
{
    // ── Inspector Settings ───────────────────────────────────────────────
    [SerializeField] private float hungerDuration    = 30f; // seconds before hungry again
    [SerializeField] private float wanderRadius      = 3f;  // how far the chicken strays
    [SerializeField] private float wanderInterval    = 3f;  // seconds between wander moves
    [SerializeField] private float wanderSpeed       = 1.5f;// movement speed while wandering
    [SerializeField] private int   feedScore         = 15;  // score for feeding this chicken

    // ── Cached Components ────────────────────────────────────────────────
    private Animator animator;

    // ── State ────────────────────────────────────────────────────────────
    private bool isHungry = true;
    private Vector3 homePosition; // where the chicken started
    private Vector3 wanderTarget;  // current wander destination

    // ────────────────────────────────────────────────────────────────────
    // Awake: cache the Animator component
    // ────────────────────────────────────────────────────────────────────
    void Awake()
    {
        animator = GetComponent<Animator>();
        homePosition = transform.position;
        wanderTarget = homePosition;
    }

    // ────────────────────────────────────────────────────────────────────
    // Start: begin the wander coroutine immediately
    // ────────────────────────────────────────────────────────────────────
    void Start()
    {
        StartCoroutine(WanderRoutine());
    }

    // ────────────────────────────────────────────────────────────────────
    // Update: move toward the current wander target each frame
    // ────────────────────────────────────────────────────────────────────
    void Update()
    {
        if (!isHungry) return; // fed chickens stand still

        float distToTarget = Vector3.Distance(transform.position, wanderTarget);

        if (distToTarget > 0.1f)
        {
            // Move toward wander target using Time.deltaTime for frame-rate independence
            transform.position = Vector3.MoveTowards(
                transform.position,
                wanderTarget,
                wanderSpeed * Time.deltaTime
            );

            // Face the direction of movement
            Vector3 dir = (wanderTarget - transform.position).normalized;
            if (dir != Vector3.zero)
                transform.rotation = Quaternion.LookRotation(dir);
        }
    }

    // ────────────────────────────────────────────────────────────────────
    // WanderRoutine: every wanderInterval seconds, pick a new random
    // destination within wanderRadius of the home position.
    // ────────────────────────────────────────────────────────────────────
    private IEnumerator WanderRoutine()
    {
        while (true) // loop forever — chicken always wanders when hungry
        {
            yield return new WaitForSeconds(wanderInterval);

            if (isHungry)
            {
                // Pick a random point within the wander radius
                Vector2 randomCircle = Random.insideUnitCircle * wanderRadius;
                wanderTarget = homePosition + new Vector3(randomCircle.x, 0, randomCircle.y);
            }
        }
    }

    // ────────────────────────────────────────────────────────────────────
    // IInteractable implementation
    // ────────────────────────────────────────────────────────────────────

    public string GetPromptText()
    {
        return isHungry
            ? "Press E to Feed Chicken (needs feed bag)"
            : "Chicken is happy!";
    }

    public void Interact(PlayerFarmer player)
    {
        if (!isHungry)
        {
            Debug.Log("This chicken is already fed.");
            return;
        }

        // Attempt to spend a feed bag from the player's inventory
        bool hasFeed = player.Inventory.SpendFeedBag();

        if (!hasFeed)
        {
            Debug.Log("You need a feed bag to feed the chicken. Find one on the farm!");
            return;
        }

        // Feed successful!
        Feed(player);
    }

    // ────────────────────────────────────────────────────────────────────
    // Feed: mark as fed, play animation, start the re-hunger timer
    // ────────────────────────────────────────────────────────────────────
    private void Feed(PlayerFarmer player)
    {
        isHungry = false;

        // Trigger the Eat animation on the Animator Controller
        // The string "Eat" must match the Trigger parameter name exactly.
        if (animator != null)
            animator.SetTrigger("Eat");

        // Award the player score directly via GameManager
        GameManager.Instance.AddScore(feedScore);

        Debug.Log($"Chicken fed! Will get hungry again in {hungerDuration} seconds.");

        // Start the countdown to hunger again
        StartCoroutine(HungerTimer());
    }

    // ────────────────────────────────────────────────────────────────────
    // HungerTimer: after hungerDuration seconds, the chicken is hungry again
    // ────────────────────────────────────────────────────────────────────
    private IEnumerator HungerTimer()
    {
        yield return new WaitForSeconds(hungerDuration);

        isHungry = true;
        Debug.Log($"{name} is hungry again!");
    }
}

// Tree.cs
// ─────────────────────────────────────────────────────────────────────────────
// The player holds E to chop a tree. A UI Slider fills as chopping progresses.
// When the progress reaches 1.0, the tree falls and is destroyed.
//
// Key concept: Time.deltaTime makes chopping speed frame-rate independent.
// Without it, the chop speed would vary wildly between fast and slow machines.
// ─────────────────────────────────────────────────────────────────────────────

using System.Collections;
using UnityEngine;
using UnityEngine.UI;

public class Tree : MonoBehaviour, IInteractable
{
    // ── Inspector Settings ───────────────────────────────────────────────
    [SerializeField] private float  chopDuration   = 4f;  // seconds to fully chop
    [SerializeField] private int    woodValue      = 20;  // score for chopping this tree
    [SerializeField] private float  fallDuration   = 1.2f;// seconds the tree takes to "fall"
    [SerializeField] private Slider chopProgressBar;    // the UI Slider — drag in from Canvas

    // ── State ────────────────────────────────────────────────────────────
    private float chopProgress    = 0f;    // 0.0 = untouched, 1.0 = fully chopped
    private bool  isBeingChopped  = false; // is the player currently holding E?
    private bool  isFalling       = false; // prevent double-chop once falling
    private PlayerFarmer currentPlayer;    // the player that started chopping

    // ────────────────────────────────────────────────────────────────────
    // Start: initialise the progress bar (it should be hidden at game start)
    // ────────────────────────────────────────────────────────────────────
    void Start()
    {
        if (chopProgressBar != null)
        {
            chopProgressBar.value = 0f;
            chopProgressBar.gameObject.SetActive(false);
        }
    }

    // ────────────────────────────────────────────────────────────────────
    // Update: advance chop progress while E is held (keyboard) OR while
    // the mobile chop button is held (isMobileChopping on PlayerFarmer).
    //
    // chopProgress += Time.deltaTime / chopDuration
    //   → Time.deltaTime is the time since the last frame (e.g. 0.016s at 60fps)
    //   → Dividing by chopDuration normalises it: 1 second of holding = 1/chopDuration
    //   → After chopDuration seconds of holding, chopProgress reaches 1.0
    // ────────────────────────────────────────────────────────────────────
    void Update()
    {
        if (isFalling) return; // already done — stop processing

        // Accept input from keyboard (PC) OR mobile button flag
        bool chopInputHeld = Input.GetKey(KeyCode.E)
                          || (currentPlayer != null && currentPlayer.isMobileChopping);

        if (isBeingChopped)
        {
            if (chopInputHeld)
            {
                // Advance progress (frame-rate independent)
                chopProgress += Time.deltaTime / chopDuration;
                chopProgress = Mathf.Clamp01(chopProgress); // keep between 0 and 1

                // Drive the UI Slider
                if (chopProgressBar != null)
                    chopProgressBar.value = chopProgress;

                // Trigger the fall when fully chopped
                if (chopProgress >= 1f)
                    StartCoroutine(FallAndDestroy());
            }
            else
            {
                // Player released — pause chopping but keep progress
                isBeingChopped = false;
                if (chopProgressBar != null)
                    chopProgressBar.gameObject.SetActive(false);
            }
        }
    }

    // ────────────────────────────────────────────────────────────────────
    // IInteractable implementation
    // ────────────────────────────────────────────────────────────────────

    public string GetPromptText()
    {
        if (isFalling) return "Timber!";
        if (chopProgress > 0f)
            return $"Hold E to continue chopping ({(int)(chopProgress * 100)}%)";
        return "Hold E to Chop Tree";
    }

    public void Interact(PlayerFarmer player)
    {
        if (isFalling) return;

        // Pressing E starts (or resumes) chopping
        // Update() will then check GetKey(E) each frame
        isBeingChopped = true;
        currentPlayer  = player;

        if (chopProgressBar != null)
            chopProgressBar.gameObject.SetActive(true);

        Debug.Log($"{name}: Chopping started ({(int)(chopProgress * 100)}% complete)");
    }

    // ────────────────────────────────────────────────────────────────────
    // FallAndDestroy: tree "falls" (tilts), then is destroyed.
    // We use a coroutine to wait for the visual effect before Destroy().
    // ────────────────────────────────────────────────────────────────────
    private IEnumerator FallAndDestroy()
    {
        isFalling = true;
        isBeingChopped = false;

        // Hide the progress bar
        if (chopProgressBar != null)
            chopProgressBar.gameObject.SetActive(false);

        // Award the player their wood score
        if (currentPlayer != null)
            currentPlayer.Inventory.AddWood(woodValue);

        Debug.Log($"{name}: Timber! Falling over {fallDuration} seconds.");

        // Animate the tree tilting over using rotation over time
        float elapsed = 0f;
        Quaternion startRot = transform.rotation;
        Quaternion endRot   = Quaternion.Euler(0, 0, 90f); // falls sideways

        while (elapsed < fallDuration)
        {
            elapsed += Time.deltaTime;
            transform.rotation = Quaternion.Lerp(startRot, endRot, elapsed / fallDuration);
            yield return null; // wait one frame, then continue the loop
        }

        // Clear the player's interaction target before destroying
        if (currentPlayer != null)
            currentPlayer.ClearNearbyInteractable();

        // Destroy the tree GameObject
        // Note: script execution stops after this call
        Destroy(gameObject);
    }
}

// GameManager.cs
// ─────────────────────────────────────────────────────────────────────────────
// A singleton manager that controls the game session: timer, score, and UI.
// Any script in the scene can call GameManager.Instance.AddScore(n) to
// award points without needing a direct reference to this GameObject.
// ─────────────────────────────────────────────────────────────────────────────

using UnityEngine;
using TMPro;

public class GameManager : MonoBehaviour
{
    // ── Singleton ────────────────────────────────────────────────────────
    // A static property — belongs to the CLASS, not any instance.
    // Set in Awake so it's available before Start() runs anywhere.
    public static GameManager Instance { get; private set; }

    // ── Inspector References ─────────────────────────────────────────────
    [SerializeField] private TMP_Text  scoreText;
    [SerializeField] private TMP_Text  timerText;
    [SerializeField] private GameObject gameOverPanel;
    [SerializeField] private TMP_Text  finalScoreText;

    // ── Game Settings ────────────────────────────────────────────────────
    [SerializeField] private float gameDuration = 120f; // 2 minutes

    // ── Runtime State ────────────────────────────────────────────────────
    private int   totalScore = 0;
    private float timeRemaining;
    private bool  gameIsOver = false;

    // ────────────────────────────────────────────────────────────────────
    // Awake: set up the singleton reference.
    // This runs before any Start(), so Instance is ready for everyone.
    // ────────────────────────────────────────────────────────────────────
    void Awake()
    {
        // If an Instance already exists (e.g. from a previous scene load), destroy this one
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this;
    }

    // ────────────────────────────────────────────────────────────────────
    // Start: initialise the game session
    // ────────────────────────────────────────────────────────────────────
    void Start()
    {
        timeRemaining = gameDuration;
        totalScore    = 0;
        gameIsOver    = false;

        if (gameOverPanel != null)
            gameOverPanel.SetActive(false);

        UpdateUI();
    }

    // ────────────────────────────────────────────────────────────────────
    // Update: count down the timer each frame
    // ────────────────────────────────────────────────────────────────────
    void Update()
    {
        if (gameIsOver) return;

        timeRemaining -= Time.deltaTime;

        if (timeRemaining <= 0f)
        {
            timeRemaining = 0f;
            EndGame();
        }

        UpdateTimerDisplay();
    }

    // ────────────────────────────────────────────────────────────────────
    // Public API — called by Inventory, Chicken, etc.
    // ────────────────────────────────────────────────────────────────────

    public void AddScore(int points)
    {
        if (gameIsOver) return;
        totalScore += points;
        UpdateScoreDisplay();
        Debug.Log($"Score: {totalScore} (+{points})");
    }

    // ────────────────────────────────────────────────────────────────────
    // UI helpers
    // ────────────────────────────────────────────────────────────────────

    private void UpdateUI()
    {
        UpdateScoreDisplay();
        UpdateTimerDisplay();
    }

    private void UpdateScoreDisplay()
    {
        if (scoreText != null)
            scoreText.text = $"Score: {totalScore}";
    }

    private void UpdateTimerDisplay()
    {
        if (timerText == null) return;

        // Format as MM:SS for readability
        int minutes = (int)(timeRemaining / 60);
        int seconds = (int)(timeRemaining % 60);
        timerText.text = $"{minutes:00}:{seconds:00}";

        // Turn red in the last 30 seconds as a visual warning
        timerText.color = timeRemaining <= 30f
            ? new Color(0.9f, 0.2f, 0.1f)
            : Color.white;
    }

    private void EndGame()
    {
        gameIsOver = true;
        Debug.Log($"Game Over! Final score: {totalScore}");

        if (gameOverPanel != null)
            gameOverPanel.SetActive(true);

        if (finalScoreText != null)
            finalScoreText.text = $"Final Score\n{totalScore}";

        // Pause the game
        Time.timeScale = 0f;
    }
}