// This creates additional connections between rooms in an attempt to make the dungeon less linear
void randomConnections()
{
int i = 0;
while (i < rooms.Count)
{
int j = 0;
while (j < rooms.Count)
{
if (rooms[i].getDist(rooms[j].x, rooms[j].y) <= 20 && !rooms[j].connectionMade)
{
rooms[j].connectionMade = true;
// Builds a corridor upward or downward
if (Mathf.Abs(rooms[i].x - rooms[j].x) <= 3)
{
if (rooms[i].y <= rooms[j].y && rooms[j].down == false)
{
for (int y = rooms[i].y; y <= rooms[j].y; y++)
{
grid[rooms[i].x, y] = tileType.floor;
pGrid[rooms[i].x, y] = propType.ignore;
grid[rooms[i].x, y - 1] = tileType.floor;
grid[rooms[i].x, y + 1] = tileType.floor;
floorTile newFloor = new floorTile(rooms[i].x, y);
floors.Add(newFloor);
newFloor = new floorTile(rooms[i].x, y + 1);
floors.Add(newFloor);
newFloor = new floorTile(rooms[i].x, y - 1);
floors.Add(newFloor);
}
rooms[j].down = true;
}
else if (rooms[j].up == false)
{
for (int y = rooms[i].y; y > rooms[j].y; y--)
{
grid[rooms[i].x, y] = tileType.floor;
pGrid[rooms[i].x, y] = propType.ignore;
grid[rooms[i].x, y - 1] = tileType.floor;
grid[rooms[i].x, y + 1] = tileType.floor;
floorTile newFloor = new floorTile(rooms[i].x, y);
floors.Add(newFloor);
newFloor = new floorTile(rooms[i].x, y - 1);
floors.Add(newFloor);
newFloor = new floorTile(rooms[i].x, y + 1);
floors.Add(newFloor);
}
rooms[j].up = true;
}
}
// Builds a corridor left or right
if (Mathf.Abs(rooms[i].y - rooms[j].y) <= 3)
{
if (rooms[i].x <= rooms[j].x && rooms[j].right == false)
{
for (int x = rooms[i].x; x <= rooms[j].x; x++)
{
grid[x, rooms[i].y] = tileType.floor;
pGrid[x, rooms[i].y] = propType.ignore;
grid[x - 1, rooms[i].y] = tileType.floor;
grid[x + 1, rooms[i].y] = tileType.floor;
floorTile newFloor = new floorTile(x, rooms[i].y);
floors.Add(newFloor);
newFloor = new floorTile(x + 1, rooms[i].y);
floors.Add(newFloor);
newFloor = new floorTile(x - 1, rooms[i].y);
floors.Add(newFloor);
}
rooms[j].right = true;
}
else if (rooms[j].left == false)
{
for (int x = rooms[i].x; x > rooms[j].x; x--)
{
grid[x, rooms[i].y] = tileType.floor;
pGrid[x, rooms[i].y] = propType.ignore;
grid[x - 1, rooms[i].y] = tileType.floor;
grid[x + 1, rooms[i].y] = tileType.floor;
floorTile newFloor = new floorTile(x, rooms[i].y);
floors.Add(newFloor);
newFloor = new floorTile(x - 1, rooms[i].y);
floors.Add(newFloor);
newFloor = new floorTile(x + 1, rooms[i].y);
floors.Add(newFloor);
}
rooms[j].left = true;
}
}
}
j++;
}
i++;
}
} // End of random connections
} // End of drawBoard
// For building a room
void buildRoom(int xC, int yC, int rW, int rH)
{
if (numberOfRooms > 0 && regionCheck(xC, yC, rW, rH))
{
int roomWidth = rW;
int roomHeight = rH;
// Builds the actual room
room newRoom = new room(xC, yC, rW, rH, (maxRooms - numberOfRooms));
numberOfRooms--;
// Creates a room based on the chosen height and width using xC and yC as the center of the room.
for (int y = (yC + roomHeight / 2); y > (yC - roomHeight / 2); y--)
{
for (int x = (xC - roomWidth / 2); x < (xC + roomWidth / 2); x++)
{
grid[x, y] = tileType.floor;
floorTile newFloor = new floorTile(x, y);
floors.Add(newFloor);
int[] addCords = new int[2];
addCords[0] = x;
addCords[1] = y;
}
}
// For building rooms connected to this one
int conRooms = 1;
int numAttempts = 0; // This is meant to prevent infinite loops
if (numberOfRooms >= 4)
{
conRooms = 4;
}
else
{
conRooms = numberOfRooms;
}
for (int i = 0; i < conRooms; i++)
{
bool roomChosen = false; // This flag is used to inform if the room has been chosen
int nextRoom = 0; // The number designation for the nest room. 0=Up, 1=Right,2=Down,3=Left
int nextWidth = pseudoRandom.Next(roomWidthMin, roomWidthMax + 1);
int nextHeight = pseudoRandom.Next(roomHeightMin, roomHeightMax + 1);
int cordLength = pseudoRandom.Next(corridorMin, corridorMax + 1);
nextRoom = pseudoRandom.Next(0, 4);
int nX;
int nY;
while (!roomChosen)
{
if (numberOfRooms > 0)
{
switch (nextRoom)
{
case 0: // Up
nX = xC;
nY = yC + (roomHeight / 2) + cordLength + (nextHeight / 2);
if (isRoomClear(nX, nY, nextWidth, nextHeight))
{
for (int z = 0; z <= cordLength; z++) // This creates the hallway that connects the rooms
{
grid[xC, yC + (rH / 2) + z] = tileType.floor;
pGrid[xC, yC + (rH / 2) + z] = propType.ignore;
grid[xC - 1, yC + (rH / 2) + z] = tileType.floor;
grid[xC + 1, yC + (rH / 2) + z] = tileType.floor;
floorTile newFloor = new floorTile(xC, yC + (rH / 2) + z);
floors.Add(newFloor);
newFloor = new floorTile(xC - 1, yC + (rH / 2) + z);
floors.Add(newFloor);
newFloor = new floorTile(xC + 1, yC + (rH / 2) + z);
floors.Add(newFloor);
}
newRoom.up = true;
roomChosen = true;
buildRoom(nX, nY, nextWidth, nextHeight);
}
else if (grid[xC, yC + cordLength + 1] == tileType.floor)
{
for (int z = 0; z <= cordLength; z++)
{
grid[xC, yC + (rH / 2) + z] = tileType.floor;
pGrid[xC, yC + (rH / 2) + z] = propType.ignore;
grid[xC - 1, yC + (rH / 2) + z] = tileType.floor;
grid[xC + 1, yC + (rH / 2) + z] = tileType.floor;
floorTile newFloor = new floorTile(xC, yC + (rH / 2) + z);
floors.Add(newFloor);
newFloor = new floorTile(xC - 1, yC + (rH / 2) + z);
floors.Add(newFloor);
newFloor = new floorTile(xC + 1, yC + (rH / 2) + z);
floors.Add(newFloor);
}
newRoom.up = true;
}
break;
case 1: // Right
nX = xC + (roomWidth / 2) + cordLength + (nextWidth / 2);
nY = yC;
if (isRoomClear(nX, nY, nextWidth, nextHeight))
{
for (int z = 0; z <= cordLength; z++)
{
grid[xC + (rW / 2) + z, yC] = tileType.floor;
pGrid[xC + (rW / 2) + z, yC] = propType.ignore;
grid[xC + (rW / 2) + z, yC + 1] = tileType.floor;
grid[xC + (rW / 2) + z, yC - 1] = tileType.floor;
floorTile newFloor = new floorTile(xC + (rW / 2) + z, yC);
floors.Add(newFloor);
newFloor = new floorTile(xC + (rW / 2) + z, yC + 1);
floors.Add(newFloor);
newFloor = new floorTile(xC + (rW / 2) + z, yC - 1);
floors.Add(newFloor);
}
newRoom.right = true;
roomChosen = true;
buildRoom(nX, nY, nextWidth, nextHeight);
}
else if (grid[xC + cordLength + 1, yC] == tileType.floor)
{
for (int z = 0; z <= cordLength; z++)
{
grid[xC + (rW / 2) + z, yC] = tileType.floor;
pGrid[xC + (rW / 2) + z, yC] = propType.ignore;
grid[xC + (rW / 2) + z, yC + 1] = tileType.floor;
grid[xC + (rW / 2) + z, yC - 1] = tileType.floor;
floorTile newFloor = new floorTile(xC + (rW / 2) + z, yC);
floors.Add(newFloor);
newFloor = new floorTile(xC + (rW / 2) + z, yC + 1);
floors.Add(newFloor);
newFloor = new floorTile(xC + (rW / 2) + z, yC - 1);
floors.Add(newFloor);
}
newRoom.right = true;
}
break;
case 2: // Down
nX = xC;
nY = yC - (roomHeight / 2) - cordLength - (nextHeight / 2);
if (isRoomClear(nX, nY, nextWidth, nextHeight))
{
roomChosen = true;
for (int z = 0; z <= cordLength + 1; z++)
{
grid[xC, yC - (rH / 2) - z] = tileType.floor;
pGrid[xC, yC - (rH / 2) - z] = propType.ignore;
grid[xC + 1, yC - (rH / 2) - z] = tileType.floor;
grid[xC - 1, yC - (rH / 2) - z] = tileType.floor;
floorTile newFloor = new floorTile(xC, yC - (rH / 2) - z);
floors.Add(newFloor);
newFloor = new floorTile(xC - 1, yC - (rH / 2) - z);
floors.Add(newFloor);
newFloor = new floorTile(xC + 1, yC - (rH / 2) - z);
floors.Add(newFloor);
}
newRoom.down = true;
buildRoom(nX, nY, nextWidth, nextHeight);
}
else if (grid[xC, yC - cordLength - 1] == tileType.floor)
{
for (int z = 0; z <= cordLength + 1; z++)
{
grid[xC, yC - (rH / 2) - z] = tileType.floor;
pGrid[xC, yC - (rH / 2) - z] = propType.ignore;
grid[xC + 1, yC - (rH / 2) - z] = tileType.floor;
grid[xC - 1, yC - (rH / 2) - z] = tileType.floor;
floorTile newFloor = new floorTile(xC, yC - (rH / 2) - z);
floors.Add(newFloor);
newFloor = new floorTile(xC - 1, yC - (rH / 2) - z);
floors.Add(newFloor);
newFloor = new floorTile(xC + 1, yC - (rH / 2) - z);
floors.Add(newFloor);
}
newRoom.down = true;
}
break;
case 3: // Left
nX = xC - (roomWidth / 2) - cordLength - (nextWidth / 2);
nY = yC;
if (isRoomClear(nX, nY, nextWidth, nextHeight))
{
roomChosen = true;
for (int z = 0; z <= cordLength; z++)
{
grid[xC - (rW / 2) - z, yC] = tileType.floor;
pGrid[xC - (rW / 2) - z, yC] = propType.ignore;
grid[xC - (rW / 2) - z, yC + 1] = tileType.floor;
grid[xC - (rW / 2) - z, yC - 1] = tileType.floor;
floorTile newFloor = new floorTile(xC - (rW / 2) - z, yC);
floors.Add(newFloor);
newFloor = new floorTile(xC - (rW / 2) - z, yC + 1);
floors.Add(newFloor);
newFloor = new floorTile(xC - (rW / 2) - z, yC - 1);
floors.Add(newFloor);
}
newRoom.left = true;
buildRoom(nX, nY, nextWidth, nextHeight);
}
else if (grid[xC + cordLength + 1, yC] == tileType.floor)
{
for (int z = 0; z <= cordLength; z++)
{
grid[xC - (rW / 2) - z, yC] = tileType.floor;
pGrid[xC - (rW / 2) - z, yC] = propType.ignore;
grid[xC - (rW / 2) - z, yC + 1] = tileType.floor;
grid[xC - (rW / 2) - z, yC - 1] = tileType.floor;
floorTile newFloor = new floorTile(xC - (rW / 2) - z, yC);
floors.Add(newFloor);
newFloor = new floorTile(xC - (rW / 2) - z, yC + 1);
floors.Add(newFloor);
newFloor = new floorTile(xC - (rW / 2) - z, yC - 1);
floors.Add(newFloor);
}
newRoom.left = true;
}
break;
}
}
else
{
roomChosen = true;
}
if (!roomChosen) // If a room is not chosen, it will attempt a different direction
{
nextRoom = pseudoRandom.Next(0, 4);
numAttempts++;
if (nextRoom > 3)
{
nextRoom = 0;
}
}
if (numAttempts > 3)
{
break;
}
}
}
rooms.Add(newRoom);
}
else
{
numberOfRooms++;
}
} // end of "Build Room"
