using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using System.Collections.Generic;
using System.Security.Cryptography;

public class ButtonNavigator : MonoBehaviour
{
    // === Serialized Fields for UI Elements ===
    public Button[] buttons; // UI buttons selectable from the list
    public Transform[] snapPoints; // Points where buttons can be placed
    public Transform backgroundImage; // Background UI element for placing buttons

    // === Internal State Tracking ===
    private int selectedIndex = 0; // Current selected index in the button list
    private int snapIndex = 0; // Current snap point index during placement
    private int placedButtonIndex = -1; // Index of selected placed button
    private GameObject clonedButton; // The button currently being placed
    private bool isPlacing = false; // Flag for placing mode
    private bool isSelectingPlacedButton = false; // Flag for selecting already placed buttons
    private bool[] snapOccupied; // Tracks if a snap point is in use
    private List placedButtons = new List(); // List of buttons that have been placed

    // === Initialization ===
    void Start()
    {
        snapOccupied = new bool[snapPoints.Length]; // All snap points start as unoccupied

        if (buttons.Length > 0)
        {
            HighlightButton(selectedIndex); // Highlight the first button initially
        }
    }

    // === Main Update Loop: Delegates Input Based on Current Mode ===
    void Update()
    {
        if (isPlacing)
        {
            HandlePlacementNavigation(); // Navigating snap points while placing
        }
        else if (isSelectingPlacedButton)
        {
            HandlePlacedButtonSelection(); // Navigating through placed buttons
        }
        else
        {
            HandleButtonSelection(); // Navigating the list of original buttons
        }
    }

    // === Navigation and Selection for Button List ===
    void HandleButtonSelection()
    {
        if (Input.GetKeyDown(KeyCode.W))
        {
            selectedIndex = (selectedIndex - 1 + buttons.Length) % buttons.Length;
            HighlightButton(selectedIndex);
        }
        else if (Input.GetKeyDown(KeyCode.S))
        {
            selectedIndex = (selectedIndex + 1) % buttons.Length;
            HighlightButton(selectedIndex);
        }
        else if (Input.GetKeyDown(KeyCode.Space))
        {
            StartPlacingButton(); // Clone and begin placing the selected button
        }
        else if (Input.GetKeyDown(KeyCode.A) || Input.GetKeyDown(KeyCode.D))
        {
            if (placedButtons.Count > 0)
            {
                placedButtonIndex = 0;
                HighlightPlacedButton(placedButtonIndex);
                isSelectingPlacedButton = true;
                ResetButtonHighlight(); // Clear selection highlight from the list
            }
        }
    }

    // === Highlights a Button in the Selection List ===
    void HighlightButton(int index)
    {
        EventSystem.current.SetSelectedGameObject(buttons[index].gameObject);

        foreach (Button btn in buttons)
        {
            btn.GetComponent().color = Color.white;
        }

        buttons[index].GetComponent().color = Color.yellow;
    }

    // === Begin the Placement Process for a Selected Button ===
    void StartPlacingButton()
    {
        if (clonedButton != null) return; // Only one clone at a time

        clonedButton = Instantiate(buttons[selectedIndex].gameObject);
        clonedButton.transform.SetParent(backgroundImage, false);
        clonedButton.transform.SetAsLastSibling();
        clonedButton.GetComponent().interactable = false;

        if (AreAllSnapPointsOccupied())
        {
            Debug.Log("All snap points are occupied. Cannot place more buttons.");
            Destroy(clonedButton);
            clonedButton = null;
            return;
        }

        snapIndex = GetNextAvailableSnapIndex(0);
        MoveClonedButtonToSnapPoint();
        isPlacing = true;
    }

    // === Navigation While Placing a Button ===
    void HandlePlacementNavigation()
    {
        if (Input.GetKeyDown(KeyCode.A))
        {
            int newSnapIndex = GetNextAvailableSnapIndex(-1);
            if (newSnapIndex != snapIndex)
            {
                snapIndex = newSnapIndex;
                MoveClonedButtonToSnapPoint();
            }
        }
        else if (Input.GetKeyDown(KeyCode.D))
        {
            int newSnapIndex = GetNextAvailableSnapIndex(1);
            if (newSnapIndex != snapIndex)
            {
                snapIndex = newSnapIndex;
                MoveClonedButtonToSnapPoint();
            }
        }
        else if (Input.GetKeyDown(KeyCode.Space))
        {
            ConfirmPlacement(); // Finalize button placement
        }
    }

    // === Move Cloned Button to a Snap Point ===
    void MoveClonedButtonToSnapPoint()
    {
        clonedButton.transform.position = snapPoints[snapIndex].position;
        clonedButton.GetComponent().color = new Color(1, 1, 1, 0.5f); // Semi-transparent preview
    }

