573 lines
21 KiB
C#
573 lines
21 KiB
C#
|
using System.Collections.Generic;
|
||
|
|
using UnityEngine;
|
||
|
|
using System.Linq;
|
||
|
|
|
||
|
|
public class MapGenManager : MonoBehaviour
|
||
|
|
{
|
||
|
|
[Header("Room Prefabs")]
|
||
|
|
[SerializeField] private List<GameObject> mapPrefab = new List<GameObject>();
|
||
|
|
[SerializeField] private GameObject StartPoint;
|
||
|
|
[SerializeField] private GameObject EndPoint;
|
||
|
|
|
||
|
|
[Header("Player")]
|
||
|
|
[SerializeField] private GameObject Player;
|
||
|
|
|
||
|
|
[Header("Corridor Prefabs")]
|
||
|
|
[SerializeField] private GameObject CorridorStraight;
|
||
|
|
[SerializeField] private GameObject CorridorL;
|
||
|
|
[SerializeField] private GameObject CorridorT;
|
||
|
|
[SerializeField] private GameObject CorridorCross;
|
||
|
|
[SerializeField] private GameObject CorridorEnd;
|
||
|
|
|
||
|
|
[Header("Generation Settings")]
|
||
|
|
[SerializeField] private float minRoomDistance = 30f;
|
||
|
|
[SerializeField] private float maxRoomDistance = 50f;
|
||
|
|
[SerializeField] private float corridorWidth = 5f;
|
||
|
|
|
||
|
|
private List<Vector3> roomPositions = new List<Vector3>();
|
||
|
|
private List<GameObject> placedRooms = new List<GameObject>();
|
||
|
|
|
||
|
|
void Start()
|
||
|
|
{
|
||
|
|
MapGen();
|
||
|
|
}
|
||
|
|
|
||
|
|
private void MapGen()
|
||
|
|
{
|
||
|
|
roomPositions.Clear();
|
||
|
|
placedRooms.Clear();
|
||
|
|
|
||
|
|
// Start position should be aligned to grid
|
||
|
|
Vector3 startPos = new Vector3(0, 0, 0); // Grid aligned at origin
|
||
|
|
GameObject startPoint = Instantiate(StartPoint, startPos, Quaternion.identity, transform);
|
||
|
|
roomPositions.Add(startPos);
|
||
|
|
placedRooms.Add(startPoint);
|
||
|
|
|
||
|
|
GameObject player = Instantiate(Player, new Vector3(startPos.x, 1, startPos.z), Quaternion.identity, transform);
|
||
|
|
|
||
|
|
int roomCount = Random.Range(3, 7);
|
||
|
|
|
||
|
|
for (int i = 0; i < roomCount; i++)
|
||
|
|
{
|
||
|
|
Vector3 roomPos = GetRandomGridPosition();
|
||
|
|
GameObject roomPrefab = mapPrefab[Random.Range(0, mapPrefab.Count)];
|
||
|
|
GameObject room = Instantiate(roomPrefab, roomPos, Quaternion.identity, transform);
|
||
|
|
placedRooms.Add(room);
|
||
|
|
roomPositions.Add(roomPos);
|
||
|
|
}
|
||
|
|
|
||
|
|
GameObject endPoint = Instantiate(EndPoint, GetRandomGridPosition(), Quaternion.identity, transform);
|
||
|
|
roomPositions.Add(endPoint.transform.position);
|
||
|
|
placedRooms.Add(endPoint);
|
||
|
|
|
||
|
|
// Generate corridors to connect rooms
|
||
|
|
GenerateCorridors();
|
||
|
|
|
||
|
|
// Add some dead ends for more dynamic layouts
|
||
|
|
AddDeadEndCorridors();
|
||
|
|
}
|
||
|
|
|
||
|
|
private void GenerateCorridors()
|
||
|
|
{
|
||
|
|
// Create a minimum spanning tree to ensure all rooms are connected
|
||
|
|
List<(int, int)> edges = CreateMinimumSpanningTree();
|
||
|
|
|
||
|
|
// Place corridors between connected rooms
|
||
|
|
foreach (var edge in edges)
|
||
|
|
{
|
||
|
|
ConnectRoomsWithCorridor(roomPositions[edge.Item1], roomPositions[edge.Item2]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private List<(int, int)> CreateMinimumSpanningTree()
|
||
|
|
{
|
||
|
|
// Using Prim's algorithm to generate a minimum spanning tree
|
||
|
|
List<(int, int)> mstEdges = new List<(int, int)>();
|
||
|
|
List<int> connectedNodes = new List<int>();
|
||
|
|
List<int> unconnectedNodes = new List<int>();
|
||
|
|
|
||
|
|
// Start with node 0 (start room)
|
||
|
|
for (int i = 0; i < roomPositions.Count; i++)
|
||
|
|
{
|
||
|
|
unconnectedNodes.Add(i);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Start with first node
|
||
|
|
connectedNodes.Add(unconnectedNodes[0]);
|
||
|
|
unconnectedNodes.RemoveAt(0);
|
||
|
|
|
||
|
|
// Continue until all nodes are connected
|
||
|
|
while (unconnectedNodes.Count > 0)
|
||
|
|
{
|
||
|
|
float minDistance = float.MaxValue;
|
||
|
|
int closestConnected = -1;
|
||
|
|
int closestUnconnected = -1;
|
||
|
|
|
||
|
|
// Find shortest edge between a connected and unconnected node
|
||
|
|
foreach (int connected in connectedNodes)
|
||
|
|
{
|
||
|
|
foreach (int unconnected in unconnectedNodes)
|
||
|
|
{
|
||
|
|
float distance = Vector3.Distance(roomPositions[connected], roomPositions[unconnected]);
|
||
|
|
if (distance < minDistance)
|
||
|
|
{
|
||
|
|
minDistance = distance;
|
||
|
|
closestConnected = connected;
|
||
|
|
closestUnconnected = unconnected;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Add the edge to our MST
|
||
|
|
mstEdges.Add((closestConnected, closestUnconnected));
|
||
|
|
|
||
|
|
// Move the node from unconnected to connected
|
||
|
|
connectedNodes.Add(closestUnconnected);
|
||
|
|
unconnectedNodes.Remove(closestUnconnected);
|
||
|
|
}
|
||
|
|
|
||
|
|
return mstEdges;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void ConnectRoomsWithCorridor(Vector3 startRoom, Vector3 endRoom)
|
||
|
|
{
|
||
|
|
// Calculate the grid-based path between rooms
|
||
|
|
List<Vector3> path = CalculateGridPath(startRoom, endRoom);
|
||
|
|
|
||
|
|
// Place corridor pieces along the path
|
||
|
|
for (int i = 0; i < path.Count - 1; i++)
|
||
|
|
{
|
||
|
|
PlaceCorridorSegment(path[i], path[i + 1]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private List<Vector3> CalculateGridPath(Vector3 start, Vector3 end)
|
||
|
|
{
|
||
|
|
List<Vector3> path = new List<Vector3>();
|
||
|
|
path.Add(start);
|
||
|
|
|
||
|
|
// Determine if we go horizontal first or vertical first (50/50 chance)
|
||
|
|
bool horizontalFirst = Random.value < 0.5f;
|
||
|
|
|
||
|
|
Vector3 current = start;
|
||
|
|
|
||
|
|
if (horizontalFirst)
|
||
|
|
{
|
||
|
|
// Move horizontally first, then vertically
|
||
|
|
while (Mathf.Abs(current.x - end.x) >= 5)
|
||
|
|
{
|
||
|
|
float step = current.x < end.x ? 5 : -5;
|
||
|
|
current = new Vector3(current.x + step, 0, current.z);
|
||
|
|
path.Add(current);
|
||
|
|
}
|
||
|
|
|
||
|
|
while (Mathf.Abs(current.z - end.z) >= 5)
|
||
|
|
{
|
||
|
|
float step = current.z < end.z ? 5 : -5;
|
||
|
|
current = new Vector3(current.x, 0, current.z + step);
|
||
|
|
path.Add(current);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Move vertically first, then horizontally
|
||
|
|
while (Mathf.Abs(current.z - end.z) >= 5)
|
||
|
|
{
|
||
|
|
float step = current.z < end.z ? 5 : -5;
|
||
|
|
current = new Vector3(current.x, 0, current.z + step);
|
||
|
|
path.Add(current);
|
||
|
|
}
|
||
|
|
|
||
|
|
while (Mathf.Abs(current.x - end.x) >= 5)
|
||
|
|
{
|
||
|
|
float step = current.x < end.x ? 5 : -5;
|
||
|
|
current = new Vector3(current.x + step, 0, current.z);
|
||
|
|
path.Add(current);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Add the end position if it's not already there
|
||
|
|
if (Vector3.Distance(current, end) >= 5)
|
||
|
|
{
|
||
|
|
path.Add(end);
|
||
|
|
}
|
||
|
|
|
||
|
|
return path;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void PlaceCorridorSegment(Vector3 start, Vector3 end)
|
||
|
|
{
|
||
|
|
// Determine corridor type based on connecting rooms
|
||
|
|
Vector3 direction = end - start;
|
||
|
|
GameObject corridorPrefab = CorridorStraight; // Default to straight
|
||
|
|
Quaternion rotation = Quaternion.identity;
|
||
|
|
Vector3 position = (start + end) / 2;
|
||
|
|
|
||
|
|
// Calculate direction for rotation
|
||
|
|
if (direction.x > 0) // East
|
||
|
|
{
|
||
|
|
rotation = Quaternion.Euler(0, 90, 0);
|
||
|
|
}
|
||
|
|
else if (direction.x < 0) // West
|
||
|
|
{
|
||
|
|
rotation = Quaternion.Euler(0, 90, 0);
|
||
|
|
}
|
||
|
|
else if (direction.z > 0) // North
|
||
|
|
{
|
||
|
|
rotation = Quaternion.Euler(0, 0, 0);
|
||
|
|
}
|
||
|
|
else if (direction.z < 0) // South
|
||
|
|
{
|
||
|
|
rotation = Quaternion.Euler(0, 0, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check if this segment is part of a turn, T-junction, or crossing
|
||
|
|
List<Direction> connectingDirections = GetConnectingDirections(end);
|
||
|
|
|
||
|
|
// Determine corridor type and rotation based on connections
|
||
|
|
if (connectingDirections.Count == 1) // Straight corridor or dead end
|
||
|
|
{
|
||
|
|
corridorPrefab = CorridorStraight;
|
||
|
|
}
|
||
|
|
else if (connectingDirections.Count == 2)
|
||
|
|
{
|
||
|
|
// Check if it's an L-turn
|
||
|
|
if (IsLTurn(direction, connectingDirections))
|
||
|
|
{
|
||
|
|
corridorPrefab = CorridorL;
|
||
|
|
// Adjust rotation for L-turn
|
||
|
|
rotation = GetLTurnRotation(direction, connectingDirections);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (connectingDirections.Count == 3) // T-junction
|
||
|
|
{
|
||
|
|
corridorPrefab = CorridorT;
|
||
|
|
// Adjust rotation for T-junction
|
||
|
|
rotation = GetTJunctionRotation(direction, connectingDirections);
|
||
|
|
}
|
||
|
|
else if (connectingDirections.Count >= 4) // Cross junction
|
||
|
|
{
|
||
|
|
corridorPrefab = CorridorCross;
|
||
|
|
}
|
||
|
|
|
||
|
|
Instantiate(corridorPrefab, position, rotation, transform);
|
||
|
|
}
|
||
|
|
|
||
|
|
private enum Direction { North, East, South, West }
|
||
|
|
|
||
|
|
private List<Direction> GetConnectingDirections(Vector3 position)
|
||
|
|
{
|
||
|
|
// Check which directions have corridors or rooms from this position
|
||
|
|
List<Direction> connections = new List<Direction>();
|
||
|
|
|
||
|
|
// Check in each cardinal direction
|
||
|
|
Vector3[] offsets = new Vector3[] {
|
||
|
|
new Vector3(0, 0, 5), // North
|
||
|
|
new Vector3(5, 0, 0), // East
|
||
|
|
new Vector3(0, 0, -5), // South
|
||
|
|
new Vector3(-5, 0, 0) // West
|
||
|
|
};
|
||
|
|
|
||
|
|
Direction[] directions = new Direction[] {
|
||
|
|
Direction.North,
|
||
|
|
Direction.East,
|
||
|
|
Direction.South,
|
||
|
|
Direction.West
|
||
|
|
};
|
||
|
|
|
||
|
|
for (int i = 0; i < offsets.Length; i++)
|
||
|
|
{
|
||
|
|
Vector3 checkPos = position + offsets[i];
|
||
|
|
|
||
|
|
// Check if there's a room at this position
|
||
|
|
bool hasConnection = roomPositions.Any(rp => Vector3.Distance(rp, checkPos) < 2.5f);
|
||
|
|
|
||
|
|
// If no room, check for corridor (simplified - in a full implementation,
|
||
|
|
// you'd track placed corridors separately)
|
||
|
|
if (!hasConnection)
|
||
|
|
{
|
||
|
|
// For simplicity, assume there's a corridor if it's part of a path we've calculated
|
||
|
|
// In a complete implementation, you'd track corridor positions
|
||
|
|
}
|
||
|
|
|
||
|
|
if (hasConnection)
|
||
|
|
{
|
||
|
|
connections.Add(directions[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return connections;
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool IsLTurn(Vector3 incomingDirection, List<Direction> connections)
|
||
|
|
{
|
||
|
|
// Check if connections form an L shape (90-degree turn)
|
||
|
|
if (connections.Count != 2) return false;
|
||
|
|
|
||
|
|
Direction incoming = VectorToDirection(incomingDirection);
|
||
|
|
Direction opposite = GetOppositeDirection(incoming);
|
||
|
|
|
||
|
|
// If one of the connections is opposite to the incoming direction,
|
||
|
|
// then it's a straight corridor, not an L-turn
|
||
|
|
return !connections.Contains(opposite);
|
||
|
|
}
|
||
|
|
|
||
|
|
private Direction VectorToDirection(Vector3 vector)
|
||
|
|
{
|
||
|
|
if (vector.x > 0) return Direction.East;
|
||
|
|
if (vector.x < 0) return Direction.West;
|
||
|
|
if (vector.z > 0) return Direction.North;
|
||
|
|
return Direction.South;
|
||
|
|
}
|
||
|
|
|
||
|
|
private Direction GetOppositeDirection(Direction dir)
|
||
|
|
{
|
||
|
|
switch (dir)
|
||
|
|
{
|
||
|
|
case Direction.North: return Direction.South;
|
||
|
|
case Direction.East: return Direction.West;
|
||
|
|
case Direction.South: return Direction.North;
|
||
|
|
case Direction.West: return Direction.East;
|
||
|
|
default: return Direction.North;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private Quaternion GetLTurnRotation(Vector3 incomingDirection, List<Direction> connections)
|
||
|
|
{
|
||
|
|
// Calculate rotation for L-turns based on the directions it connects
|
||
|
|
Direction incoming = VectorToDirection(incomingDirection);
|
||
|
|
|
||
|
|
// Find the other direction (not the incoming and not the opposite of incoming)
|
||
|
|
Direction other = connections.Find(d => d != incoming && d != GetOppositeDirection(incoming));
|
||
|
|
|
||
|
|
switch (incoming)
|
||
|
|
{
|
||
|
|
case Direction.North:
|
||
|
|
return other == Direction.East ? Quaternion.Euler(0, 0, 0) : Quaternion.Euler(0, 270, 0);
|
||
|
|
case Direction.East:
|
||
|
|
return other == Direction.North ? Quaternion.Euler(0, 90, 0) : Quaternion.Euler(0, 0, 0);
|
||
|
|
case Direction.South:
|
||
|
|
return other == Direction.East ? Quaternion.Euler(0, 270, 0) : Quaternion.Euler(0, 180, 0);
|
||
|
|
case Direction.West:
|
||
|
|
return other == Direction.North ? Quaternion.Euler(0, 180, 0) : Quaternion.Euler(0, 90, 0);
|
||
|
|
default:
|
||
|
|
return Quaternion.identity;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private Quaternion GetTJunctionRotation(Vector3 incomingDirection, List<Direction> connections)
|
||
|
|
{
|
||
|
|
// Calculate rotation for T-junctions
|
||
|
|
Direction incoming = VectorToDirection(incomingDirection);
|
||
|
|
Direction opposite = GetOppositeDirection(incoming);
|
||
|
|
|
||
|
|
// If the connection doesn't include the opposite direction, the "T" points in that direction
|
||
|
|
if (!connections.Contains(opposite))
|
||
|
|
{
|
||
|
|
switch (opposite)
|
||
|
|
{
|
||
|
|
case Direction.North: return Quaternion.Euler(0, 0, 0);
|
||
|
|
case Direction.East: return Quaternion.Euler(0, 90, 0);
|
||
|
|
case Direction.South: return Quaternion.Euler(0, 180, 0);
|
||
|
|
case Direction.West: return Quaternion.Euler(0, 270, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// If it does contain the opposite, find the missing direction
|
||
|
|
Direction[] allDirections = new Direction[] { Direction.North, Direction.East, Direction.South, Direction.West };
|
||
|
|
Direction missing = allDirections.First(d => !connections.Contains(d));
|
||
|
|
|
||
|
|
switch (missing)
|
||
|
|
{
|
||
|
|
case Direction.North: return Quaternion.Euler(0, 180, 0);
|
||
|
|
case Direction.East: return Quaternion.Euler(0, 270, 0);
|
||
|
|
case Direction.South: return Quaternion.Euler(0, 0, 0);
|
||
|
|
case Direction.West: return Quaternion.Euler(0, 90, 0);
|
||
|
|
default: return Quaternion.identity;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void AddDeadEndCorridors()
|
||
|
|
{
|
||
|
|
// Add some random dead ends for more interesting level design
|
||
|
|
int deadEndCount = Random.Range(1, 4); // 1-3 dead ends
|
||
|
|
|
||
|
|
for (int i = 0; i < deadEndCount; i++)
|
||
|
|
{
|
||
|
|
// Pick a random room to extend from
|
||
|
|
int roomIndex = Random.Range(0, roomPositions.Count);
|
||
|
|
Vector3 roomPos = roomPositions[roomIndex];
|
||
|
|
|
||
|
|
// Pick a random direction
|
||
|
|
Vector3[] directions = new Vector3[] {
|
||
|
|
new Vector3(5, 0, 0), // East
|
||
|
|
new Vector3(-5, 0, 0), // West
|
||
|
|
new Vector3(0, 0, 5), // North
|
||
|
|
new Vector3(0, 0, -5) // South
|
||
|
|
};
|
||
|
|
|
||
|
|
Vector3 direction = directions[Random.Range(0, directions.Length)];
|
||
|
|
|
||
|
|
// Create a dead end corridor (1-3 segments long)
|
||
|
|
int segmentCount = Random.Range(1, 4);
|
||
|
|
Vector3 currentPos = roomPos;
|
||
|
|
|
||
|
|
for (int j = 0; j < segmentCount; j++)
|
||
|
|
{
|
||
|
|
Vector3 nextPos = currentPos + direction;
|
||
|
|
|
||
|
|
// Make sure we're not placing corridors where rooms exist
|
||
|
|
bool canPlace = true;
|
||
|
|
foreach (Vector3 roomPosition in roomPositions)
|
||
|
|
{
|
||
|
|
if (Vector3.Distance(nextPos, roomPosition) < 5)
|
||
|
|
{
|
||
|
|
canPlace = false;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (canPlace)
|
||
|
|
{
|
||
|
|
PlaceCorridorSegment(currentPos, nextPos);
|
||
|
|
currentPos = nextPos;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Place an end cap at the last position if it's not overlapping with a room
|
||
|
|
bool endCapCanBePlaced = true;
|
||
|
|
foreach (Vector3 roomPosition in roomPositions)
|
||
|
|
{
|
||
|
|
if (Vector3.Distance(currentPos, roomPosition) < 5)
|
||
|
|
{
|
||
|
|
endCapCanBePlaced = false;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (endCapCanBePlaced && segmentCount > 0)
|
||
|
|
{
|
||
|
|
// Calculate rotation based on direction
|
||
|
|
Quaternion rotation = Quaternion.identity;
|
||
|
|
if (direction.x > 0) rotation = Quaternion.Euler(0, 90, 0);
|
||
|
|
else if (direction.x < 0) rotation = Quaternion.Euler(0, 270, 0);
|
||
|
|
else if (direction.z > 0) rotation = Quaternion.Euler(0, 0, 0);
|
||
|
|
else if (direction.z < 0) rotation = Quaternion.Euler(0, 180, 0);
|
||
|
|
|
||
|
|
Instantiate(CorridorEnd, currentPos, rotation, transform);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private Vector3 GetRandomGridPosition()
|
||
|
|
{
|
||
|
|
Vector3 lastRoomPos = roomPositions[roomPositions.Count - 1];
|
||
|
|
|
||
|
|
// Calculate min and max distances in grid units (multiples of 5)
|
||
|
|
int minGridDistance = Mathf.CeilToInt(minRoomDistance / 5);
|
||
|
|
int maxGridDistance = Mathf.FloorToInt(maxRoomDistance / 5);
|
||
|
|
|
||
|
|
// Get random grid cell offset
|
||
|
|
int xGridOffset = 0;
|
||
|
|
int zGridOffset = 0;
|
||
|
|
Vector3 roomPos = Vector3.zero;
|
||
|
|
|
||
|
|
// Make sure the position is valid
|
||
|
|
int attempts = 0;
|
||
|
|
int maxAttempts = 100; // Prevent infinite loops
|
||
|
|
|
||
|
|
do {
|
||
|
|
// Generate random offsets directly as grid units
|
||
|
|
xGridOffset = Random.Range(-maxGridDistance, maxGridDistance + 1);
|
||
|
|
zGridOffset = Random.Range(-maxGridDistance, maxGridDistance + 1);
|
||
|
|
|
||
|
|
// Ensure we respect minimum distance
|
||
|
|
if (Mathf.Abs(xGridOffset) < minGridDistance && Mathf.Abs(zGridOffset) < minGridDistance)
|
||
|
|
{
|
||
|
|
// Force minimum distance by picking a direction
|
||
|
|
if (Random.value < 0.5f)
|
||
|
|
xGridOffset = Random.value < 0.5f ? minGridDistance : -minGridDistance;
|
||
|
|
else
|
||
|
|
zGridOffset = Random.value < 0.5f ? minGridDistance : -minGridDistance;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Convert grid units to world position (multiply by 5)
|
||
|
|
roomPos = new Vector3(
|
||
|
|
lastRoomPos.x + (xGridOffset * 5),
|
||
|
|
0,
|
||
|
|
lastRoomPos.z + (zGridOffset * 5)
|
||
|
|
);
|
||
|
|
|
||
|
|
attempts++;
|
||
|
|
} while (!IsValidPos(roomPos) && attempts < maxAttempts);
|
||
|
|
|
||
|
|
// If we couldn't find a valid position, use fallback
|
||
|
|
if (attempts >= maxAttempts)
|
||
|
|
{
|
||
|
|
Debug.LogWarning("Couldn't find valid room position after " + maxAttempts + " attempts. Using best approximation.");
|
||
|
|
roomPos = FindNearestValidGridPosition(lastRoomPos);
|
||
|
|
}
|
||
|
|
|
||
|
|
return roomPos;
|
||
|
|
}
|
||
|
|
|
||
|
|
private Vector3 FindNearestValidGridPosition(Vector3 startPos)
|
||
|
|
{
|
||
|
|
// Define min and max grid distances in grid units (not world units)
|
||
|
|
int minGridDistance = Mathf.CeilToInt(minRoomDistance / 5);
|
||
|
|
int maxGridDistance = Mathf.FloorToInt(maxRoomDistance / 5);
|
||
|
|
|
||
|
|
// Check each grid distance in increasing order
|
||
|
|
for (int distance = minGridDistance; distance <= maxGridDistance; distance++)
|
||
|
|
{
|
||
|
|
// Try cardinal directions first (more likely to have space)
|
||
|
|
int[] directions = { distance, -distance };
|
||
|
|
|
||
|
|
// Try horizontal directions
|
||
|
|
foreach (int x in directions)
|
||
|
|
{
|
||
|
|
Vector3 testPos = new Vector3(startPos.x + (x * 5), 0, startPos.z);
|
||
|
|
if (IsValidPos(testPos))
|
||
|
|
return testPos;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Try vertical directions
|
||
|
|
foreach (int z in directions)
|
||
|
|
{
|
||
|
|
Vector3 testPos = new Vector3(startPos.x, 0, startPos.z + (z * 5));
|
||
|
|
if (IsValidPos(testPos))
|
||
|
|
return testPos;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Try diagonals
|
||
|
|
foreach (int x in directions)
|
||
|
|
{
|
||
|
|
foreach (int z in directions)
|
||
|
|
{
|
||
|
|
Vector3 testPos = new Vector3(startPos.x + (x * 5), 0, startPos.z + (z * 5));
|
||
|
|
if (IsValidPos(testPos))
|
||
|
|
return testPos;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// If all else fails, return a position at minimum distance
|
||
|
|
return new Vector3(startPos.x + (minGridDistance * 5), 0, startPos.z);
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool IsValidPos(Vector3 pos)
|
||
|
|
{
|
||
|
|
foreach (Vector3 roomPos in roomPositions)
|
||
|
|
{
|
||
|
|
if (Vector3.Distance(pos, roomPos) < minRoomDistance)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|