void SetTilesValuesForCorridors() { // Go through every corridor... for (int i = 0; i < corridors.Length; i++) { Corridor3D currentCorridor = corridors[i]; // and go through it's length. for (int j = 0; j < currentCorridor.corridorLength; j++) { // Start the coordinates at the start of the corridor. int xCoord = currentCorridor.startXPos; int yCoord = currentCorridor.startYPos; int CorridDepth = currentCorridor.Depth - 1; // Depending on the direction, add or subtract from the appropriate // coordinate based on how far through the length the loop is. switch (currentCorridor.direction) { case Direction.North: yCoord += j; break; case Direction.East: xCoord += j; break; case Direction.South: yCoord -= j; break; case Direction.West: xCoord -= j; break; } // Set the tile at these coordinates to Floor. tiles[CorridDepth][xCoord][yCoord] = currentCorridor.FloorType; } } //Redo Room[0] to ensure entry room not destroyed Room3D EntryRoom = rooms[0]; //Debug.Log("Total Rooms " + rooms.Length + " Room # " + i); int EntryDepth = EntryRoom.Depth - 1; // ... and for each room go through it's width. for (int j = 0; j < EntryRoom.roomWidth; j++) { int xCoord = EntryRoom.xPos + j; // For each horizontal tile, go up vertically through the room's height. for (int k = 0; k < EntryRoom.roomHeight; k++) { int yCoord = EntryRoom.yPos + k; // The coordinates in the jagged array are based on the room's position and it's width and height. tiles[EntryDepth][xCoord][yCoord] = EntryRoom.FloorType; } } }
public Room3DController(GameWorld world) { foreach (var room in world.Rooms) { Room3D.Init(room); } }
public void BuildEntryCorridor(Room3D room, int length) { FloorType = TileType3D.Floor; Depth = 1; switch (room.FloorType) { case TileType3D.Entry1: direction = Direction.West; break; case TileType3D.Entry2: direction = Direction.East; break; case TileType3D.Entry4: direction = Direction.North; break; case TileType3D.Entry8: direction = Direction.South; break; } switch (direction) { case Direction.North: startXPos = room.xPos; startYPos = room.yPos + 1; break; case Direction.West: startXPos = room.xPos - 1; startYPos = room.yPos; break; case Direction.South: startXPos = room.xPos; startYPos = room.yPos - 1; break; case Direction.East: startXPos = room.xPos + 1; startYPos = room.yPos; break; } corridorLength = length; }
void SetTilesValuesForRooms() { // Go through all the rooms... for (int i = 0; i < rooms.Length; i++) { Room3D currentRoom = rooms[i]; //Debug.Log("Total Rooms " + rooms.Length + " Room # " + i); int roomDepth = currentRoom.Depth - 1; // ... and for each room go through it's width. for (int j = 0; j < currentRoom.roomWidth; j++) { int xCoord = currentRoom.xPos + j; // For each horizontal tile, go up vertically through the room's height. for (int k = 0; k < currentRoom.roomHeight; k++) { int yCoord = currentRoom.yPos + k; // The coordinates in the jagged array are based on the room's position and it's width and height. tiles[roomDepth][xCoord][yCoord] = currentRoom.FloorType; } } } //Redo Room[0] to ensure entry room not destroyed Room3D EntryRoom = rooms[0]; //Debug.Log("Total Rooms " + rooms.Length + " Room # " + i); int EntryDepth = EntryRoom.Depth - 1; // ... and for each room go through it's width. for (int j = 0; j < EntryRoom.roomWidth; j++) { int xCoord = EntryRoom.xPos + j; // For each horizontal tile, go up vertically through the room's height. for (int k = 0; k < EntryRoom.roomHeight; k++) { int yCoord = EntryRoom.yPos + k; // The coordinates in the jagged array are based on the room's position and it's width and height. tiles[EntryDepth][xCoord][yCoord] = EntryRoom.FloorType; } } //Debug.Log("Rooms created in array."); }
public void SetupCorridor(Room3D room, IntRange length, IntRange roomWidth, IntRange roomHeight, int columns, int rows, bool firstCorridor, int level) { // Set a random direction (a random index from 0 to 3, cast to Direction). direction = (Direction)Random.Range(0, 4); Depth = level; // Find the direction opposite to the one entering the room this corridor is leaving from. // Cast the previous corridor's direction to an int between 0 and 3 and add 2 (a number between 2 and 5). // Find the remainder when dividing by 4 (if 2 then 2, if 3 then 3, if 4 then 0, if 5 then 1). // Cast this number back to a direction. // Overall effect is if the direction was South then that is 2, becomes 4, remainder is 0, which is north. Direction oppositeDirection = (Direction)(((int)room.enteringCorridor + 2) % 4); // If this is noth the first corridor and the randomly selected direction is opposite to the previous corridor's direction... if (!firstCorridor && direction == oppositeDirection) { // Rotate the direction 90 degrees clockwise (North becomes East, East becomes South, etc). // This is a more broken down version of the opposite direction operation above but instead of adding 2 we're adding 1. // This means instead of rotating 180 (the opposite direction) we're rotating 90. int directionInt = (int)direction; directionInt++; directionInt = directionInt % 4; direction = (Direction)directionInt; } // Set a random length. corridorLength = length.Random; // Create a cap for how long the length can be (this will be changed based on the direction and position). int maxLength = length.m_Max; FloorType = TileType3D.Floor; switch (direction) { // If the choosen direction is North (up)... case Direction.North: // ... the starting position in the x axis can be random but within the width of the room. startXPos = Random.Range(room.xPos, room.xPos + room.roomWidth - 1); // The starting position in the y axis must be the top of the room. startYPos = room.yPos + room.roomHeight; // The maximum length the corridor can be is the height of the board (rows) but from the top of the room (y pos + height). maxLength = rows - startYPos - roomHeight.m_Min; break; case Direction.East: startXPos = room.xPos + room.roomWidth; startYPos = Random.Range(room.yPos, room.yPos + room.roomHeight - 1); maxLength = columns - startXPos - roomWidth.m_Min; break; case Direction.South: startXPos = Random.Range(room.xPos, room.xPos + room.roomWidth); startYPos = room.yPos; maxLength = startYPos - roomHeight.m_Min; break; case Direction.West: startXPos = room.xPos; startYPos = Random.Range(room.yPos, room.yPos + room.roomHeight); maxLength = startXPos - roomWidth.m_Min; break; } // We clamp the length of the corridor to make sure it doesn't go off the board. corridorLength = Mathf.Clamp(corridorLength, 1, maxLength); }
void CreateRoomsAndCorridors() { // Create the rooms array with a random size. int TotalRooms; int RoomPerLvl; int RoomTotalLoop; RoomTotalLoop = 0; RoomPerLvl = numRooms.Random; //TotalRooms = (RoomPerLvl * Depth) + 3 + (1+(2*(Depth-1))); TotalRooms = (RoomPerLvl * Depth) + 3; Debug.Log("Total Rooms: " + TotalRooms); Debug.Log("Total Room per LVL " + RoomPerLvl); rooms = new Room3D[TotalRooms]; // There should be one less corridor than there is rooms. corridors = new Corridor3D[TotalRooms - 1]; //Create the first room and corridor. rooms[0] = new Room3D(); corridors[0] = new Corridor3D(); //Create Entry Room rooms[0].CreateEntry(1, 1, columns, rows); corridors[0].BuildEntryCorridor(rooms[0], 5); RoomTotalLoop++; rooms[1] = new Room3D(); corridors[1] = new Corridor3D(); rooms[1].SetupRoom(roomWidth, roomHeight, columns, rows, corridors[0], 1, TileType3D.Floor); corridors[1].SetupCorridor(rooms[1], corridorLength, roomWidth, roomHeight, columns, rows, false, 1); RoomTotalLoop++; rooms[2] = new Room3D(); corridors[2] = new Corridor3D(); rooms[2].SetupRoom(roomWidth, roomHeight, columns, rows, corridors[1], 1, TileType3D.Floor); corridors[2].SetupCorridor(rooms[2], corridorLength, roomWidth, roomHeight, columns, rows, false, 1); // Setup the first room, there is no previous corridor so we do not use one. //rooms[0].SetupRoom(roomWidth, roomHeight, columns, rows); // Setup the first corridor using the first room. //corridors[0].SetupCorridor(rooms[0], corridorLength, roomWidth, roomHeight, columns, rows, true); for (int i = 0; i < RoomPerLvl; i++) { // Create a room. RoomTotalLoop++; rooms[RoomTotalLoop] = new Room3D(); //Debug.Log("Room " + RoomTotalLoop); // Setup the room based on the previous corridor. rooms[RoomTotalLoop].SetupRoom(roomWidth, roomHeight, columns, rows, corridors[RoomTotalLoop - 1], 1, TileType3D.Floor); // If we haven't reached the end of the corridors array... if (RoomTotalLoop < corridors.Length) { // ... create a corridor. corridors[RoomTotalLoop] = new Corridor3D(); // Setup the corridor based on the room that was just created. corridors[RoomTotalLoop].SetupCorridor(rooms[RoomTotalLoop], corridorLength, roomWidth, roomHeight, columns, rows, false, 1); } } // Create an extra room on current level and next level down. Both will be classed as stair undef. for (int d = 1; d < Depth; d++) { for (int i = 0; i < RoomPerLvl; i++) { // Create a room. RoomTotalLoop++; rooms[RoomTotalLoop] = new Room3D(); //Debug.Log("Depth " + d + " Room " + RoomTotalLoop); // Setup the room based on the previous corridor. rooms[RoomTotalLoop].SetupRoom(roomWidth, roomHeight, columns, rows, corridors[RoomTotalLoop - 1], d + 1, TileType3D.Floor); // If we haven't reached the end of the corridors array... if (RoomTotalLoop < corridors.Length) { // ... create a corridor. corridors[RoomTotalLoop] = new Corridor3D(); // Setup the corridor based on the room that was just created. corridors[RoomTotalLoop].SetupCorridor(rooms[RoomTotalLoop], corridorLength, roomWidth, roomHeight, columns, rows, false, d + 1); } } //Create same room at current level and next level for down stairs. } }