    // === Finalize Placement of the Cloned Button ===
    void ConfirmPlacement()
    {
        snapOccupied[snapIndex] = true;
        clonedButton.GetComponent().interactable = true;
        clonedButton.GetComponent().color = Color.white;

        placedButtons.Add(clonedButton);
        clonedButton = null;
        isPlacing = false;
    }

    // === Navigation and Selection of Already Placed Buttons ===
    void HandlePlacedButtonSelection()
    {
        if (Input.GetKeyDown(KeyCode.A))
        {
            placedButtonIndex = (placedButtonIndex - 1 + placedButtons.Count) % placedButtons.Count;
            HighlightPlacedButton(placedButtonIndex);
        }
        else if (Input.GetKeyDown(KeyCode.D))
        {
            placedButtonIndex = (placedButtonIndex + 1) % placedButtons.Count;
            HighlightPlacedButton(placedButtonIndex);
        }
        else if (Input.GetKeyDown(KeyCode.Return) || Input.GetKeyDown(KeyCode.Space))
        {
            StartMovingPlacedButton(); // Pick up and move a placed button
        }
        else if (Input.GetKeyDown(KeyCode.W) || Input.GetKeyDown(KeyCode.S))
        {
            ResetPlacedButtonHighlight();
            isSelectingPlacedButton = false;
            HighlightButton(selectedIndex); // Switch back to list
        }
        else if (Input.GetKeyDown(KeyCode.Escape))
        {
            ResetPlacedButtonHighlight();
            isSelectingPlacedButton = false;
        }
    }

    // === Resets Highlighting for Original Button List ===
    void ResetButtonHighlight()
    {
        foreach (Button btn in buttons)
        {
            btn.GetComponent().color = Color.white;
        }
    }

    // === Highlight a Placed Button in Green ===
    void HighlightPlacedButton(int index)
    {
        foreach (GameObject btn in placedButtons)
        {
            btn.GetComponent().color = Color.white;
        }

        placedButtons[index].GetComponent().color = Color.green;
    }

    // === Reset All Placed Buttons to Default Color ===
    void ResetPlacedButtonHighlight()
    {
        foreach (GameObject btn in placedButtons)
        {
            btn.GetComponent().color = Color.white;
        }
    }

    // === Begin Moving a Placed Button by Re-entering Placement Mode ===
    void StartMovingPlacedButton()
    {
        clonedButton = placedButtons[placedButtonIndex];
        snapIndex = FindSnapPointIndex(clonedButton.transform.position);
        snapOccupied[snapIndex] = false;

        isPlacing = true;
        isSelectingPlacedButton = false;
        placedButtons.RemoveAt(placedButtonIndex);
    }

    // === Utility: Get Next Available Snap Point in a Direction ===
    int GetNextAvailableSnapIndex(int direction)
    {
        int newIndex = snapIndex;
        int attempts = 0;

        do
        {
            newIndex = (newIndex + direction + snapPoints.Length) % snapPoints.Length;
            attempts++;
            if (attempts > snapPoints.Length) return snapIndex;
        } while (snapOccupied[newIndex]);

        return newIndex;
    }

    // === Utility: Find Index of Snap Point Based on Position ===
    int FindSnapPointIndex(Vector3 position)
    {
        for (int i = 0; i < snapPoints.Length; i++)
        {
            if (Vector3.Distance(snapPoints[i].position, position) < 0.1f)
                return i;
        }
        return 0;
    }

    // === Utility: Check if All Snap Points Are Occupied ===
    bool AreAllSnapPointsOccupied()
    {
        foreach (bool occupied in snapOccupied)
        {
            if (!occupied) return false;
        }
        return true;
    }
}
              

using UnityEngine;
using System.Collections;

public class GridRotator : MonoBehaviour
{
    // === Configuration ===
    public float rotationDuration = 0.2f; // Duration of rotation animation in seconds

    // === Internal State ===
    private TileManager tileManager;      // Reference to TileManager script
    private bool isRotating = false;      // Prevents simultaneous rotations
    private float targetRotationY = 0f;   // Target Y rotation in degrees

    // === Initialization ===
    void Start()
    {
        tileManager = GetComponent();

        if (tileManager == null)
        {
            Debug.LogError("TileManager not found! Attach GridRotator to the same GameObject as TileManager.");
        }

        targetRotationY = transform.eulerAngles.y; // Set initial rotation value
    }

    // === Frame Update ===
    void Update()
    {
        HandleRotation(); // Process input for rotation
    }

    // === Input Handling for Rotation ===
    void HandleRotation()
    {
        if (isRotating) return; // Block input while rotating

        if (Input.GetKeyDown(KeyCode.Q))
        {
            targetRotationY -= 90f; // Rotate left
            StartCoroutine(SnapRotate());
        }
        else if (Input.GetKeyDown(KeyCode.E))
        {
            targetRotationY += 90f; // Rotate right
            StartCoroutine(SnapRotate());
        }
    }

