PuzzleGame/PuzzleGameProject/Assets/Scripts/Rooms/Room.cs

using System;
using System.Collections;
using TMPro;
using UnityEngine;
using System.Collections.Generic;
using System.Linq;
using Unity.VisualScripting;
using UnityEngine.Serialization;


public abstract class Room : MonoBehaviour
{
    [SerializeField] private GameObject highlight;
    [SerializeField] private GameObject explored;
    [SerializeField] private Sprite litRoom;
    [FormerlySerializedAs("adjacentRooms")] [SerializeField] public List<GameObject> AdjacentRooms;
    public bool IsEntrance;
    [SerializeField] protected RoomRewards roomRewards;

    public event Action<Room> RoomExploredByDice;
    public event Action<Room> ThisRoomExploredByTorch;  
    public static event Action<Room> RoomExploredByTorch;
    private DicePair _diceSelected;
    
    protected bool _isExplored = false;
    protected Lock[] _locks;
    private bool _usingTorchAbility = false;
    
    private void OnEnable() {
        GameManager.StateChanged += HandleStateChange;
        GameManager.DiceSelected += HandleDiceSelected;
        GameManager.DiceUnselected += HandDiceUnselected;
        TorchAbility.TorchAbilityUsed += HandleTorchAbilityUsed;
        RoomExploredByTorch += HandleRoomExploredByTorch;
    }

    private void OnDisable() {
        GameManager.StateChanged -= HandleStateChange;
        GameManager.DiceSelected -= HandleDiceSelected;
        GameManager.DiceUnselected -= HandDiceUnselected;
        TorchAbility.TorchAbilityUsed -= HandleTorchAbilityUsed;
    }

    // Start is called once before the first execution of Update after the MonoBehaviour is created
    void Start() {
        InitializeRoom();
    }
    
    public bool GetRoomExplored()
    {
        return _isExplored;
    }

    public void SetRoomLit()
    {
        gameObject.GetComponent<SpriteRenderer>().sprite = litRoom;
    }

    public Lock[] GetLocks()
    {
        if (_locks != null)
        {
            return _locks;
        }

        return gameObject.GetComponents<Lock>();
    }

    public void AddBlockingRoom(Room blockingRoom)
    {
        Lock[] locks = gameObject.GetComponents<Lock>();
        foreach (Lock _lock in locks)
        {
            foreach (Lock blockingRoomLocks in blockingRoom.GetLocks())
            {
                if (blockingRoomLocks.Equals(_lock))
                {
                    _lock.SetBlockingRoom(blockingRoom);
                }
            }
        }
    }

    public abstract void SetRoomExplored();

    protected void SetExploredGUI()
    {
        explored.SetActive(true);
        foreach (GameObject roomObject in AdjacentRooms)
        {
            roomObject.GetComponent<Room>().SetRoomLit();
        }
    }
    protected virtual void InitializeRoom() {
        if (IsEntrance) {
            SetPropertiesOfEntrance();
        }
        _locks = gameObject.GetComponents<Lock>();
        roomRewards = gameObject.GetComponent<RoomRewards>();
    }

    protected void HighlightRoomAsOption()
    {
        highlight.SetActive(true);
    }

    protected void UnhighlightRoomAsOption()
    {
        highlight.SetActive(false);
    }

    void SetPropertiesOfEntrance() {
        gameObject.GetComponent<SpriteRenderer>().color = Color.yellow;
        IsEntrance = true;
    }
    
    void OnMouseDown() {
        if (!CheckIfValidRoomToExplore()) return;

        switch (GameManager.State)
        {
            case GameState.PickRoomOne:
            case GameState.PickRoomTwo:
                if (TryUnlock(_diceSelected))
                {
                    OnRoomExploredByDice();
                    SetRoomExplored();
                }
                else if(_usingTorchAbility && CheckIfValidRoomToExplore())
                {
                    SetRoomExplored();
                    OnRoomExploredByTorch();
                }
                break;
            default:
                if (_usingTorchAbility && CheckIfValidRoomToExplore())
                {
                    SetRoomExplored();
                    OnRoomExploredByTorch();
                }
                break;
        }
    }

    protected virtual void OnRoomExploredByDice() {
        RoomExploredByDice?.Invoke(this);
    }

    protected void SetLockGUI(TextMeshProUGUI text, Lock _lock)
    {
        _lock.AssignGUI(text);
    }

    protected void TriggerRoomRewards()
    {
        roomRewards.TriggerGetReward();
    }

    private void OnRoomExploredByTorch()
    {
        RoomExploredByTorch?.Invoke(this);
        ThisRoomExploredByTorch?.Invoke(this);
    }

    // Check if the room is valid to be explored. If so trigger the event.
    private bool CheckIfValidRoomToExplore() {
        if (_isExplored) {
            return false;
        }
        
        if (IsEntrance) {
            // All entrance rooms are valid to be explored.
            return true;
        }
        else if (HasExploredAdjacentRooms()) {
            // Otherwise the room must have an adjacent room explored.
            return true;
        }
        return false;
    }

    bool HasExploredAdjacentRooms() {
        foreach (GameObject adjacentRoom in AdjacentRooms) {
            if (adjacentRoom.GetComponent<Room>()._isExplored)
            {
                return true;
            }
        }
        return false;
    }

    public abstract bool TryUnlock(DicePair pair);

    private void HandleStateChange(GameState state) {
        UnhighlightRoomAsOption();
        switch (state)
        {
            case GameState.PickDiceOne:
            case GameState.PickDiceTwo:
                _diceSelected = null;
                break;
        }
    }

    private void HandleDiceSelected(DicePair pair)
    {
        _diceSelected = pair;
        if (TryUnlock(pair) && CheckIfValidRoomToExplore())
        {
            HighlightRoomAsOption();
        }
    }

    private void HandDiceUnselected()
    {
        _diceSelected = null;
        UnhighlightRoomAsOption();
    }

    private void HandleTorchAbilityUsed()
    {
        if (CheckIfValidRoomToExplore())
        {
            _usingTorchAbility = true;
            HighlightRoomAsOption();
        }
    }

    private void HandleRoomExploredByTorch(Room roomExploredByTorch)
    {
        _usingTorchAbility = false;
        if (_diceSelected != null && TryUnlock(_diceSelected))
        {
            return;
        }
        UnhighlightRoomAsOption();
    }
}