static public void MakeRoom(ref AreaMap new_map, ref AreaMapType template)
{
RoomTypes room_type = RoomTypes.NULL;
// loads a random RoomTypes into local var room_typr and returns room_index;
// room_index matches a room in List<MapRoomTypes> in AreaMap
template.currRoomTypeIndex = GetRoomTypeProb(ref template, ref room_type);
switch (room_type)
{
case RoomTypes.RECTANGLE:
SetRectRoomArea(ref new_map, ref template);
if (Globals.roomFail)
{
break;
}
foreach (Point sqr in new_map.RoomList[MapGenHelper.roomCounter].AllSquares)
{
MapGenHelper.PreToRoomOrWall(ref new_map, sqr, MapGenHelper.roomCounter);
}
SetRoomBarrier(ref new_map, ref template, MapGenHelper.roomCounter);
MakeRoomArea(ref new_map, ref template);
MapGenHelper.roomCounter++;
break;
}
}
static public void LoadMapSet(MapSets map_set, ref AreaMapType map_template)
{
line = string.Empty;
try
{
System.IO.Stream stream = TitleContainer.OpenStream(mapSetNames[(int)map_set]); // <------ this is where the MapSets enum is used
System.IO.StreamReader map_set_txt_file = new System.IO.StreamReader(stream);
if ((line = map_set_txt_file.ReadLine()) == "START")
{
GetName(ref map_template, "MAP_SET_NAME", ref map_set_txt_file);
GetMapType(ref map_template, "MAP_TYPE", ref map_set_txt_file);
GetRoomTypes(ref map_template, "ROOM_TYPES", ref map_set_txt_file);
GetRoomTypeProbabilities(ref map_template, "ROOM_PROBABILITIES", ref map_set_txt_file);
GetRoomSizesRange(ref map_template, "ROOM_SIZES_RANGE", ref map_set_txt_file);
GetRoomBarriers(ref map_template, "ROOM_BARRIER_SIZES", ref map_set_txt_file);
GetTileSets(ref map_template, "TILE_SETS", ref map_set_txt_file);
}
map_set_txt_file.Close();
}
catch (System.IO.FileNotFoundException)
{
//temp_game.Exit();
}
}
static private void GetRoomSizesRange(ref AreaMapType template, string start, ref System.IO.StreamReader reader)
{
line = reader.ReadLine();
int try_room;
int room = 0;
if (line == start)
{
while ((line = reader.ReadLine()) != lineStop)
{
if (CheckLine(ref line) == TileSetFlags.OK)
{
if (Int32.TryParse(line, out try_room)) // get room #
{
room = try_room;
template.roomSizesRange.Add(new List <Sizes>());
}
else
{
template.roomSizesRange[room].Add(StringToRoomSizesRange(line));
}
}
}
}
}
static public void SetRectRoomArea(ref AreaMap new_map, ref AreaMapType template)
{
Rectangle room_rect = Rectangle.Empty; // origin of room to be created, in tiles
int room_x_max = 0;
int room_y_max = 0;
MakeRectUntil(ref room_rect, ref new_map, ref template, 100); // <------------ rects made
if (Globals.roomFail)
{
return;
}
// add room to AreaMap room list
new_map.RoomList.Add(new Room(MapGenHelper.roomCounter, room_rect));
room_x_max = (room_rect.X + room_rect.Width);
room_y_max = (room_rect.Y + room_rect.Height);
// minimum room x tile coordinate index to maximum room x tile index, inclusive
for (int x = room_rect.X; x < room_x_max; x++)
{
for (int y = room_rect.Y; y < room_y_max; y++) // same, with y
{
MakePreRoomSqr(ref new_map.MSGrid[y][x], MapGenHelper.roomCounter);
new_map.RoomList[MapGenHelper.roomCounter].AllSquares.Add(new Point(x, y));
}
}
//roomMakeFail = false;
}
static public Sizes GetRndRmSize(ref AreaMapType template, int room_index)
{
int size_index = 0;
size_index = rand.Next(0, template.roomSizesRange[room_index].Count() - 1);
return(template.roomSizesRange[room_index][size_index]);
}
static public void GenerateMap(ref AreaMap current_map, ref List <string> currMapTexNames, MapSets map_set, Sizes map_size,
ref List <int> dcRoomList)
{
areaMapType = new AreaMapType();
LoadMapSet(map_set, ref areaMapType);
MapGenHelper.MakeMap(ref current_map, ref areaMapType, ref currMapTexNames, map_size);
MapGenHelper.GetMapData(ref dcRoomList);
}
static public void MakeMap(ref AreaMap new_map, ref AreaMapType template,
ref List <string> currMapTexNames, Sizes size)
{
int prev_dc_count = 0;
Point m_size_range = Point.Zero;
m_size_range = Globals.GetSizeRange(MakeTarget.MAP, size);
// get map size
template.mapWidthTile = rand.Next(m_size_range.X, m_size_range.Y);
template.mapHeightTile = template.mapWidthTile;
// load possible TileSets from template to TileSetManager
for (int set = 0; set < template.tsNameIndices.Count(); set++)
{
TileSetManager.LoadTileSet(template.tsNameIndices[set], set);
}
// load template into new AreaMap
new_map = new AreaMap(ref template);
if (new_map.areaMapType == MapTypes.ROOMS)
{
List <List <Point> > hall_path = new List <List <Point> >();
RoomMaker.MakeRooms(ref new_map, ref template);
HallMaker.ConnectRooms(ref new_map, ref hall_path, 1);
HallMaker.MakeHalls(ref new_map, ref hall_path);
while (!HallMaker.FloodIsConnectedCheck(ref new_map, false))
{
if (prev_dc_count > 0)
{
if (prev_dc_count <= disconnectedRooms.Count())
{
break;
}
}
hall_path.Clear();
HallMaker.ConnectDCRooms(ref new_map, ref hall_path, 1);
HallMaker.MakeHalls(ref new_map, ref hall_path);
prev_dc_count = disconnectedRooms.Count();
}
}
else if (new_map.areaMapType == MapTypes.OPEN)
{
}
else if (new_map.areaMapType == MapTypes.ENCLOSED_ROOMS)
{
}
CopyMapTexNames(ref currMapTexNames);
}
static public void MakeRooms(ref AreaMap new_map, ref AreaMapType template)
{
while (!Globals.roomFail)
{
MakeRoom(ref new_map, ref template);
if (Globals.roomFail)
{
break;
}
}
}
// 1) Gets random TileSet index for Room from LoadedTileSets
// 2) Calls AddTextureName, which adds the TileSet name to this.mapEngineTextureNames
// and current AreaMap.TextureNameList
static public void MakeRoomArea(ref AreaMap new_map, ref AreaMapType template)
{
int rand_tile_set_index = 0;
rand_tile_set_index = rand.Next(0, MapGenHelper.LoadedTileSets.Count());
MapGenHelper.CurrentTileSet = MapGenHelper.LoadedTileSets[rand_tile_set_index];
foreach (Point sqr in new_map.RoomList[MapGenHelper.roomCounter].AllSquares)
{
MapGenHelper.AddTextureName(ref new_map, ref new_map.MSGrid[sqr.Y][sqr.X], MapGenHelper.LoadedTileSets[rand_tile_set_index].TextureName);
MapGenHelper.AddRoomSqrTile(ref new_map, ref new_map.MSGrid[sqr.Y][sqr.X], sqr.X, sqr.Y);
}
}
static private void GetName(ref AreaMapType template, string start, ref System.IO.StreamReader reader)
{
line = reader.ReadLine();
if (line == start)
{
while ((line = reader.ReadLine()) != lineStop)
{
if (CheckLine(ref line) == TileSetFlags.OK)
{
template.name = line;
}
}
}
}
static private void GetTileSets(ref AreaMapType template, string start, ref System.IO.StreamReader reader)
{
line = reader.ReadLine();
if (line == start)
{
while ((line = reader.ReadLine()) != lineStop)
{
if (CheckLine(ref line) == TileSetFlags.OK)
{
template.tsNameIndices.Add(StringToTSNameIndex(line));
}
}
}
}
static private void GetRoomBarriers(ref AreaMapType template, string start, ref System.IO.StreamReader reader)
{
line = reader.ReadLine();
if (line == start)
{
while ((line = reader.ReadLine()) != lineStop)
{
if (CheckLine(ref line) == TileSetFlags.OK)
{
template.roomBarrierSizes.Add(Convert.ToInt32(line));
}
}
}
}
static public int GetRoomTypeProb(ref AreaMapType template, ref RoomTypes room_type)
{
int room_prob = rand.Next(0, 101); int room_index = 0;
for (int room = 0; room < template.roomTypeProbs.Count - 1; room++)
{
if (room_prob > template.roomTypeProbs[room])
{
continue;
}
else
{
room_index = room;
}
}
room_type = template.roomTypes[room_index];
return(room_index);
}
static public float MakeRectUntil(ref Rectangle rect, ref AreaMap new_map, ref AreaMapType template, int max_fails)
{
int tries = 0;
int fails = 0;
float fail_rate = 0f;
Sizes r_size = Sizes.NULL;
Point r_sizep = Point.Zero;
while (fails < max_fails)
{
tries++;
r_size = GetRndRmSize(ref template, template.currRoomTypeIndex);
template.currRoomSize = r_size;
r_sizep = new Point(Globals.sizeRanges[(int)r_size], Globals.sizeRanges[(int)r_size + 1]);
MakeRect(ref rect, ref new_map, ref template, ref r_sizep);
if (!new_map.ChkRectForAllFlagged(ref new_map, ref rect, MSFlag.BL, MSFlagIndex.BL_ST) ||
!new_map.ChkRectForAllFlagged(ref new_map, ref rect, MSFlag.MAKE_OK, MSFlagIndex.CAN_MAKE))
{
Globals.roomFail = true;
}
else
{
Globals.roomFail = false;
}
if (Globals.roomFail)
{
fails++;
}
else
{
break;
}
}
fail_rate = (float)tries / (float)fails;
return(fail_rate);
}
static private void GetRoomTypeProbabilities(ref AreaMapType template, string start, ref System.IO.StreamReader reader)
{
line = reader.ReadLine();
if (line == start)
{
int prev_prob = 0; int curr_prob = 0;
while ((line = reader.ReadLine()) != lineStop)
{
if (CheckLine(ref line) == TileSetFlags.OK)
{
curr_prob = Convert.ToInt32(line);
curr_prob += prev_prob;
template.roomTypeProbs.Add(curr_prob);
prev_prob = curr_prob;
}
}
}
}
static public void SetRoomBarrier(ref AreaMap new_map, ref AreaMapType template, int room_ID)
{
if (template.roomBarrierSizes[template.currRoomTypeIndex] != 0)
{
int x = 0;
int y = 0;
int wave = 0;
int old_wave = 1;
int wave_size = 0; // size of PREVIOUS wave
int wave_counter = 0; // tracker for size of CURRENT wave
int no_make_size = template.roomBarrierSizes[template.currRoomTypeIndex] - 1;
Point offset = Point.Zero;
List <List <Point> > waves = new List <List <Point> >();
waves.Add(new List <Point>());
waves.Add(new List <Point>());
// first iteration through wall square list, populates first "wave"
foreach (Point sqr in new_map.RoomList[MapGenHelper.roomCounter].WallSquares)
{
for (int dir = 0; dir < Globals.NumDirects; dir += Globals.AllDirItr)
{
offset = Globals.Directions[dir];
x = sqr.X; y = sqr.Y; x += offset.X; y += offset.Y;
if (!new_map.OffMap(x, y))
{
if (new_map.MSGrid[y][x].RoomID != room_ID)
{
if (new_map.MSGrid[y][x].MSStates[(int)MSFlagIndex.CAN_MAKE] != MSFlag.NO_MAKE)
{
new_map.MSGrid[y][x].MSStates[(int)MSFlagIndex.CAN_MAKE] = MSFlag.NO_MAKE;
waves[wave].Add(new Point(x, y));
wave_size++;
//new_map.MSGrid[y][x].TileColor = Color.Blue;
}
}
}
}
}
// loops back and forth between waves
for (int wv = 0; wv < no_make_size; wv++)
{
if (wave > 0)
{
wave = 0;
old_wave = 1;
}
else
{
wave = 1;
old_wave = 0;
}
for (int wav = 0; wav < wave_size; wav++)
{
for (int dir = 0; dir < Globals.NumDirects; dir += Globals.AllDirItr)
{
offset = Globals.Directions[dir];
x = waves[old_wave][wav].X; y = waves[old_wave][wav].Y;
x += offset.X; y += offset.Y;
if (!new_map.OffMap(x, y))
{
if (new_map.MSGrid[y][x].RoomID != room_ID)
{
if (new_map.MSGrid[y][x].MSStates[(int)MSFlagIndex.CAN_MAKE] != MSFlag.NO_MAKE)
{
new_map.MSGrid[y][x].MSStates[(int)MSFlagIndex.CAN_MAKE] = MSFlag.NO_MAKE;
if (wav < waves[wave].Count)
{
waves[wave][wav] = new Point(x, y);
}
else
{
waves[wave].Add(new Point(x, y));
}
wave_counter++;
//if(wave == 0)
// new_map.MSGrid[y][x].TileColor = Color.Aqua;
//else
// new_map.MSGrid[y][x].TileColor = Color.Green;
}
}
}
}
}
wave_size = wave_counter;
wave_counter = 0;
}
}
}
static public void MakeRect(ref Rectangle rect, ref AreaMap new_map,
ref AreaMapType template, ref Point r_size)
{
MakeRndRect(ref rect, ref new_map.xRange, ref new_map.yRange, ref r_size, ref r_size);
}