    // === Smooth Rotation Animation ===
    private IEnumerator SnapRotate()
    {
        isRotating = true;

        float currentRotationY = transform.eulerAngles.y;
        float elapsedTime = 0f;

        // Compute the center of the grid for rotation
        Vector3 center = new Vector3((tileManager.gridWidth - 1) / 2f, 0, (tileManager.gridHeight - 1) / 2f);

        while (elapsedTime < rotationDuration)
        {
            elapsedTime += Time.deltaTime;
            float newY = Mathf.LerpAngle(currentRotationY, targetRotationY, elapsedTime / rotationDuration);

            // Apply smooth rotation around grid center
            transform.RotateAround(center, Vector3.up, newY - transform.eulerAngles.y);
            yield return null;
        }

        // Snap to exact target rotation to correct any interpolation errors
        transform.RotateAround(center, Vector3.up, targetRotationY - transform.eulerAngles.y);
        isRotating = false;
    }
}
              

                public class PlayerAction : MonoBehaviour
{
    // === Enumerations for Player Movement Options ===
    public enum TurnDirection { None, Turn90, Turn180 }
    public enum TurnSide { Left, Right }                  // Which way to turn
    public enum MoveDirection { Forward, Backward }       // Which way to move

    // === Configurable Action Settings ===
    public TurnDirection turnDirection;                   // Type of rotation (None, 90°, 180°)
    public TurnSide turnSide = TurnSide.Right;            // Direction of rotation (default: Right)
    public MoveDirection moveDirection;                   // Direction of movement
    public float moveDistance = 1f;                       // How far to move
    public float turnSpeed = 90f;                         // Degrees per second while turning
    public float moveSpeed = 2f;                          // Units per second while moving

