public Map GenerateMap(int extraConnections)
{
LogFile.Log.LogEntry(String.Format("Generating BSP dungeon"));
baseMap = new Map(width, height);
//Make a BSP tree for the rooms
rootNode = new MapNode(0, 0, width, height);
rootNode.Split();
//Draw a room in each BSP leaf
rootNode.DrawRoomAtLeaf(baseMap);
//debug
//Screen.Instance.DrawMapDebug(baseMap);
//Draw connecting corridors
rootNode.DrawCorridorConnectingChildren(baseMap);
//Add any extra connecting corridors as specified
for (int i = 0; i < extraConnections; i++)
{
rootNode.AddRandomConnection(baseMap);
}
//Add doors where single corridors terminate into rooms
AddDoors();
//Turn corridors into normal squares and surround with walls
CorridorsIntoRooms();
//Set which squares are light blocking
//Now done during creation
//SetLightBlocking(baseMap);
//Set the PC start location in a random room
baseMap.PCStartLocation = rootNode.RandomRoomPoint();
return(baseMap);
}
public Map GenerateMap(int extraConnections)
{
LogFile.Log.LogEntry(String.Format("Generating BSP dungeon"));
baseMap = new Map(width, height);
//Make a BSP tree for the rooms
rootNode = new MapNode(0, 0, width, height);
rootNode.Split();
//Draw a room in each BSP leaf
rootNode.DrawRoomAtLeaf(baseMap);
//debug
//Screen.Instance.DrawMapDebug(baseMap);
//Draw connecting corridors
rootNode.DrawCorridorConnectingChildren(baseMap);
//Add any extra connecting corridors as specified
for (int i = 0; i < extraConnections; i++)
{
rootNode.AddRandomConnection(baseMap);
}
//Add doors where single corridors terminate into rooms
AddDoors();
//Turn corridors into normal squares and surround with walls
CorridorsIntoRooms();
//Set which squares are light blocking
//Now done during creation
//SetLightBlocking(baseMap);
//Set the PC start location in a random room
baseMap.PCStartLocation = rootNode.RandomRoomPoint();
return baseMap;
}
public void DrawCorridorConnectingChildren(Map baseMap)
{
//Children should do their own drawing first
//However, if we don't have children, return to our parent
if (childLeft != null)
{
childLeft.DrawCorridorConnectingChildren(baseMap);
}
if (childRight != null)
{
childRight.DrawCorridorConnectingChildren(baseMap);
}
//If we only have 1 child we can't connect them, but our parent will connect to them
if (childLeft == null || childRight == null)
{
return;
}
//Draw a connecting corridor between our two children
DrawConnectingCorriderBetweenChildren(baseMap);
}
public Map GenerateMap(int extraConnections)
{
LogFile.Log.LogEntry(String.Format("Generating BSP dungeon"));
do
{
baseMap = new Map(width, height);
connectivityGraph = new ConnectivityMap();
//BSP is always connected
baseMap.GuaranteedConnected = true;
//Make a BSP tree for the rooms
rootNode = new MapNode(this, 0, 0, width, height);
rootNode.Split();
//Draw a room in each BSP leaf
rootNode.DrawRoomAtLeaf(baseMap);
//debug
//Screen.Instance.DrawMapDebug(baseMap);
//Draw connecting corridors
rootNode.DrawCorridorConnectingChildren(baseMap);
//Add any extra connecting corridors as specified
for (int i = 0; i < extraConnections; i++)
{
rootNode.AddRandomConnection(baseMap);
}
//Add doors where single corridors terminate into rooms
AddDoorsGraph();
//Turn corridors into normal squares and surround with walls
CorridorsIntoRooms();
//Work out where the staircases will be
//We just want 2 places that aren't too close to each other. The map is guaranteed connected
double RequiredStairDistance = (width * 0.5);
double stairDistance;
do
{
upStaircase = RandomWalkablePoint();
downStaircase = RandomWalkablePoint();
stairDistance = Math.Sqrt(Math.Pow(upStaircase.x - downStaircase.x, 2) + Math.Pow(upStaircase.y - downStaircase.y, 2));
} while (stairDistance < RequiredStairDistance);
//Set which squares are light blocking
//Now done during creation
//SetLightBlocking(baseMap);
//Set the PC start location in a random room
baseMap.PCStartLocation = AddEntryRoomForPlayer();
} while (baseMap.PCStartLocation == null);
//Fake a start room
PointInRoom randomRoom = RandomPointInRoom();
//baseMap.PCStartLocation = randomRoom.GetPointInRoomOnly();
baseMap.PCStartRoomId = randomRoom.RoomId;
//Build the map model for the graph, based on the PC's true starting position (useful for locking doors)
graphModel = new MapModel(connectivityGraph, baseMap.PCStartRoomId);
//Save out the graph
GraphvizExport.OutputUndirectedGraph(connectivityGraph.RoomConnectionGraph, "bsptree-base");
//Save out a copy of the graph with no cycles
GraphvizExport.OutputUndirectedGraph(graphModel.GraphNoCycles.mapNoCycles, "bsptree-nocycles");
return baseMap.Clone();
}
public Map GenerateMap(int extraConnections)
{
LogFile.Log.LogEntry(String.Format("Generating BSPCave dungeon"));
baseMap = new Map(width, height);
//BSP is always connected
baseMap.GuaranteedConnected = true;
//Make a BSP tree for the rooms
rootNode = new MapNode(this, 0, 0, width, height);
rootNode.Split();
//Draw a room in each BSP leaf
rootNode.DrawRoomAtLeaf(baseMap);
//debug
//Screen.Instance.DrawMapDebug(baseMap);
//Draw connecting corridors
rootNode.DrawCorridorConnectingChildren(baseMap);
//Add any extra connecting corridors as specified
for (int i = 0; i < extraConnections; i++)
{
rootNode.AddRandomConnection(baseMap);
}
//Add doors where single corridors terminate into rooms
AddDoors();
//Turn corridors into normal squares and surround with walls
CorridorsIntoRooms();
//Now fill all void with walls
//Fill the map with walls
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
if (baseMap.mapSquares[i, j].Terrain == MapTerrain.Void)
{
baseMap.mapSquares[i, j].Terrain = MapTerrain.Wall;
}
}
}
//Work out where the staircases will be
//We just want 2 places that aren't too close to each other. The map is guaranteed connected
double RequiredStairDistance = (width * 0.5);
double stairDistance;
do
{
upStaircase = RandomWalkablePoint();
downStaircase = RandomWalkablePoint();
stairDistance = Math.Sqrt(Math.Pow(upStaircase.x - downStaircase.x, 2) + Math.Pow(upStaircase.y - downStaircase.y, 2));
} while (stairDistance < RequiredStairDistance);
//Set which squares are light blocking
//Now done during creation
//SetLightBlocking(baseMap);
//Set the PC start location in a random room
baseMap.PCStartLocation = rootNode.RandomRoomPoint().GetPointInRoomOnly();
//Now we use the cave algorithm to eat the map
//Instead of setting this Empty like in cave, set them to Corridor temporarily (so the algo knows where it's been)
DiggingChance = 22;
//Start digging from a random point
int noDiggingPoints = 6 + Game.Random.Next(2);
for (int i = 0; i < noDiggingPoints; i++)
{
int x = Game.Random.Next(width);
int y = Game.Random.Next(height);
//Don't dig right to the edge
if (x == 0)
{
x = 1;
}
if (x == width - 1)
{
x = width - 2;
}
if (y == 0)
{
y = 1;
}
if (y == height - 1)
{
y = height - 2;
}
Dig(x, y);
}
//Turn the corridors into empty
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
if (baseMap.mapSquares[i, j].Terrain == MapTerrain.Corridor)
{
baseMap.mapSquares[i, j].Terrain = MapTerrain.Empty;
}
}
}
//Do a final pass to convert Wall into something more exciting
if (wallType.Count > 0)
{
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
if (baseMap.mapSquares[i, j].Terrain == MapTerrain.Wall)
{
baseMap.mapSquares[i, j].Terrain = wallType[rand.Next(wallType.Count)];
}
}
}
}
return(baseMap.Clone());
}
public Map GenerateMap(int extraConnections)
{
LogFile.Log.LogEntry(String.Format("Generating BSPCave dungeon"));
baseMap = new Map(width, height);
//BSP is always connected
baseMap.GuaranteedConnected = true;
//Make a BSP tree for the rooms
rootNode = new MapNode(this, 0, 0, width, height);
rootNode.Split();
//Draw a room in each BSP leaf
rootNode.DrawRoomAtLeaf(baseMap);
//debug
//Screen.Instance.DrawMapDebug(baseMap);
//Draw connecting corridors
rootNode.DrawCorridorConnectingChildren(baseMap);
//Add any extra connecting corridors as specified
for (int i = 0; i < extraConnections; i++)
{
rootNode.AddRandomConnection(baseMap);
}
//Add doors where single corridors terminate into rooms
AddDoors();
//Turn corridors into normal squares and surround with walls
CorridorsIntoRooms();
//Now fill all void with walls
//Fill the map with walls
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
if (baseMap.mapSquares[i, j].Terrain == MapTerrain.Void)
{
baseMap.mapSquares[i, j].Terrain = MapTerrain.Wall;
}
}
}
//Work out where the staircases will be
//We just want 2 places that aren't too close to each other. The map is guaranteed connected
double RequiredStairDistance = (width * 0.5);
double stairDistance;
do
{
upStaircase = RandomWalkablePoint();
downStaircase = RandomWalkablePoint();
stairDistance = Math.Sqrt(Math.Pow(upStaircase.x - downStaircase.x, 2) + Math.Pow(upStaircase.y - downStaircase.y, 2));
} while (stairDistance < RequiredStairDistance);
//Set which squares are light blocking
//Now done during creation
//SetLightBlocking(baseMap);
//Set the PC start location in a random room
baseMap.PCStartLocation = rootNode.RandomRoomPoint().GetPointInRoomOnly();
//Now we use the cave algorithm to eat the map
//Instead of setting this Empty like in cave, set them to Corridor temporarily (so the algo knows where it's been)
DiggingChance = 22;
//Start digging from a random point
int noDiggingPoints = 6 + Game.Random.Next(2);
for (int i = 0; i < noDiggingPoints; i++)
{
int x = Game.Random.Next(width);
int y = Game.Random.Next(height);
//Don't dig right to the edge
if (x == 0)
x = 1;
if (x == width - 1)
x = width - 2;
if (y == 0)
y = 1;
if (y == height - 1)
y = height - 2;
Dig(x, y);
}
//Turn the corridors into empty
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
if (baseMap.mapSquares[i, j].Terrain == MapTerrain.Corridor)
{
baseMap.mapSquares[i, j].Terrain = MapTerrain.Empty;
}
}
}
//Do a final pass to convert Wall into something more exciting
if (wallType.Count > 0)
{
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
if (baseMap.mapSquares[i, j].Terrain == MapTerrain.Wall)
{
baseMap.mapSquares[i, j].Terrain = wallType[rand.Next(wallType.Count)];
}
}
}
}
return baseMap.Clone();
}