Okay, let's start building the foundation for your 2D maze survival game. We'll begin with the core mechanics like maze generation, player movement, and the fog of war effect. using UnityEngine; using System.Collections.Generic; using MazeSurvival.Maze; using MazeSurvival.Player; // Assuming PlayerController is in this namespace namespace MazeSurvival.Core { public class GameManager : MonoBehaviour { public static GameManager Instance { get; private set; } [Header("Maze Settings")] [SerializeField] private MazeGenerator mazeGenerator; [SerializeField] private int mazeWidth = 21; // Odd numbers work best for some algorithms [SerializeField] private int mazeHeight = 21; [SerializeField] private Tile tilePrefab; // Prefab for visual tiles [SerializeField] private Transform mazeParent; // Parent object for maze tiles [Header("Player Settings")] [SerializeField] private PlayerController playerPrefab; // Prefab for the player [SerializeField] private FogOfWar playerFogOfWarPrefab; // Prefab for the fog of war visual private Tile[,] grid; private List players = new List(); // For multiplayer later private PlayerController localPlayer; // Reference to the local player instance private void Awake() { if (Instance == null) { Instance = this; // DontDestroyOnLoad(gameObject); // Consider if needed for scene transitions } else { Destroy(gameObject); return; } if (mazeGenerator == null) { Debug.LogError("MazeGenerator reference is missing in GameManager!"); enabled = false; return; } if (tilePrefab == null) { Debug.LogError("Tile Prefab reference is missing in GameManager!"); enabled = false; return; } if (playerPrefab == null) { Debug.LogError("Player Prefab reference is missing in GameManager!"); enabled = false; return; } if (playerFogOfWarPrefab == null) { Debug.LogError("FogOfWar Prefab reference is missing in GameManager!"); enabled = false; return; } } private void Start() { GenerateNewMaze(); SpawnPlayer(); // In a real multiplayer scenario, this would be handled by the network manager } public void GenerateNewMaze() { // Clear existing maze if any if (grid != null) { foreach (Transform child in mazeParent) { Destroy(child.gameObject); } } // Generate maze data MazeCell[,] mazeData = mazeGenerator.GenerateMaze(mazeWidth, mazeHeight); // Instantiate visual tiles based on maze data grid = new Tile[mazeWidth, mazeHeight]; Vector3 centerOffset = new Vector3(-mazeWidth / 2f + 0.5f, -mazeHeight / 2f + 0.5f, 0); // Center the maze for (int x = 0; x < mazeWidth; x++) { for (int y = 0; y < mazeHeight; y++) { Vector3 position = new Vector3(x, y, 0) + centerOffset; Tile newTile = Instantiate(tilePrefab, position, Quaternion.identity, mazeParent); newTile.Initialize(mazeData[x, y].Type, x, y); grid[x, y] = newTile; newTile.SetVisible(false); // Initially hide all tiles } } // TODO: Place traps, capture zone, teleport points based on mazeData or separate logic } private void SpawnPlayer() { // Find a valid starting position (e.g., the first floor tile) Vector2Int startPos = FindStartPosition(); if (startPos == new Vector2Int(-1, -1)) { Debug.LogError("Could not find a valid start position in the maze!"); return; } Vector3 spawnWorldPos = GetWorldPosition(startPos.x, startPos.y); localPlayer = Instantiate(playerPrefab, spawnWorldPos, Quaternion.identity); players.Add(localPlayer); // Add to list (for future multiplayer) // Attach Fog of War visual to the player FogOfWar fog = Instantiate(playerFogOfWarPrefab, localPlayer.transform); fog.Initialize(this, localPlayer); // Pass references localPlayer.AssignFogOfWar(fog); // Let player know about its fog controller // Initial fog update fog.UpdateFog(startPos.x, startPos.y); } private Vector2Int FindStartPosition() { for (int x = 0; x < mazeWidth; x++) { for (int y = 0; y < mazeHeight; y++) { if (grid[x, y].Type == TileType.Floor) { return new Vector2Int(x, y); } } } return new Vector2Int(-1, -1); // Indicate failure } public Tile GetTile(int x, int y) { if (x >= 0 && x < mazeWidth && y >= 0 && y < mazeHeight) { return grid[x, y]; } return null; // Out of bounds } public Vector3 GetWorldPosition(int x, int y) { Vector3 centerOffset = new Vector3(-mazeWidth / 2f + 0.5f, -mazeHeight / 2f + 0.5f, 0); return new Vector3(x, y, 0) + centerOffset; } public Vector2Int GetGridPosition(Vector3 worldPosition) { Vector3 centerOffset = new Vector3(-mazeWidth / 2f + 0.5f, -mazeHeight / 2f + 0.5f, 0); Vector3 gridPosFloat = worldPosition - centerOffset; return new Vector2Int(Mathf.RoundToInt(gridPosFloat.x), Mathf.RoundToInt(gridPosFloat.y)); } // Called when a player wins (placeholder) public void OnPlayerWin(PlayerController winner) { Debug.Log($"Player {winner.name} wins!"); // Replace with actual player ID later // TODO: Update Leaderboard // TODO: Trigger maze regeneration for the next round GenerateNewMaze(); // TODO: Reset player positions (or handle respawn logic via network) if (localPlayer != null) { Vector2Int startPos = FindStartPosition(); if (startPos != new Vector2Int(-1, -1)) { localPlayer.transform.position = GetWorldPosition(startPos.x, startPos.y); localPlayer.ForceFogUpdate(); // Update fog after teleporting } } } // Placeholder for capture zone logic public void PlayerEnteredCaptureZone(PlayerController player) { Debug.Log($"Player {player.name} entered capture zone."); // TODO: Start capture timer // TODO: Check for other players in the zone -> Trigger Battle } public void PlayerExitedCaptureZone(PlayerController player) { Debug.Log($"Player {player.name} exited capture zone."); // TODO: Stop capture timer } // Placeholder for battle logic public void InitiateBattle(PlayerController player1, PlayerController player2) { Debug.Log($"Battle initiated between {player1.name} and {player2.name}!"); // TODO: Implement battle resolution mechanic // Player winner = DetermineBattleWinner(player1, player2); // HandleBattleOutcome(winner, loser); } } } using UnityEngine; using System.Collections.Generic; namespace MazeSurvival.Maze { // Represents the type of a cell in the maze data public enum MazeCellType { Wall, Floor, Start, End, Trap, Teleporter, CaptureZone } // Holds data for a single cell during generation public class MazeCell { public int X, Y; public MazeCellType Type = MazeCellType.Wall; // Default to wall public bool Visited = false; // For generation algorithm (Recursive Backtracker) public bool WallLeft = true; public bool WallBottom = true; public MazeCell(int x, int y) { X = x; Y = y; } } public class MazeGenerator : MonoBehaviour { // Basic Recursive Backtracker implementation public MazeCell[,] GenerateMaze(int width, int height) { if (width % 2 == 0 || height % 2 == 0) { Debug.LogWarning("Maze dimensions should ideally be odd numbers for standard Recursive Backtracker."); // Adjust or handle even dimensions if necessary } MazeCell[,] maze = new MazeCell[width, height]; // Initialize grid for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { maze[x, y] = new MazeCell(x, y); // Make cells at even coordinates potential floors for the algorithm structure if (x % 2 != 0 && y % 2 != 0) { maze[x,y].Type = MazeCellType.Floor; // Mark as potential path initially } } } Stack stack = new Stack(); System.Random random = new System.Random(); // Start carving from a central odd-coordinate point int startX = 1; //(width / 2) | 1; // Force odd int startY = 1; //(height / 2) | 1; // Force odd MazeCell startCell = maze[startX, startY]; startCell.Visited = true; startCell.Type = MazeCellType.Floor; // Ensure start is floor stack.Push(startCell); while (stack.Count > 0) { MazeCell current = stack.Peek(); List neighbours = GetUnvisitedNeighbours(current, maze, width, height); if (neighbours.Count > 0) { MazeCell chosen = neighbours[random.Next(neighbours.Count)]; RemoveWall(current, chosen, maze); chosen.Visited = true; chosen.Type = MazeCellType.Floor; // Carved path is floor stack.Push(chosen); } else { stack.Pop(); } } // Post-processing: Assign specific types (optional here, can be done in GameManager) // maze[startX, startY].Type = MazeCellType.Start; // Add logic to place End, Traps, Teleporters, CaptureZone based on rules return maze; } private List GetUnvisitedNeighbours(MazeCell cell, MazeCell[,] maze, int width, int height) { List neighbours = new List(); int[,] directions = { { 0, 2 }, { 2, 0 }, { 0, -2 }, { -2, 0 } }; // Check cells 2 units away for(int i = 0; i < directions.GetLength(0); i++) { int nx = cell.X + directions[i, 0]; int ny = cell.Y + directions[i, 1]; if (nx >= 0 && nx < width && ny >= 0 && ny < height) { MazeCell neighbour = maze[nx, ny]; // Check if it's a potential floor cell and hasn't been visited if (!neighbour.Visited && neighbour.Type == MazeCellType.Floor) { neighbours.Add(neighbour); } } } return neighbours; } private void RemoveWall(MazeCell current, MazeCell chosen, MazeCell[,] maze) { int dx = chosen.X - current.X; int dy = chosen.Y - current.Y; int wallX = current.X + (dx / 2); int wallY = current.Y + (dy / 2); maze[wallX, wallY].Type = MazeCellType.Floor; // Remove the wall between them // Update wall flags (less critical if using Type directly, but good for some visualizers) if (dx > 0) // Moved Right { current.WallLeft = false; // Wall to the right of 'current' removed (conceptually) // chosen.WallLeft = false; // Wall to the left of 'chosen' removed } else if (dx < 0) // Moved Left { chosen.WallLeft = false; // Wall to the right of 'chosen' removed // current.WallLeft = false; // Wall to the left of 'current' removed } else if (dy > 0) // Moved Up { current.WallBottom = false; // Wall above 'current' removed // chosen.WallBottom = false; // Wall below 'chosen' removed } else if (dy < 0) // Moved Down { chosen.WallBottom = false; // Wall above 'chosen' removed // current.WallBottom = false; // Wall below 'current' removed } } } } using UnityEngine; namespace MazeSurvival.Maze { // Matches MazeCellType but for the instantiated Tile component public enum TileType { Wall, Floor, Trap, Teleporter, CaptureZone } public class Tile : MonoBehaviour { [SerializeField] private SpriteRenderer spriteRenderer; [SerializeField] private Color wallColor = Color.grey; [SerializeField] private Color floorColor = Color.white; [SerializeField] private Color trapColor = Color.red; [SerializeField] private Color teleporterColor = Color.blue; [SerializeField] private Color captureZoneColor = Color.green; [SerializeField] private Color hiddenColor = Color.black; public TileType Type { get; private set; } public int X { get; private set; } public int Y { get; private set; } public bool IsVisible { get; private set; } = false; public bool IsWalkable => Type == TileType.Floor || Type == TileType.Trap || Type == TileType.Teleporter || Type == TileType.CaptureZone; private void Awake() { if (spriteRenderer == null) { spriteRenderer = GetComponentInChildren(); if (spriteRenderer == null) { Debug.LogError("Tile needs a SpriteRenderer component in its children or on itself.", this); enabled = false; } } } public void Initialize(MazeCellType cellType, int x, int y) { X = x; Y = y; // Convert MazeCellType to TileType switch (cellType) { case MazeCellType.Wall: Type = TileType.Wall; break; case MazeCellType.Floor: Type = TileType.Floor; break; case MazeCellType.Start: Type = TileType.Floor; break; // Start is just floor visually case MazeCellType.End: Type = TileType.Floor; break; // End might be CaptureZone later case MazeCellType.Trap: Type = TileType.Trap; break; case MazeCellType.Teleporter: Type = TileType.Teleporter; break; case MazeCellType.CaptureZone: Type = TileType.CaptureZone; break; default: Type = TileType.Wall; break; // Default safety } SetVisible(false); // Start hidden } public void SetVisible(bool visible) { IsVisible = visible; if (visible) { switch (Type) { case TileType.Wall: spriteRenderer.color = wallColor; break; case TileType.Floor: spriteRenderer.color = floorColor; break; case TileType.Trap: spriteRenderer.color = trapColor; break; case TileType.Teleporter: spriteRenderer.color = teleporterColor; break; case TileType.CaptureZone: spriteRenderer.color = captureZoneColor; break; default: spriteRenderer.color = hiddenColor; break; } } else { spriteRenderer.color = hiddenColor; } } // TODO: Add interaction logic (OnTriggerEnter for traps, teleporters, capture zone) } } using UnityEngine; using MazeSurvival.Core; using MazeSurvival.Maze; namespace MazeSurvival.Player { public class PlayerController : MonoBehaviour { [SerializeField] private float moveSpeed = 5f; // Units per second [SerializeField] private float moveCooldown = 0.15f; // Prevent instant multi-moves private Vector2Int currentGridPos; private Vector3 targetPosition; private bool isMoving = false; private float lastMoveTime = -1f; private FogOfWar fogOfWar; // Reference set by GameManager private void Start() { // Initial position is set by GameManager during spawn targetPosition = transform.position; currentGridPos = GameManager.Instance.GetGridPosition(transform.position); } public void AssignFogOfWar(FogOfWar fog) { fogOfWar = fog; } void Update() { HandleMovementInput(); MoveTowardsTarget(); } void HandleMovementInput() { if (isMoving || Time.time < lastMoveTime + moveCooldown) return; // Don't accept input while moving or on cooldown int horizontalInput = Mathf.RoundToInt(Input.GetAxisRaw("Horizontal")); int verticalInput = Mathf.RoundToInt(Input.GetAxisRaw("Vertical")); // Prioritize horizontal movement if both inputs are pressed Vector2Int desiredMove = Vector2Int.zero; if (horizontalInput != 0) { desiredMove = new Vector2Int(horizontalInput, 0); } else if (verticalInput != 0) { desiredMove = new Vector2Int(0, verticalInput); } if (desiredMove != Vector2Int.zero) { TryMove(desiredMove); } } void TryMove(Vector2Int direction) { Vector2Int targetGridPos = currentGridPos + direction; Tile targetTile = GameManager.Instance.GetTile(targetGridPos.x, targetGridPos.y); if (targetTile != null && targetTile.IsWalkable) { currentGridPos = targetGridPos; targetPosition = GameManager.Instance.GetWorldPosition(currentGridPos.x, currentGridPos.y); isMoving = true; lastMoveTime = Time.time; // Update Fog of War after confirming move if (fogOfWar != null) { fogOfWar.UpdateFog(currentGridPos.x, currentGridPos.y); } // Check for special tile types upon *arrival* (or use triggers) CheckTileInteraction(targetTile); } // Optional: Add sound effect for hitting a wall } void MoveTowardsTarget() { if (!isMoving) return; transform.position = Vector3.MoveTowards(transform.position, targetPosition, moveSpeed * Time.deltaTime); if (Vector3.Distance(transform.position, targetPosition) < 0.01f) { transform.position = targetPosition; // Snap to exact position isMoving = false; } } void CheckTileInteraction(Tile currentTile) { // This could also be handled via Trigger Colliders on the Tiles switch(currentTile.Type) { case TileType.Trap: Debug.Log("Stepped on a Trap!"); // TODO: Implement trap effect (damage, stun, etc.) - Network sync needed break; case TileType.Teleporter: Debug.Log("Stepped on a Teleporter!"); // TODO: Implement teleport logic (find destination, move player) - Network sync needed break; case TileType.CaptureZone: GameManager.Instance.PlayerEnteredCaptureZone(this); // Note: Need PlayerExitedCaptureZone logic too, perhaps via OnTriggerExit or checking tile type every frame/move break; } } // Called by GameManager after maze regeneration/reset public void ForceFogUpdate() { currentGridPos = GameManager.Instance.GetGridPosition(transform.position); if (fogOfWar != null) { fogOfWar.UpdateFog(currentGridPos.x, currentGridPos.y); } } // TODO: Add health, battle stats, network identity, etc. } } using UnityEngine; using MazeSurvival.Core; using MazeSurvival.Maze; using System.Collections.Generic; namespace MazeSurvival.Player { // This component lives on the player and tells the GameManager which tiles should be visible public class FogOfWar : MonoBehaviour { [SerializeField] private int viewDistance = 2; // How many tiles away are visible private GameManager gameManager; private PlayerController owner; // The player this fog belongs to private HashSet previouslyVisibleTiles = new HashSet(); public void Initialize(GameManager manager, PlayerController player) { gameManager = manager; owner = player; } // Call this when the player moves to a new tile public void UpdateFog(int playerX, int playerY) { if (gameManager == null) return; HashSet currentlyVisibleTiles = new HashSet(); // Iterate through a square area around the player for (int x = playerX - viewDistance; x <= playerX + viewDistance; x++) { for (int y = playerY - viewDistance; y <= playerY + viewDistance; y++) { // Optional: Use Manhattan distance for a diamond shape // if (Mathf.Abs(x - playerX) + Mathf.Abs(y - playerY) > viewDistance) continue; Tile tile = gameManager.GetTile(x, y); if (tile != null) { // Basic visibility: just reveal tiles within range // TODO: Implement Line of Sight (LOS) check if walls should block vision tile.SetVisible(true); currentlyVisibleTiles.Add(tile); } } } // Hide tiles that are no longer visible foreach (Tile tile in previouslyVisibleTiles) { if (!currentlyVisibleTiles.Contains(tile)) { tile.SetVisible(false); } } // Update the set of previously visible tiles previouslyVisibleTiles = currentlyVisibleTiles; } // Optional: Implement Line of Sight (Raycasting or Bresenham's Line Algorithm) // bool HasLineOfSight(int startX, int startY, int endX, int endY) { ... } } } **Next Steps & Considerations:** 1. **Unity Setup:** * Create the prefabs mentioned (`TilePrefab`, `PlayerPrefab`, `FogOfWarPrefab`). * `TilePrefab`: Add a `SpriteRenderer` and the `Tile.cs` script. Assign colors in the Inspector. Add a `BoxCollider2D` if you plan to use physics triggers for interactions. * `PlayerPrefab`: Add a `SpriteRenderer`, the `PlayerController.cs` script, and potentially a `Rigidbody2D` (set to Kinematic if using transform movement) and `Collider2D`. * `FogOfWarPrefab`: This can be an empty GameObject with just the `FogOfWar.cs` script attached. It will be instantiated as a child of the player. * Create a `GameManager` GameObject in your scene, attach `GameManager.cs` and `MazeGenerator.cs`. * Assign the prefabs and create a `MazeParent` empty GameObject in the scene, then assign references in the `GameManager` Inspector. 2. **Multiplayer Integration:** This is a major step. You'll need to choose a networking solution (like Netcode for GameObjects or Mirror), implement network identities, synchronize player movement, game state, maze generation seeds, trap activations, battle outcomes, etc. 3. **Detailed Mechanics:** Flesh out traps, teleportation (linking pairs of points), the capture zone timer, and the battle system. 4. **UI:** Implement the main menu, leaderboard display, and in-game HUD elements. 5. **Refinement:** Add animations, sound effects, visual polish, and potentially more complex maze generation or Line of Sight for the fog of war. This initial setup provides the core single-player structure upon which the more complex features can be built.