    // === Action Execution Coroutine ===
    public IEnumerator ExecuteAction(Transform target)
    {
        // --- Handle Rotation ---
        if (turnDirection != TurnDirection.None)
        {
            float targetAngle = (turnDirection == TurnDirection.Turn90) ? 90f : 180f;
            float rotated = 0f;

            float turnMultiplier = (turnSide == TurnSide.Right) ? 1f : -1f;

            while (rotated < targetAngle)
            {
                float step = turnSpeed * Time.deltaTime;
                target.Rotate(0f, step * turnMultiplier, 0f);
                rotated += step;
                yield return null;
            }
        }

        // --- Handle Movement ---
        if (moveDistance > 0)
        {
            Vector3 direction = (moveDirection == MoveDirection.Forward) ? target.forward : -target.forward;
            Vector3 startPos = target.position;
            Vector3 endPos = startPos + direction * moveDistance;

            float t = 0f;
            while (t < 1f)
            {
                t += Time.deltaTime * (moveSpeed / moveDistance);
                target.position = Vector3.Lerp(startPos, endPos, t);
                yield return null;
            }
        }
    }
}
              

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class PlayerActionExecutor : MonoBehaviour
{
    // === Configuration ===
    public string playerTag = "Player";                  // Tag used to find the player object
    public Transform actionContainer;                    // Parent object containing PlayerAction components

    // === Runtime State ===
    private Transform player;                            // Cached player transform
    private bool isExecuting = false;                    // Prevents multiple executions at once

    // === Input Trigger ===
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.T) && !isExecuting)
        {
            Debug.Log("Starting coroutine to execute player actions...");
            StartCoroutine(Execute());
        }
    }

    // === Main Execution Coroutine ===
    IEnumerator Execute()
    {
        isExecuting = true;

        // --- Wait until player object is available ---
        while (player == null)
        {
            GameObject playerObj = GameObject.FindGameObjectWithTag(playerTag);
            if (playerObj != null)
            {
                player = playerObj.transform;
                Debug.Log("Player detected: " + player.name);
            }
            else
            {
                yield return null; // Wait a frame and try again
            }
        }

        // --- Collect and execute all PlayerAction components ---
        PlayerAction[] actions = actionContainer.GetComponentsInChildren();
        Debug.Log($"Found {actions.Length} PlayerAction components. Starting execution...");

        foreach (PlayerAction action in actions)
        {
            Debug.Log("Executing action: " + action.name);
            yield return StartCoroutine(action.ExecuteAction(player));
        }

        Debug.Log("Finished executing all player actions.");

        // --- Cleanup UI after execution ---
        DeleteAllChildren();

        isExecuting = false;
    }

    // === Utility: Cleanup Action UI ===
    private void DeleteAllChildren()
    {
        foreach (Transform child in actionContainer)
        {
            Destroy(child.gameObject);
        }
        Debug.Log("All child objects of actionContainer have been deleted.");
    }
}
              

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerMovementVisual : MonoBehaviour
{
    // === Configuration ===
    public GameObject indicatorPrefab; // Prefab to visually indicate the hovered tile

    // === Runtime References ===
    private GameObject indicatorInstance;
    private TileManager tileManager;

    // === Initialization ===
    void Start()
    {
        // Locate TileManager in the scene
        tileManager = FindObjectOfType();
        if (tileManager == null)
        {
            Debug.LogError("TileManager not found in the scene!");
            return;
        }

        // Create indicator instance from prefab
        if (indicatorPrefab != null)
        {
            indicatorInstance = Instantiate(indicatorPrefab);
            indicatorInstance.SetActive(false); // Hide initially
        }
        else
        {
            Debug.LogError("Indicator Prefab not assigned!");
        }
    }


    void Update()
    {
        UpdateIndicatorPosition();
    }

    // === Visual Feedback: Update Indicator ===
    private void UpdateIndicatorPosition()
    {
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        RaycastHit hit;

        if (Physics.Raycast(ray, out hit))
        {
            // Show indicator above a tile if hit
            if (hit.collider.CompareTag("Tile"))
            {
                Vector3 tilePosition = hit.collider.transform.position;
                Vector3 indicatorPosition = new Vector3(tilePosition.x, tilePosition.y + 1f, tilePosition.z);

                indicatorInstance.transform.position = indicatorPosition;
                indicatorInstance.SetActive(true);
            }
            else
            {
                indicatorInstance.SetActive(false); // Not a tile
            }
        }
        else
        {
            indicatorInstance.SetActive(false); // No hit
        }
    }
}
              

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class SpawnObjects : MonoBehaviour
{
    // === Configuration ===
    [Header("Player Settings")]
    public GameObject playerPrefab;       // Prefab to spawn as the player
    public float spawnHeight = 0.75f;     // Y offset for the spawn position

    // === Runtime State ===
    private TileManager tileManager;
    private Vector3 playerStartPosition;
    private List availableTiles = new List();

    // === Initialization ===
    void Start()
    {
        tileManager = FindObjectOfType();

        if (tileManager == null)
        {
            Debug.LogError("TileManager not found in the scene!");
            return;
        }

        StartCoroutine(WaitForWallsAndSpawn());
    }

    // === Coroutine: Wait until the grid is ready ===
    private IEnumerator WaitForWallsAndSpawn()
    {
        while (!tileManager.AreWallsPlaced)
        {
            yield return null;
        }

        playerStartPosition = tileManager.GetPlayerStartPosition();
        SpawnPlayer();

        // Reserve the player's spawn tile
        availableTiles.Remove(playerStartPosition);
    }

    // === Player Instantiation ===
    private void SpawnPlayer()
    {
        if (playerPrefab == null)
        {
            Debug.LogError("Player Prefab is not assigned in the Inspector!");
            return;
        }

        Vector3 adjustedPosition = new Vector3(playerStartPosition.x, spawnHeight, playerStartPosition.z);
        Debug.Log($"Spawning player at: {adjustedPosition}");

        GameObject player = Instantiate(playerPrefab, adjustedPosition, Quaternion.identity);

        // Optional: parent to tile manager for organization
        player.transform.SetParent(tileManager.transform);
    }
}
              

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

public class TileManager : MonoBehaviour
{
    public static HashSet walkableTiles = new HashSet();
    public int gridWidth = 12, gridHeight = 12;
    public GameObject tilePrefab;
    public float totalFallTime = 5f;
    public float fallHeight = 10f;
    public GameObject wallPrefab;
    public Material startTileMaterial, pathMaterial, highlightMaterial;
    private Vector3Int startTile, endTile;
    public float obstacleFallHeight = 10f;  // Fall height for obstacles
    public float wallFallHeight = 10f;      // Fall height for walls
    public GameObject TestEndDestination;



    [System.Serializable]
    public class KeyItemSpawn
    {
        public GameObject keyItemPrefab; // The key item prefab to spawn
        public int minCount; // Minimum number of this key item to spawn
        public int maxCount; // Maximum number of this key item to spawn
    }


    [Header("Path Settings")]
    public int numberOfPaths = 1;

    [Header("Item Settings")]
    public int keyItemCount = 3;
    public KeyItemSpawn[] keyItems; // Array of key item types

    [Header("Obstacle Settings")]
    public int obstacleCount = 10;
    public GameObject obstaclePrefab;

    public bool AreWallsPlaced { get; private set; } = false;
    public Vector3 playerStartPosition;
    private bool firstTilePlaced = false;

