MazeWalkerTv/Assets/Scripts/MazeController.cs

using UnityEngine;

/// <summary>
/// Main controller for maze generation and management
/// </summary>
public class MazeController : MonoBehaviour
{
    [SerializeField] private MazeConfig mazeConfig = new();
    [SerializeField] private bool generateOnStart = true;
    [SerializeField] private bool visualizeDebug = true;

    [Header("Renderers")]
    [SerializeField] private MazeRenderer mazeRenderer;
    [SerializeField] private MeshMazeRenderer meshMazeRenderer;

    [Header("AI Agents")]
    [SerializeField] private bool spawnAIAgents = true;
    [SerializeField] private AIAgentManager agentManager;

    private MazeData currentMaze;
    private MazeGenerator generator;

    void Start()
    {
        if (mazeRenderer == null)
        {
            mazeRenderer = GetComponent<MazeRenderer>() ?? FindAnyObjectByType<MazeRenderer>();
        }
        if (meshMazeRenderer == null)
        {
            meshMazeRenderer = GetComponent<MeshMazeRenderer>() ?? FindAnyObjectByType<MeshMazeRenderer>();
        }

        // Setup AI agent manager
        if (spawnAIAgents)
        {
            if (agentManager == null)
            {
                agentManager = GetComponent<AIAgentManager>();
            }
            if (agentManager == null)
            {
                // Create agent manager if not already present
                GameObject managerGO = new GameObject("AIAgentManager");
                managerGO.transform.parent = transform;
                agentManager = managerGO.AddComponent<AIAgentManager>();
            }
        }

        if (generateOnStart)
        {
            GenerateMaze();
        }
    }

    /// <summary>
    /// Generates a new maze using the current configuration
    /// </summary>
    public void GenerateMaze()
    {
        Debug.Log("Generating maze...");
        generator = new MazeGenerator(mazeConfig);
        currentMaze = generator.Generate();

        if (visualizeDebug)
        {
            VisualizeMaze();
        }

        if (mazeRenderer != null)
        {
            mazeRenderer.RenderMaze();
        }

        if (meshMazeRenderer != null)
        {
            meshMazeRenderer.RefreshMesh();
        }

        // Reset AI agents for new maze
        if (spawnAIAgents && agentManager != null)
        {
            agentManager.ResetForNewMaze();
        }
    }

    /// <summary>
    /// Visualizes the maze in the editor/game for debugging
    /// </summary>
    private void VisualizeMaze()
    {
        if (currentMaze == null) return;

        // Draw grid visualization in Scene view
        for (int x = 0; x < currentMaze.Width; x += 10)
        {
            Debug.DrawLine(new Vector3(x, 0, 0), new Vector3(x, currentMaze.Height, 0), Color.gray);
        }
        for (int y = 0; y < currentMaze.Height; y += 10)
        {
            Debug.DrawLine(new Vector3(0, y, 0), new Vector3(currentMaze.Width, y, 0), Color.gray);
        }

        // Highlight start and exit points
        foreach (var start in currentMaze.StartPoints)
        {
            Debug.DrawLine(new Vector3(start.x - 0.5f, start.y - 0.5f, 0),
                          new Vector3(start.x + 0.5f, start.y + 0.5f, 0), Color.green);
        }

        foreach (var exit in currentMaze.ExitPoints)
        {
            Debug.DrawLine(new Vector3(exit.x - 0.5f, exit.y - 0.5f, 0),
                          new Vector3(exit.x + 0.5f, exit.y + 0.5f, 0), Color.red);
        }
    }

    /// <summary>
    /// Gets the current maze data
    /// </summary>
    public MazeData GetCurrentMaze()
    {
        return currentMaze;
    }

    /// <summary>
    /// Sets the current maze data (used by async generators)
    /// </summary>
    public void SetCurrentMaze(MazeData maze)
    {
        currentMaze = maze;

        if (visualizeDebug)
        {
            VisualizeMaze();
        }

        // Render the maze using available renderers
        var renderer = GetComponent<MazeRenderer>();
        if (renderer != null)
        {
            renderer.RenderMaze();
        }

        var meshRenderer = GetComponent<MeshMazeRenderer>();
        if (meshRenderer != null)
        {
            meshRenderer.RefreshMesh();
        }

        // Reset AI agents for new maze
        if (spawnAIAgents && agentManager != null)
        {
            agentManager.ResetForNewMaze();
        }
    }

    /// <summary>
    /// Gets the current maze configuration
    /// </summary>
    public MazeConfig GetConfig()
    {
        return mazeConfig;
    }

    /// <summary>
    /// Gets a tile at specific coordinates
    /// </summary>
    public MazeTile GetTile(int x, int y)
    {
        return currentMaze?.GetTile(x, y);
    }

    /// <summary>
    /// Checks if a position is walkable
    /// </summary>
    public bool IsWalkable(int x, int y)
    {
        return currentMaze?.IsWalkable(x, y) ?? false;
    }

    /// <summary>
    /// Gets the room at a specific tile position
    /// </summary>
    public MazeRoom GetRoomAtTile(int x, int y)
    {
        return currentMaze?.GetRoomAtTile(x, y);
    }

    /// <summary>
    /// Gets all start points
    /// </summary>
    public System.Collections.Generic.List<Vector2Int> GetStartPoints()
    {
        return currentMaze?.StartPoints ?? new();
    }

    /// <summary>
    /// Gets all exit points
    /// </summary>
    public System.Collections.Generic.List<Vector2Int> GetExitPoints()
    {
        return currentMaze?.ExitPoints ?? new();
    }

    /// <summary>
    /// Gets the AI agent manager
    /// </summary>
    public AIAgentManager GetAgentManager()
    {
        return agentManager;
    }

    void Update()
    {
        // Can be used for real-time generation or maze editing later
    }
}