public void GenerateNextRoom()
{
Door targetDoor = openSet[0]; //grab the first door in the openset to process
openSet.RemoveAt(0);
Vector3 targetVoxel = targetDoor.position + targetDoor.direction; //offset one voxel in door dir so we work on the unoccupied voxel the door leads to
Vector3 targetWorldVoxPos = GetVoxelWorldPos(targetVoxel, targetDoor.parent.rotation) + targetDoor.parent.transform.position; //need this for offset
Vector3 targetWorldDoorDir = GetVoxelWorldDir(targetDoor.direction, targetDoor.parent.rotation); //the target voxel we're going to align to
Door doorForProcessing = new Door(targetWorldVoxPos, targetWorldDoorDir, targetDoor.parent); //why do I do this instead of using targetDoor directly...?
//AllDoorsData.Add(doorForProcessing);
List <GameObject> roomsToTry = new List <GameObject>(generatorSettings.possibleRooms);
//create a copy of the "all possible rooms list" so we can pick and remove from this list as we try different rooms
//this ensures we don't try the same room over and over, and so we know when we have exhausted all the possiblities and just have to cap it off with a 1x1x1 vox room
for (int i = 0; i < roomsToTry.Count; i++) //find the room template of the room we are trying to connect to, and remove that room template from the list of possible rooms to spawn
{
if (roomsToTry[i].GetComponent <RoomData>().roomTemplateID == targetDoor.parent.roomTemplateID) //this is to make it so we are less likely to spawn the same room type twice in a row
{
roomsToTry.RemoveAt(i); break;
}
}
roomsToTry.Shuffle(rand); //shuffle this list so we dont always try the rooms in the same order.
for (int i = 0; i < generatorSettings.possibleRooms.Count; i++) //add back the room type we removed to the end of the (now shuffled) list, so that we try every other room first and only use this room as a last choice
{
if (generatorSettings.possibleRooms[i].GetComponent <RoomData>().roomTemplateID == targetDoor.parent.roomTemplateID)
{
roomsToTry.Add(generatorSettings.possibleRooms[i]);
}
}
RoomData instantiatedNewRoom = null;
if (generatorSettings.useDeadendRooms)
{
if (AllRooms.Count + openSet.Count >= targetRooms)
{
roomsToTry.Clear();
//Debug.Log("Ending Gen, Target rooms hit");
}
}
else
{
if (AllRooms.Count >= targetRooms)
{
roomsToTry.Clear();
}
}
if (generatorSettings.useDeadendRooms) //append this to the end of the roomsToTryList
{
int ri = rand.Next(0, generatorSettings.deadendRooms.Count); //get a random deadend room
roomsToTry.Add(generatorSettings.deadendRooms[ri]); //append the "singleVoxelRoom" as a last resort, this room will fit in ALL cases
}
//roomsToTry list MIGHT be empty, if so we just don't spawn a room, spawn a door and a halfempty connection
bool makeRoomDeadend = false;
if (roomsToTry.Count == 0)
{
makeRoomDeadend = true;
}
if (!makeRoomDeadend) //spawn rooms like normal
{
//data we will have once we find a room, used for spawning the room into the world
RoomData newRoom = null;
Vector3 computedRoomOffset = Vector3.zero;
int doorIndex = 0;
float computedRoomRotation = 0f;
bool anyOverlaps = false;
//start
do
{
//it's possible that we try every room and none fit, especially if we don't have any deaded rooms that _should_ fit in any situation.
//so if the list is empty, just break out
if (roomsToTry.Count == 0)
{
makeRoomDeadend = true;
break;
}
newRoom = roomsToTry[0].GetComponent <RoomData>();
roomsToTry.RemoveAt(0);
List <int> doorsToTry = new List <int>();
for (int i = 0; i < newRoom.Doors.Count; i++)
{
doorsToTry.Add(i);
}
doorsToTry.Shuffle(rand); //same thing here with the doorors as with the rooms. Copy the list so we can exaust our options, shuffle it so we never try in the same order
do //try all the different doors in different orientations
{
doorIndex = doorsToTry[0]; //get first doorIndex (has been shuffled)
doorsToTry.RemoveAt(0);
Door newDoor = newRoom.Doors[doorIndex];
Vector3 targetDoorDir = targetWorldDoorDir;
computedRoomRotation = GetRoomRotation(targetDoorDir, newDoor); //computes the rotation of the room so that the door we've selected to try lines up properly to the door we are wanting to connect to
Vector3 sDLocalWithRotation = GetVoxelWorldPos(newDoor.position, computedRoomRotation);
computedRoomOffset = targetWorldVoxPos - sDLocalWithRotation; //the computed offset we need to apply to the room gameobject so that the doors align
List <Vector3> worldVoxels = new List <Vector3>(); //check for overlaps with all of these. MUST BE Mathf.RoundToInt so that the vectors are not like 0.999999999 due to precision issues
for (int i = 0; i < newRoom.LocalVoxels.Count; i++)
{
Vector3 v = GetVoxelWorldPos(newRoom.LocalVoxels[i].position, computedRoomRotation) + computedRoomOffset; //all the room voxels
worldVoxels.Add(v);
}
for (int i = 0; i < newRoom.Doors.Count; i++)
{
if (i != doorIndex) //all the door voxels (except the one we're currently working on/linking up to another room).
//We need to do this to so that we don't PLACE this room in a spot where the doors of this room have no space for at least a 1x1x1 room (eg, opening a door directly into a wall)
{
Vector3 v = GetVoxelWorldPos((newRoom.Doors[i].position + newRoom.Doors[i].direction), computedRoomRotation) + computedRoomOffset;
worldVoxels.Add(v);
}
}
//all room voxels addd. Get all open door voxels now.. as we don't want to block the exits to any doors not yet connected on both sides.
List <Vector3> doorNeighbours = new List <Vector3>();
for (int i = 0; i < openSet.Count; i++)
{
Vector3 v = GetVoxelWorldPos((openSet[i].position + openSet[i].direction), openSet[i].parent.rotation) + openSet[i].parent.transform.position;
doorNeighbours.Add(v);
}
anyOverlaps = false;
for (int i = 0; i < worldVoxels.Count; i++)
{
Vector3 iV = new Vector3(Mathf.RoundToInt(worldVoxels[i].x), Mathf.RoundToInt(worldVoxels[i].y), Mathf.RoundToInt(worldVoxels[i].z));
bool result = IsVoxelOccupied(iV); //check this rooms volume (including the voxels this rooms doors lead into) against all occupied voxels to check for overlaps
if (result)
{
anyOverlaps = true;
break;
}
else
{
for (int j = 0; j < doorNeighbours.Count; j++) //also check this rooms volume against all the voxels openSet.doors lead into, prevents opening a door into a wall
{
Vector3 iD = new Vector3(Mathf.RoundToInt(doorNeighbours[j].x), Mathf.RoundToInt(doorNeighbours[j].y), Mathf.RoundToInt(doorNeighbours[j].z));
if (iD == iV)
{
anyOverlaps = true;
break;
}
}
}
}
} while(doorsToTry.Count > 0 && anyOverlaps);
} while(roomsToTry.Count > 0 && anyOverlaps);
if (anyOverlaps) //if we made it here, we either have a newRoom assigned and ready to spawn, or we have no rooms left to as they all didn't fit
{
makeRoomDeadend = true;
}
//Instantiate
if (!makeRoomDeadend)
{
instantiatedNewRoom = AddRoom(newRoom, computedRoomOffset, computedRoomRotation);
for (int i = 0; i < instantiatedNewRoom.Doors.Count; i++)
{
if (i != doorIndex)
{
openSet.Add(instantiatedNewRoom.Doors[i]);
}
}
}
}
//spawn in door geometry
int di = 0;
GameObject doorToSpawn = null;
if (!makeRoomDeadend)
{
di = rand.Next(0, generatorSettings.doors.Count); //get a random door from the list
doorToSpawn = generatorSettings.doors[di];
}
else
{
di = rand.Next(0, generatorSettings.deadendDoors.Count); //get a random door from the list
doorToSpawn = generatorSettings.deadendDoors[di];
}
Vector3 doorOffset = new Vector3(0f, 0.5f, 0f); //to offset it so the gameobject pivot is on the bottom edge of the voxel
GameObject spawnedDoor = GameObject.Instantiate(doorToSpawn, doorForProcessing.position - (doorForProcessing.direction * 0.5f) - doorOffset, Quaternion.LookRotation(doorForProcessing.direction), this.transform);
doorForProcessing.spawnedDoor = spawnedDoor;
//need to link up the doors to the roomData's too?
//AllDoors.Add(spawnedDoor);
//instantiatedNewRoom.Doors[doorIndex].spawnedDoor = spawnedDoor;
//build graph.. we know...
//instantiatedNewRoom and doorForProcessing.parent are the only two rooms that share the connection we just made so...
//we also know instantiedNewRoom is brand new and has no other connections, we we can use that directly,
//however we need to search for doorForProcessing.parent in the roomsList first as it could have more connections already, if it does, we need to add the connection
//betwen it and
if (!makeRoomDeadend)
{
GraphNode newNode = new GraphNode();
newNode.data = instantiatedNewRoom; //connect it both ways, so we access the data from the node, and the node from the data...
instantiatedNewRoom.node = newNode;
//grab the node of the room we are connecting to
GraphNode lastNode = doorForProcessing.parent.node;
newNode.depth = lastNode.depth + 1;
if (newNode.depth > highestDepth)
{
highestDepth = newNode.depth; //store the highest depth, used for debugging
}
//make a connection for the two of them
GraphConnection con = new GraphConnection();
con.a = lastNode; //store the connections to the rooms
con.b = newNode;
con.open = true;
con.doorRef = doorForProcessing; //this needs a reference to the door geometry, as we need to be able to...unlock it visually? We could hook it up to a data ref, which then has a ref to geometry too but that seems painfully overcomplicated
lastNode.connections.Add(con); //store the connections both ways
newNode.connections.Add(con);
spawnedDoor.GetComponent <GeneratorDoor>().data = con;
DungeonGraph.Add(newNode);
}
else
{
//want to add just a new door as we did not spawn a room!
//GraphNode newNode = new GraphNode();
//newNode.data = instantiatedNewRoom; //connect it both ways, so we access the data from the node, and the node from the data...
//instantiatedNewRoom.node = newNode;
//grab the node of the room we are connecting to
GraphNode lastNode = doorForProcessing.parent.node;
//newNode.depth = lastNode.depth + 1;
//if(newNode.depth > highestDepth) highestDepth = newNode.depth; //store the highest depth, used for debugging
//make a connection for the two of them
GraphConnection con = new GraphConnection();
con.a = lastNode; //store the connections to the rooms
con.b = null;
con.open = false;
con.keyID = -1;
con.doorRef = doorForProcessing; //this needs a reference to the door geometry, as we need to be able to...unlock it visually? We could hook it up to a data ref, which then has a ref to geometry too but that seems painfully overcomplicated
lastNode.connections.Add(con); //store the connections both ways
//newNode.connections.Add(con);
spawnedDoor.GetComponent <GeneratorDoor>().data = con;
//DungeonGraph.Add(newNode);
}
}
/// <summary>
/// Finds a path between the start and end nodes. Interally, we don't need to use the path for anything, but we just need to make sure a path exsists, otherwise the graph is not solveable
/// This is used for keys and locked doors and stuff like that
/// </summary>
/// <param name="start"></param>
/// <param name="end"></param>
/// <returns></returns>
public bool HasPath(GraphNode start, GraphNode end)
{
//iterate through the graph to zero it out
for (int i = 0; i < DungeonGraph.Count; i++)
{
DungeonGraph[i].pathfindingWeight = -1f; //-1f means "not processed"
DungeonGraph[i].pathfindingProcessed = false;
}
List <GraphNode> nodesToProcess = new List <GraphNode>();
nodesToProcess.Add(start);
start.pathfindingWeight = 0f;
start.pathfindingProcessed = true;
//do a flood fill starting from start room, increasing the depth every step
//for(int i = 0; i < nodesToProcess.Count; i++) {
//ColorChildren(start.data.gameObject.transform, Color.cyan);
//this is infinite looping
while (nodesToProcess.Count > 0)
{
GraphNode nodeToProcess = nodesToProcess[0];
nodesToProcess.RemoveAt(0);
nodeToProcess.pathfindingProcessed = true;
for (int j = 0; j < nodeToProcess.connections.Count; j++)
{
if (nodeToProcess.connections[j].open)
{
GraphConnection c = nodeToProcess.connections[j];
if (!c.a.pathfindingProcessed)
{
//a has not been processed, so add it to the "rooms to process" and set it's weight accordingly
c.a.pathfindingWeight = nodeToProcess.pathfindingWeight + 1f;
//c.a.pathfindingProcessed = true;
nodesToProcess.Add(c.a);
//ColorChildren(c.a.data.transform, Color.red);
}
if (!c.b.pathfindingProcessed)
{
//a has not been processed, so add it to the "rooms to process" and set it's weight accordingly
c.b.pathfindingWeight = nodeToProcess.pathfindingWeight + 1f;
//c.a.pathfindingProcessed = true;
nodesToProcess.Add(c.b);
//ColorChildren(c.b.data.transform, Color.green);
}
}
else
{
//can't add this one as the way is closed!
}
}
}
bool foundPath = false;
if (end.pathfindingWeight != -1)
{
foundPath = true;
}
return(foundPath);
}
//Call this to start the generator.
public void RunGenerator(int seed)
{
openSet = new List <Door>();
GlobalVoxelGrid = new Dictionary <Vector3, bool>();
AllRooms = new List <GameObject>();
AllDoorsData = new List <Door>();
DungeonGraph = new List <GraphNode>();
if (regenerateWithDifferentSeed)
{
seed = this.randomSeed;
Debug.Log("Dungeon Generator:: Seed changed to [" + seed + "]");
attempts++;
regenerateWithDifferentSeed = false;
}
//assign every possible room a unique template ID, used for identifying room types later
int templateId = 0;
for (int i = 0; i < generatorSettings.possibleRooms.Count; i++)
{
generatorSettings.possibleRooms[i].GetComponent <RoomData>().roomTemplateID = templateId;
templateId++;
}
for (int i = 0; i < generatorSettings.spawnRooms.Count; i++)
{
generatorSettings.spawnRooms[i].GetComponent <RoomData>().roomTemplateID = templateId;
templateId++;
}
for (int i = 0; i < generatorSettings.deadendRooms.Count; i++)
{
generatorSettings.deadendRooms[i].GetComponent <RoomData>().roomTemplateID = templateId;
templateId++;
}
rand = new System.Random(seed);
int ri = rand.Next(0, generatorSettings.spawnRooms.Count); //get a random start room
RoomData startRoomPrefab = generatorSettings.spawnRooms[ri].GetComponent <RoomData>();
RoomData instantiatedDataStartRoom = AddRoom(startRoomPrefab, Vector3.zero, 0f);
GraphNode firstNode = new GraphNode();
firstNode.data = instantiatedDataStartRoom;
instantiatedDataStartRoom.node = firstNode; //cyclic yay
DungeonGraph.Add(firstNode);
for (int i = 0; i < instantiatedDataStartRoom.Doors.Count; i++)
{
openSet.Add(instantiatedDataStartRoom.Doors[i]);
}
if (generateInUpdate)
{
return;
}
while (openSet.Count > 0)
{
GenerateNextRoom(); //this is just isolated so we can tick this in update during testing
}
//generation is done, do any dungeon specific postprocessing here
if (AllRooms.Count < generatorSettings.minRooms)
{
regenerateWithDifferentSeed = true;
this.randomSeed++;
Debug.Log("Dungeon Generator:: Generation failed to meet min rooms [" + AllRooms.Count + "/" + generatorSettings.minRooms + "] ... trying again with seed++ [ " + this.randomSeed + " ]");
return;
}
Debug.Log("Dungeon Generator:: Generation Complete in [" + DMDebugTimer.Lap() + "ms] and [" + attempts + "] attempts");
generationComplete = true;
}