    private HashSet pathTiles = new HashSet();
    private List> allPaths = new List>();
    private HashSet validPath = new HashSet(); // Changed from List to HashSet for efficiency
    public float obstacleEndHeight = 0.75f;  // End position height for obstacles (default or set in Unity)
    public float wallEndHeight = 0.5f;       // End position height for walls (default or set in Unity)
    [SerializeField] private float placementHeight = 0.5f;  // Variable for adjusting placement height


    public Vector3 GetPlayerStartPosition() => playerStartPosition;

    public void RegisterTile(Vector3Int position)
    {
        walkableTiles.Add(position);
    }

    public static bool IsWalkable(Vector3Int position)
    {
        return walkableTiles.Contains(position);
    }

    private void Start()
    {
        GenerateGrid();
    }

    void GenerateGrid()
    {
        StartCoroutine(GenerateTiles());
    }

    private IEnumerator GenerateTiles()
    {
        List allTiles = new List();
        int totalTiles = gridWidth * gridHeight;
        float delayBetweenTiles = totalFallTime / totalTiles;

        for (int x = 0; x < gridWidth; x++)
        {
            for (int z = 0; z < gridHeight; z++)
            {
                Vector3Int tilePos = new Vector3Int(x, 0, z);
                allTiles.Add(tilePos);

                Vector3 position = new Vector3(x, fallHeight, z);
                GameObject newTile = Instantiate(tilePrefab, position, Quaternion.identity, transform);
                RegisterTile(tilePos);

                if (!firstTilePlaced)
                {
                    startTile = tilePos;
                    firstTilePlaced = true;
                    Debug.Log($"Start Tile: {startTile}");

                    if (startTileMaterial != null)
                    {
                        Renderer tileRenderer = newTile.GetComponent();
                        if (tileRenderer != null) tileRenderer.material = startTileMaterial;
                    }
                }

                newTile.name = $"Tile_{x}_{z}";
                StartCoroutine(FallToPosition(newTile, new Vector3(x, 0, z)));
                yield return new WaitForSeconds(delayBetweenTiles);
            }
        }

        // Now generate multiple paths and save them to allPaths
        allPaths = GenerateMultiplePaths(startTile, numberOfPaths);

        // Highlight all paths
        foreach (var path in allPaths)
        {
            foreach (Vector3Int tile in path)
            {
                GameObject tileObj = transform.Find($"Tile_{tile.x}_{tile.z}")?.gameObject;
                if (tileObj != null && pathMaterial != null)
                {
                    Renderer tileRenderer = tileObj.GetComponent();
                    if (tileRenderer != null)
                    {
                        tileRenderer.material = pathMaterial;
                    }
                }
            }
        }

        // Ensure paths exist before placing key items
        if (allPaths.Count > 0)
        {
            // Get the last path's last tile
            endTile = allPaths[allPaths.Count - 1].Last();

            // Check if the tile is NOT at (0, 0)
            if (endTile.x != 0 || endTile.z != 0)
            {
                if (TestEndDestination != null)
                {
                    Vector3 spawnPosition = new Vector3(endTile.x + 0.5f, placementHeight, endTile.z + 0.5f);
                    Instantiate(TestEndDestination, spawnPosition, Quaternion.identity, transform);
                    Debug.Log($"Spawned TestEndDestination at {spawnPosition}");
                }
                else
                {
                    Debug.LogWarning("TestEndDestination is not assigned in the Inspector.");
                }
            }
            else
            {
                Debug.Log("Skipping spawn because end tile is at (0,0)");
            }
        }

        // Now place obstacles, passing allTiles to PlaceObstacles
        yield return StartCoroutine(PlaceObstacles(allTiles));
        PlaceKeyItems();
        StartCoroutine(GenerateWalls());
    }



    private IEnumerator GenerateWalls()
    {
        float wallOffset = 0.75f;
        float delayBetweenWalls = totalFallTime / (2 * gridWidth + 2 * gridHeight);

        // Create walls along the x-axis (left and right walls)
        for (int x = 0; x < gridWidth; x++)
        {
            Vector3 position = new Vector3(x, fallHeight, -wallOffset);  // Start position at fallHeight
            GameObject wall = Instantiate(wallPrefab, position, Quaternion.Euler(0, 90, 0), transform);
            StartCoroutine(FallToPosition(wall, new Vector3(x, wallEndHeight, -wallOffset)));  // Fall to custom end height for walls
            yield return new WaitForSeconds(delayBetweenWalls);
        }

        // Create walls along the z-axis (top and bottom walls)
        for (int z = 0; z < gridHeight; z++)
        {
            Vector3 position = new Vector3(gridWidth - 1 + wallOffset, fallHeight, z);  // Start position at fallHeight
            GameObject wall = Instantiate(wallPrefab, position, Quaternion.identity, transform);
            StartCoroutine(FallToPosition(wall, new Vector3(gridWidth - 1 + wallOffset, wallEndHeight, z)));  // Fall to custom end height for walls
            yield return new WaitForSeconds(delayBetweenWalls);
        }

        // Create walls along the x-axis (right and left edges)
        for (int x = gridWidth - 1; x >= 0; x--)
        {
            Vector3 position = new Vector3(x, fallHeight, gridHeight - 1 + wallOffset);  // Start position at fallHeight
            GameObject wall = Instantiate(wallPrefab, position, Quaternion.Euler(0, 90, 0), transform);
            StartCoroutine(FallToPosition(wall, new Vector3(x, wallEndHeight, gridHeight - 1 + wallOffset)));  // Fall to custom end height for walls
            yield return new WaitForSeconds(delayBetweenWalls);
        }

        // Create walls along the z-axis (bottom and top edges)
        for (int z = gridHeight - 1; z >= 0; z--)
        {
            Vector3 position = new Vector3(-wallOffset, fallHeight, z);  // Start position at fallHeight
            GameObject wall = Instantiate(wallPrefab, position, Quaternion.identity, transform);
            StartCoroutine(FallToPosition(wall, new Vector3(-wallOffset, wallEndHeight, z)));  // Fall to custom end height for walls
            yield return new WaitForSeconds(delayBetweenWalls);
        }

        yield return null;
        AreWallsPlaced = true;
        Debug.Log("All walls have been placed!");
    }



    private Vector3Int SelectEndTile(Vector3Int start)
    {
        int minDistance = Mathf.Max(gridWidth, gridHeight) / 2;
        Vector3Int chosenTile;

        do
        {
            chosenTile = new Vector3Int(Random.Range(0, gridWidth), 0, Random.Range(0, gridHeight));
        } while (Vector3Int.Distance(start, chosenTile) < minDistance ||
                 !GeneratePath(start, chosenTile).Contains(chosenTile));

        return chosenTile;
    }

    private HashSet GeneratePath(Vector3Int start, Vector3Int end)
    {
        HashSet path = new HashSet();
        Queue queue = new Queue();
        Dictionary cameFrom = new Dictionary();

        queue.Enqueue(start);
        cameFrom[start] = start;

        Vector3Int[] directions = { Vector3Int.right, Vector3Int.left, Vector3Int.forward, Vector3Int.back };

        while (queue.Count > 0)
        {
            Vector3Int current = queue.Dequeue();
            if (current == end) break;

            foreach (var dir in directions)
            {
                Vector3Int next = current + dir;
                if (walkableTiles.Contains(next) && !cameFrom.ContainsKey(next))
                {
                    queue.Enqueue(next);
                    cameFrom[next] = current;
                }
            }
        }

        if (!cameFrom.ContainsKey(end))
        {
            Debug.LogError("No valid path found!");
            return new HashSet();
        }

        Vector3Int step = end;
        while (step != start)
        {
            path.Add(step);
            step = cameFrom[step];
        }
        path.Add(start);

        Debug.Log($"Generated path with {path.Count} tiles.");
        return path;
    }

    private IEnumerator PlaceObstacles(List allTiles)
    {
        HashSet pathTiles = new HashSet();

        // Use the stored paths instead of regenerating
        foreach (var path in allPaths)
        {
            pathTiles.UnionWith(path);
        }

        List possibleSpots = new List(allTiles);
        possibleSpots.RemoveAll(tile => pathTiles.Contains(tile));

        int placedObstacles = 0;
        int maxAttempts = 1000;

        while (placedObstacles < obstacleCount && possibleSpots.Count > 0 && maxAttempts > 0)
        {
            maxAttempts--;  // Decrease attempts

            int randIndex = Random.Range(0, possibleSpots.Count);
            Vector3Int obstacleTile = possibleSpots[randIndex];
            possibleSpots.RemoveAt(randIndex);

            // Check if the tile is mistakenly on a path
            if (pathTiles.Contains(obstacleTile))
            {
                Debug.LogError($"ERROR: Attempted to place obstacle on path {obstacleTile}!");
                continue;
            }

            // Create the obstacle at a custom height
            Vector3 startPosition = new Vector3(obstacleTile.x, fallHeight, obstacleTile.z);  // Starting height for obstacles
            GameObject obstacle = Instantiate(obstaclePrefab, startPosition, Quaternion.identity, transform);

            // Register the obstacle position
            RegisterObstacle(obstacleTile);

            // Use the FallToPosition coroutine to move it down to the desired target height
            StartCoroutine(FallToPosition(obstacle, new Vector3(obstacleTile.x, obstacleEndHeight, obstacleTile.z)));  // Custom end height for obstacles

            placedObstacles++;

           
            yield return new WaitForSeconds(totalFallTime / obstacleCount);
        }

        if (maxAttempts <= 0)
        {
            Debug.LogError("Max attempts reached while trying to place obstacles!");
        }

        Debug.Log($"Placed {placedObstacles} obstacles.");
    }


    private HashSet obstacleTiles = new HashSet();  

    private void PlaceKeyItems()
    {
        if (allPaths.Count == 0)
        {
            Debug.LogError("No valid path available for key item placement.");
            return;
        }

        HashSet validAdjacentTiles = new HashSet();
        HashSet keyItemTiles = new HashSet();
        HashSet allPathTiles = new HashSet();

        foreach (var path in allPaths)
        {
            allPathTiles.UnionWith(path);
        }

        Debug.Log($"Total number of path tiles: {allPathTiles.Count}");

        foreach (var pathTile in allPathTiles)
        {
            Vector3Int[] adjacentTiles = new Vector3Int[]
            {
            pathTile + Vector3Int.right,
            pathTile + Vector3Int.left,
            pathTile + Vector3Int.forward,
            pathTile + Vector3Int.back
            };

            foreach (var adjacentTile in adjacentTiles)
            {
                if (IsWalkable(adjacentTile) &&
                    !allPathTiles.Contains(adjacentTile) &&
                    !obstacleTiles.Contains(adjacentTile) &&
                    !keyItemTiles.Contains(adjacentTile))
                {
                    validAdjacentTiles.Add(adjacentTile);
                }
            }
        }

        if (validAdjacentTiles.Count == 0)
        {
            Debug.LogError("No valid adjacent tiles found to place key items!");
            return;
        }

        List adjacentTileList = validAdjacentTiles.ToList();
        ShuffleList(adjacentTileList); // Shuffle tiles for randomness

        foreach (var keyItem in keyItems)
        {
            int spawnCount = Random.Range(keyItem.minCount, keyItem.maxCount + 1);
            Debug.Log($"Spawning {spawnCount} of {keyItem.keyItemPrefab.name}");

            for (int i = 0; i < spawnCount && adjacentTileList.Count > 0; i++)
            {
                Vector3Int spawnTile = adjacentTileList[0];
                adjacentTileList.RemoveAt(0);

                Vector3 spawnPosition = new Vector3(spawnTile.x, placementHeight, spawnTile.z);
                GameObject spawnedItem = Instantiate(keyItem.keyItemPrefab, spawnPosition, Quaternion.identity, transform);

                keyItemTiles.Add(spawnTile);
                Vector3 closestPathTilePosition = FindClosestPathTile(spawnTile);
                Quaternion targetRotation = Quaternion.LookRotation((closestPathTilePosition - spawnPosition).normalized);
                spawnedItem.transform.rotation = Quaternion.Euler(0, targetRotation.eulerAngles.y, 0);

                Debug.Log($"Placed {keyItem.keyItemPrefab.name} at {spawnPosition}, facing {closestPathTilePosition}");

                RemoveAdjacentTiles(spawnTile, validAdjacentTiles, keyItemTiles);
            }
        }
    }

    // Method to shuffle a list 
    private void ShuffleList(List list)
    {
        System.Random rng = new System.Random();
        int n = list.Count;
        while (n > 1)
        {
            n--;
            int k = rng.Next(n + 1);
            (list[k], list[n]) = (list[n], list[k]); // Swap elements
        }
    }

    // Method to remove adjacent tiles to a placed key item
    private void RemoveAdjacentTiles(Vector3Int keyItemTile, HashSet validAdjacentTiles, HashSet keyItemTiles)
    {
        // Get adjacent tiles (up, down, left, right)
        Vector3Int[] adjacentTiles = new Vector3Int[]
        {
    keyItemTile + Vector3Int.right,
    keyItemTile + Vector3Int.left,
    keyItemTile + Vector3Int.forward,
    keyItemTile + Vector3Int.back
        };

        // Remove adjacent tiles from the valid adjacent tiles set to avoid key items spawning too close to each other
        foreach (var adjacentTile in adjacentTiles)
        {
            validAdjacentTiles.Remove(adjacentTile);
            keyItemTiles.Add(adjacentTile);  // Mark adjacent tiles as occupied by a key item
        }
    }

    // Method to find the closest path tile to a given position
    private Vector3 FindClosestPathTile(Vector3Int keyItemPosition)
    {
        Vector3 closestPathTile = Vector3.zero;
        float closestDistance = float.MaxValue;

        foreach (var path in allPaths)
        {
            foreach (var pathTile in path)
            {
                Vector3 pathTilePosition = new Vector3(pathTile.x, 0.5f, pathTile.z);  // Get path tile position
                float distance = Vector3.Distance(keyItemPosition, pathTilePosition);

                if (distance < closestDistance)
                {
                    closestDistance = distance;
                    closestPathTile = pathTilePosition;
                }
            }
        }

        return closestPathTile;
    }


    // Call this method when obstacles are placed to track their positions
    private void RegisterObstacle(Vector3Int position)
    {
        obstacleTiles.Add(position);
    }




    private IEnumerator FallToPosition(GameObject tile, Vector3 targetPosition)
    {
        float timeElapsed = 0f;
        Vector3 startPosition = tile.transform.position;
        float duration = totalFallTime / gridWidth;  // Adjust duration as necessary

        while (timeElapsed < duration)
        {
            timeElapsed += Time.deltaTime;
            tile.transform.position = Vector3.Lerp(startPosition, targetPosition, timeElapsed / duration);
            yield return null;
        }

        tile.transform.position = targetPosition;
    }

 
    private List> GenerateMultiplePaths(Vector3Int start, int pathCount)
    {
        List> allPaths = new List>();
        HashSet usedTiles = new HashSet();

        for (int i = 0; i < pathCount; i++)
        {
            Vector3Int newEndTile = SelectEndTile(start); // Get a new end tile
            HashSet newPath = GeneratePath(start, newEndTile);

            if (newPath.Count > 1)
            {
                allPaths.Add(newPath);
                usedTiles.UnionWith(newPath); // Mark path tiles as used
            }
            else
            {
                Debug.LogWarning($"Path {i + 1} was too short or invalid. Skipping...");
            }
        }

        return allPaths;
    }

}
              

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class WallVisibilityToggler : MonoBehaviour
{
    public GameObject cameraObject;  // Reference to the camera object instead of the camera component
    public float toggleDistance = 10f;  // Distance threshold for toggling wall visibility
    private List walls = new List();  // List to store all walls
    private float wallCheckInterval = 5.5f;  // Interval for updating the wall list
    private float nextWallCheckTime = 0f;  // Timer to track when to update walls
    private bool wallsPlaced = false;  // Track if walls are placed

    void Start()
    {
        StartCoroutine(WaitForWalls());
    }

    IEnumerator WaitForWalls()
    {
        TileManager tileManager = FindObjectOfType();  //  Get TileManager

        if (tileManager == null)
        {
            Debug.LogError("TileManager not found!");
            yield break;
        }

        yield return new WaitUntil(() => tileManager.AreWallsPlaced);  //  Wait for walls
        UpdateWallList();
        wallsPlaced = true;
        Debug.Log("WallVisibilityToggler started: Walls have been placed.");
    }

    void Update()
    {
        if (!wallsPlaced || cameraObject == null) return;  //  Ensure cameraObject is assigned and walls are placed

        // Periodically update the wall list (e.g., every 5.5 seconds)
        if (Time.time >= nextWallCheckTime)
        {
            UpdateWallList();
            nextWallCheckTime = Time.time + wallCheckInterval;
        }

        // Toggle wall visibility every frame
        ToggleWallsBasedOnDistance();
    }

    void UpdateWallList()
    {
        walls.Clear();
        foreach (Transform child in transform)
        {
            if (child.CompareTag("Wall"))
            {
                walls.Add(child.gameObject);
            }
        }
        Debug.Log($"Total Walls Detected: {walls.Count}");
    }

    void ToggleWallsBasedOnDistance()
    {
        int hiddenWallCount = 0;
        Vector3 cameraPosition = cameraObject.transform.position;  // Use camera object position

        foreach (GameObject wall in walls)
        {
            float distance = Vector3.Distance(cameraPosition, wall.transform.position);
            bool shouldBeVisible = distance >= toggleDistance;

            wall.SetActive(shouldBeVisible);

            if (!shouldBeVisible)
                hiddenWallCount++;
        }
        Debug.Log($"Hidden Walls: {hiddenWallCount}/{walls.Count}");
    }
}
              

                using System.Collections;
using UnityEngine;
using UnityEngine.SceneManagement;

public class TempWin : MonoBehaviour
{
    [Header("Scene Reset Settings")]
    public float resetDelay = 0.1f; // Exposed for easy tuning in Inspector

    private bool hasTriggered = false; // Prevent multiple triggers

    private void OnTriggerEnter(Collider other)
    {
        // Prevent multiple triggers
        if (hasTriggered) return;

        if (other.CompareTag("Player")) // Use "Player" with uppercase P (Unity default)
        {
            hasTriggered = true;
            Debug.Log("Player entered trigger. Resetting scene in " + resetDelay + " seconds...");
            StartCoroutine(ResetSceneAfterDelay(resetDelay));
        }
        else
        {
            Debug.Log($"Ignored trigger from: {other.name}");
        }
    }

    private IEnumerator ResetSceneAfterDelay(float delay)
    {
        yield return new WaitForSeconds(delay);
        SceneManager.LoadScene(SceneManager.GetActiveScene().name);
    }

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Y))
        {
            StartCoroutine(ResetSceneAfterDelay(resetDelay));
        }
    }

}