public async Task Genrate()
{
_startingpos = (StartingPosition)NumGen.Next(0, 5) /*StartingPosition.Center*/;
LogToUiThread($"Starting position : {_startingpos}");
int roomcount = _dp.RoomNumber.Next();
LogToUiThread($"Generating {roomcount} rooms");
for (int i = 0; i < roomcount; i++)
{
bool isFirst = i == 0;
Direction dir = Direction.North;
if (isFirst)
{
dir = GetDirByStartupPos();
}
else
{
dir = (Direction)NumGen.Next(0, 4);
}
var r = await GenerateRoom(dir, (Corridors.Count > 0)?Corridors[i - 1] : null, (isFirst));
Rooms.Add(r);
//si dernière salle, pas couloir
if (i < roomcount - 1)
{
var c = await GenerateCorridor(r);
Corridors.Add(c);
}
}
}
public void GetAllRoomsAndCorridors()
{
Rooms.Clear();
Corridors.Clear();
ClearAllSpaces(TileMap, NumColumns, NumRows);
DetermineSpaceTypes();
for (int column = 0; column < NumColumns; column++)
{
for (int row = 0; row < NumRows; row++)
{
Tile activeSpace = GetFloorSpace(column, row);
if (activeSpace == null)
{
continue;
}
if (activeSpace.SpaceType == SpaceType.Room)
{
if (activeSpace.Parent == null)
{
Rooms.Add(CreateRoomFromSpace(activeSpace));
}
}
else if (activeSpace.SpaceType == SpaceType.Corridor)
{
if (activeSpace.Parent == null)
{
Corridors.Add(CreateCorridorFromSpace(activeSpace));
}
}
}
}
}
private void Window_Initialized(object sender, EventArgs e)
{
Dispatcher.Invoke(new Action(() => {
cmbPair.ResetText();
cmbLotsToTradeBuy.ResetText();
cmbLotsToTradeSell.ResetText();
if (pair == "")
{
MessageBox.Show("Pair is not selected!");
return;
}
if (isMainWindow)
{
System.IO.File.Delete(logFileName);
}
fw = new Order2GoAddIn.FXCoreWrapper(app.FXCM);
chartingWindow = new HedgeHog.Charting(this.Name, fw);
corridorsWindow = new Corridors(this.Name);
chartingWindow.TicksChanged += chartingWindow_TicksChanged;
chartingWindow.PriceGridChanged += ProcessPrice;
chartingWindow.PriceGridError += chartingWindow_PriceGridError;
dataGrid1.AutoGeneratingColumn += new EventHandler <Microsoft.Windows.Controls.DataGridAutoGeneratingColumnEventArgs>(dataGrid1_AutoGeneratingColumn);
RaisePropertyChanged(() => title);
}));
//Window w = sender as Window;
//w.Height = Properties.Settings.Default.MainWindowSize.Height;
//w.Width = Properties.Settings.Default.MainWindowSize.Width;
//w.Top = Properties.Settings.Default.MainWindowPos.Y;
//w.Left = Properties.Settings.Default.MainWindowPos.X;
}
void GetTilesAndRoomsFromFlyweights()
{
foreach (Guid guid in flyweights.Keys)
{
JObject jObject = flyweights[guid] as JObject;
JToken typeNameToken = jObject.GetValue("TypeName");
string typeName = typeNameToken.ToString();
switch (typeName)
{
case "MapCore.Tile":
Tile tile = jObject.ToObject <Tile>();
Tiles.Add(tile);
reconstitutedFlyweights[guid] = tile;
break;
case "MapCore.MapRegion":
MapRegion mapRegion = jObject.ToObject <MapRegion>();
reconstitutedFlyweights[guid] = mapRegion;
if (mapRegion.RegionType == RegionType.Room)
{
Rooms.Add(mapRegion);
}
else if (mapRegion.RegionType == RegionType.Corridor)
{
Corridors.Add(mapRegion);
}
break;
}
}
}
/// <summary>
/// Private function conforming the Corridors to other Story Room lists.
/// </summary>
private void FitCorridors()
{
var corridors = Corridors.ToList();
Corridors.Clear();
foreach (var corridor in corridors)
{
AddCorridor(corridor);
}
}
/// <summary>
/// Adds a Room to the Corridors list.
/// </summary>
/// <param name="room">Room to add.</param>
/// <param name="fit">Indicates whether the new corridor should mutually fit to other Story features.</param>
/// <param name="merge">Indicates whether the new corridor should merge with other corridors.</param>
/// <returns>
/// True if one or more rooms were added to the Story.
/// </returns>
public bool AddCorridor(Room room, bool fit = true, bool merge = true)
{
if (Perimeter == null || room.Perimeter == null || !Perimeter.Covers(perimeter))
{
return(false);
}
var newRoom =
new Room()
{
Color = room.Color,
Elevation = Elevation,
Height = room.Height,
Name = room.Name,
Perimeter = room.Perimeter
};
var fitRooms = new List <Room> {
newRoom
};
if (fit)
{
var toRooms = new List <Room>(Exclusions);
toRooms.AddRange(Services);
fitRooms = FitRooms(fitRooms, toRooms, false);
Rooms = FitRooms(Rooms, fitRooms);
}
if (fitRooms.Count == 0)
{
return(false);
}
Corridors.AddRange(fitRooms);
var merged = Shaper.Merge(CorridorsAsPolygons);
if (merge && merged.Count < Corridors.Count)
{
Corridors.Clear();
foreach (var corridor in merged)
{
Corridors.Add(
new Room()
{
Color = room.Color,
Elevation = Elevation,
Height = room.Height,
Name = room.Name,
Perimeter = corridor
});
}
}
return(true);
}
public void AddCorridor(string firstName, string secondName)
{
var nodeFirst = FindNode(firstName);
var nodeSecond = FindNode(secondName);
if (nodeFirst == null || nodeSecond == null)
{
return;
}
nodeFirst.AddCorridor(nodeSecond);
nodeSecond.AddCorridor(nodeFirst);
Corridors.Add(new GraphCorridor(LastIdCorridor, nodeFirst, nodeSecond));
LastIdCorridor++;
}
public void ConnectRooms()
{
var rooms = AllRooms;
Corridors.Add(1, 2, rooms);
Corridors.Add((1), (3), rooms);
Corridors.Add((1), (4), rooms);
Corridors.Add((2), (6), rooms);
Corridors.Add((2), (999), rooms, 2, true);
Corridors.Add((3), (7), rooms, 2);
Corridors.Add((4), (8), rooms);
Corridors.Add((4), (999), rooms, 2, true);
Corridors.Add((5), (999), rooms, 2, true);
Corridors.Add((5), (6), rooms);
Corridors.Add((5), (10), rooms, 2);
Corridors.Add((6), (7), rooms);
Corridors.Add((6), (11), rooms);
Corridors.Add((7), (8), rooms);
Corridors.Add((8), (9), rooms);
Corridors.Add((8), (11), rooms);
Corridors.Add((9), (12), rooms, 2);
Corridors.Add((9), (999), rooms, 1, true);
Corridors.Add((10), (13), rooms, 2);
Corridors.Add((11), (14), rooms);
Corridors.Add((11), (15), rooms);
Corridors.Add((12), (16), rooms, 2);
;
Corridors.Add((13), (14), rooms);
Corridors.Add((13), (19), rooms);
;
Corridors.Add((14), (17), rooms);
Corridors.Add((14), (999), rooms, 1, true);
Corridors.Add((15), (18), rooms);
Corridors.Add((15), (16), rooms);
Corridors.Add((15), (999), rooms, 1, true);
;
;
Corridors.Add((16), (21), rooms);
Corridors.Add((17), (19), rooms);
Corridors.Add((17), (20), rooms, 2);
Corridors.Add((18), (20), rooms, 2);
Corridors.Add((18), (21), rooms);
;
Corridors.Add((19), (999), rooms, 2, true);
Corridors.Add((21), (999), rooms, 2, true);
}
/// <summary>
/// Private function configuring all Corridor perimeters to conform to all Service perimeters.
/// </summary>
/// <returns>
/// None.
/// </returns>
private void FitCorridorsToServices()
{
foreach (Room service in Services)
{
if (service.Perimeter == null)
{
continue;
}
int index = 0;
List <int> indices = new List <int>();
var addRooms = new List <Room>();
foreach (Room room in Corridors)
{
var perimeters = room.Perimeter.Difference(service.Perimeter);
if (perimeters != null && perimeters.Count > 0)
{
room.Perimeter = perimeters.First();
for (int i = 1; i < perimeters.Count; i++)
{
var addRoom = new Room()
{
Color = room.Color,
Elevation = room.Elevation,
Height = room.Height,
Name = room.Name,
Perimeter = perimeters[i]
};
addRooms.Add(addRoom);
}
}
else
{
indices.Add(index);
}
index++;
}
foreach (int remove in indices)
{
Corridors.RemoveAt(remove);
}
if (addRooms.Count > 0)
{
Corridors.AddRange(addRooms);
}
}
}
/// <summary>
/// Attempt to build a corridor at the end of a random corridor.
/// </summary>
/// <returns>
/// True if a corridor was built. Otherwise, false.
/// </returns>
private bool BuildCorridorOnCorridorEnd()
{
for (int attempt = 0; attempt < MaximumAttempts; attempt++)
{
int directionAwayFromCorridor;
Vector2 corridorEndpoint = GetEndOfCorridor(out directionAwayFromCorridor);
Rect corridor = GetCorridor(corridorEndpoint, directionAwayFromCorridor);
if (RectangleFits(corridor))
{
Corridors.Add(corridor);
BuildRectangle(corridor);
return(true);
}
}
return(false);
}
/// <summary>
/// Creates a rectangular corridor Room from a centerline axis, width, and height, at the Story elevation.
/// Adds the new Room to the Corrdors list.
/// Corridors conform to Service perimeters.
/// Corridors change intersecting Room perimeters to conform to the corridor's perimeter.
/// </summary>
/// <param name="axis">Center Line of the corridor.</param>
/// <param name="width">Width of the corridor.</param>
/// <param name="height">Height of the corridor.</param>
/// <param name="name">String identifier.</param>
/// <param name="color">Rendering color of the Room as a Space.</param>
/// <returns>
/// None.
/// </returns>
public void AddCorridor(Line axis,
double width = 2.0,
double height = 3.0,
string name = "",
Color color = null)
{
var corridor = new Room()
{
Color = color,
Elevation = Elevation,
Height = height,
Name = name
};
corridor.MakePerimeter(axis, width);
Corridors.Add(corridor);
FitCorridorsToServices();
FitRoomsToCorridors();
}
/// <summary>
/// Attempt to build a corridor on the side of a room.
/// </summary>
/// <returns>
/// True if a corridor was built. Otherwise, false.
/// </returns>
private bool BuildCorridorOnRoomEdge()
{
for (int attempt = 0; attempt < MaximumAttempts; attempt++)
{
int direction;
Vector2 door = GetRoomEdge(out direction);
Rect corridor = GetCorridor(door, direction);
if (RectangleFits(corridor))
{
Corridors.Add(corridor);
BuildRectangle(corridor);
Map[(int)door.x, (int)door.y] = (int)MapElements.Door;
Doors.Add(door);
return(true);
}
}
return(false);
}
/// <summary>
/// Adds a Room to the Corridors list.
/// </summary>
/// <param name="room">Room to add.</param>
/// <returns>
/// True if one or more Rooms were added.
/// </returns>
public bool AddCorridor(Room room,
bool merge = true,
double tolerance = 0.0,
double minLength = 0.0)
{
var perimeters = Shaper.FitWithin(room.Perimeter, Perimeter);
if (perimeters.Count == 0)
{
return(false);
}
var fitAmong = new List <Polygon>(OpeningsAsPolygons);
fitAmong.AddRange(ExclusionsAsPolygons);
fitAmong.AddRange(ServicesAsPolygons);
var corridors = Shaper.Differences(perimeters, fitAmong).ToList();
if (corridors.Count() == 0)
{
return(false);
}
corridors.AddRange(CorridorsAsPolygons);
if (merge)
{
corridors = Shaper.Merge(corridors);
}
Corridors.Clear();
foreach (var corridor in corridors)
{
Corridors.Add(
new Room(room)
{
Elevation = Elevation,
Height = room.Height,
Perimeter = corridor
});
}
FitRooms();
return(true);
}
/// <summary>
/// Creates a corridor Room from a perimeter and height, at the Story elevation.
/// Adds the new Room to the Corrdors list.
/// Corridors conform to Service perimeters.
/// Corridors change intersecting Room perimeters to conform to the corridor's perimeter.
/// </summary>
/// <param name="perimeter">Polygon perimeter of the corridor.</param>
/// <param name="height">Height of the corridor.</param>
/// <param name="name">String identifier.</param>
/// <param name="color">Rendering color of the Room as a Space.</param>
/// <returns>
/// None.
/// </returns>
public void AddCorridor(Polygon perimeter,
double height = 3.0,
string name = "",
Color color = null)
{
if (Perimeter == null)
{
throw new ArgumentNullException(Messages.PERIMETER_NULL_EXCEPTION);
}
var corridor = new Room()
{
Color = color,
Elevation = elevation,
Height = height,
Name = name,
Perimeter = perimeter
};
Corridors.Add(corridor);
FitCorridorsToServices();
FitRoomsToCorridors();
}
/// <summary>
/// Adds a Room to the Corridors list.
/// </summary>
/// <param name="room">Room to add.</param>
/// <param name="fit">Indicates whether the new room should mutually fit to other Story features. Default is true.</param>
/// <returns>
/// True if one or more rooms were added to the Story.
/// </returns>
public bool AddCorridor(Room room, bool fit = true)
{
if (Perimeter == null || room.Perimeter == null)
{
throw new ArgumentNullException(Messages.PERIMETER_NULL_EXCEPTION);
}
if (!Perimeter.Covers(perimeter))
{
throw new ArgumentNullException(Messages.PERIMETER_PLACEMENT_EXCEPTION);
}
var newRoom =
new Room()
{
Color = room.Color,
Elevation = Elevation,
Height = room.Height,
Name = room.Name,
Perimeter = room.Perimeter
};
var fitRooms = new List <Room> {
newRoom
};
if (fit)
{
var toRooms = new List <Room>(Exclusions);
toRooms.AddRange(Services);
fitRooms = FitRooms(fitRooms, toRooms, false);
Rooms = FitRooms(Rooms, fitRooms);
}
if (fitRooms.Count == 0)
{
return(false);
}
Corridors.AddRange(fitRooms);
return(true);
}
private static void Aux_MakeRandomCorridor(ref char[][] map, MapMeta meta, Point coord, List <Corridors> corridors)
{
int headTo = RandomNumber.Between(0, 4);
int direction = RandomNumber.Between(0, 3); // +/- , + , -
int lengthPositive = 0, lengthNegative = 0;
Stack <Point> path = new Stack <Point>();
Point baseCoord = new Point(coord.X, coord.Y);
if (direction == 0)
{
lengthPositive = RandomNumber.Between(meta.MinCorridorStraight, meta.MaxCorridorStraight);
lengthNegative = RandomNumber.Between(meta.MinCorridorStraight, meta.MaxCorridorStraight);
}
else if (direction == 1)
{
lengthPositive = RandomNumber.Between(meta.MinCorridorStraight, meta.MaxCorridorStraight);
}
else
{
lengthNegative = RandomNumber.Between(meta.MinCorridorStraight, meta.MaxCorridorStraight);
}
for (int i = 0; i < lengthPositive; i++)
{
switch (headTo)
{
case N:
case S:
coord.Y++; break;
case W:
case E:
coord.X++; break;
default:
break;
}
if (coord.X + 1 > meta.MapSizeX)
{
coord.X--; continue;
}
else if (coord.Y + 1 > meta.MapSizeY)
{
coord.Y--; continue;
}
if (map[(int)coord.X][(int)coord.Y] != (char)TileType.FLOOR_START)
{
map[(int)coord.X][(int)coord.Y] = (char)TileType.FLOOR;
}
path.Push(coord);
}
coord = baseCoord;
for (int i = 0; i < lengthNegative; i++)
{
switch (headTo)
{
case N:
case S:
coord.Y--; break;
case W:
case E:
coord.X--; break;
default:
break;
}
if (coord.X - 1 < 0)
{
coord.X++; continue;
}
else if (coord.Y - 1 < 0)
{
coord.Y++; continue;
}
if (map[(int)coord.X][(int)coord.Y] != (char)TileType.FLOOR_START)
{
map[(int)coord.X][(int)coord.Y] = (char)TileType.FLOOR;
}
path.Push(coord);
}
Corridors crd = new Corridors
{
CorridorData = path,
IsBranch = true,
CorridorStartAt = -1,
CorridorEndAt = -1,
};
corridors.Add(crd);
}
private static void Stage4_ConnectRooms(
ref char[][] map,
MapMeta meta,
List <RoomMeta> rooms,
List <Corridors> corridors,
int overrideRoomStart,
int overrideRoomTarget)
{
bool completeFlag = false;
bool overrideFlag = false;
if (overrideRoomStart != 0 || overrideRoomTarget != 0)
{
overrideFlag = true;
}
if (meta.MaxRoomNumber != rooms.Count)
{
meta.MaxRoomNumber = rooms.Count;
}
while (completeFlag == false)
{
Stack <Point> stack = new Stack <Point>();
int targetRoom = RandomNumber.Between(1, meta.MaxRoomNumber - 1);
int startRoom = 0;
int maxConn = RandomNumber.Between(1, meta.MaxRoomConnection);
for (int i = 0; i < rooms.Count; i++)
{
if (rooms[i].Connections < maxConn)
{
startRoom = i;
break;
}
// there is no more room that 0 connection
if (i == rooms.Count - 1)
{
completeFlag = true;
}
}
if (overrideFlag)
{
startRoom = overrideRoomStart;
targetRoom = overrideRoomTarget;
completeFlag = true;
}
// starting position
stack.Push(new Point {
X = rooms[startRoom].X, Y = rooms[startRoom].Y
});
Point start = stack.Pop();
int curX = (int)start.X;
int curY = (int)start.Y;
double dist = double.MaxValue;
int cs = RandomNumber.Between(meta.MinCorridorStraight, meta.MaxCorridorStraight);
int headTo = 0;
while (dist > 1.412)
{
// Readjust point that out of bound
double distN = (new Point(curX, curY + 1) - new Point(rooms[targetRoom].X, rooms[targetRoom].Y)).LengthSquared;
double distS = (new Point(curX, curY - 1) - new Point(rooms[targetRoom].X, rooms[targetRoom].Y)).LengthSquared;
double distW = (new Point(curX - 1, curY) - new Point(rooms[targetRoom].X, rooms[targetRoom].Y)).LengthSquared;
double distE = (new Point(curX + 1, curY) - new Point(rooms[targetRoom].X, rooms[targetRoom].Y)).LengthSquared;
double min = Math.Min(distE, Math.Min(distW, Math.Min(distN, distS)));
// Corridor twister here (set on meta) - 0, 4 = 25%
int rb = RandomNumber.Between(0, meta.RouteTwistFactor);
if (rb == 0)
{
int rc = RandomNumber.Between(0, 4);
if (rc == N)
{
min = distN;
}
else if (rc == S)
{
min = distS;
}
else if (rc == W)
{
min = distW;
}
else if (rc == E)
{
min = distE;
}
}
dist = min;
// Boundary check
if (curX > meta.MapSizeX)
{
curX--; continue;
}
else if (curY > meta.MapSizeY)
{
curY--; continue;
}
else if (curX - 1 < 0)
{
curX++; continue;
}
else if (curY - 1 < 0)
{
curY++; continue;
}
// Push cursor
if (min == distN)
{
stack.Push(new Point {
X = curX, Y = ++curY
}); headTo = N;
}
if (min == distS)
{
stack.Push(new Point {
X = curX, Y = --curY
}); headTo = S;
}
if (min == distW)
{
stack.Push(new Point {
X = --curX, Y = curY
}); headTo = W;
}
if (min == distE)
{
stack.Push(new Point {
X = ++curX, Y = curY
}); headTo = E;
}
// Make corridor straight
int straight = RandomNumber.Between(0, meta.RouteDirectFactor);
if (straight == 0)
{
cs = RandomNumber.Between(meta.MinCorridorStraight, meta.MaxCorridorStraight);
switch (headTo)
{
case N:
for (int i = 0; i < cs; i++)
{
stack.Push(new Point {
X = curX, Y = ++curY
});
}
break;
case S:
for (int i = 0; i < cs; i++)
{
stack.Push(new Point {
X = curX, Y = --curY
});
}
break;
case W:
for (int i = 0; i < cs; i++)
{
stack.Push(new Point {
X = --curX, Y = curY
});
}
break;
case E:
for (int i = 0; i < cs; i++)
{
stack.Push(new Point {
X = ++curX, Y = curY
});
}
break;
default:
break;
}
}
}
// Save corridors data
Stack <Point> tmp = new Stack <Point>();
tmp = CopyStack.Clone(stack);
Corridors crd = new Corridors
{
CorridorData = tmp,
IsBranch = false,
CorridorStartAt = startRoom,
CorridorEndAt = targetRoom,
};
corridors.Add(crd);
// Draw path
while (stack.Count > 0)
{
Point pt = stack.Pop();
if (pt.X < meta.MapSizeX &&
pt.X >= 0 &&
pt.Y < meta.MapSizeY &&
pt.Y >= 0)
{
if (map[(int)pt.X][(int)pt.Y] != (char)TileType.FLOOR_START)
{
map[(int)pt.X][(int)pt.Y] = (char)TileType.FLOOR;
}
}
}
// Add connections
rooms[startRoom].Connections++;
rooms[targetRoom].Connections++;
}
}
public void AddCorridors()
{
VectQuater aux;
bool canCreate;
int cardinal;
foreach (Room room in rooms)
{
//Main Corridor
cardinal = 0;
canCreate = true;
if (room is Triangle)
{
while (!room.PrevRoom[cardinal])
{
cardinal++;
}
aux = room.CorridorCreator(cardinal);
for (int j = 0; j < nCInitialized; j++)
{
if (aux.vector3 == posNoCorr[j])
{
continue;
}
}
posCorr[cInitialized] = aux.vector3;
posNoCorr[nCInitialized] = aux.vector3;
cInitialized++;
nCInitialized++;
if (aux.quaternion.eulerAngles.y == 90 ||
aux.quaternion.eulerAngles.y == 270)
{
Corridors.Add(new CorrH(aux.vector3, aux.quaternion, cInitialized));
}
else
{
Corridors.Add(new CorrV(aux.vector3, aux.quaternion, cInitialized));
}
continue;
}
if (!(room is Octagon))
{
room.ActualizeCanCreate(ref posRooms, rInitialized);
}
while (!room.PrevRoom[cardinal])
{
cardinal++;
}
aux = room.CorridorCreator(cardinal);
for (int j = 0; j < nCInitialized; j++)
{
if (canCreate && aux.vector3 == posNoCorr[j])
{
canCreate = false;
}
}
if (canCreate)
{
room.Corridors[cardinal] = true;
posCorr[cInitialized] = aux.vector3;
posNoCorr[nCInitialized] = aux.vector3;
cInitialized++;
nCInitialized++;
if (aux.quaternion.eulerAngles.y == 90 ||
aux.quaternion.eulerAngles.y == 270)
{
Corridors.Add(new CorrH(aux.vector3, aux.quaternion, cInitialized));
}
else
{
Corridors.Add(new CorrV(aux.vector3, aux.quaternion, cInitialized));
}
}
if (room is Octagon)
{
continue;
}
//Other Corridors
for (int i = 0; i < room.CanCreateSq.Length; i++)
{
if (!room.CanCreateSq[i] && i != cardinal &&
Random.Range(0, 10) < properties.ProbCorrid)
{
aux = room.CorridorCreator(i);
for (int j = 0; j < nCInitialized; j++)
{
if (canCreate && aux.vector3 == posNoCorr[j])
{
canCreate = false;
}
}
if (canCreate)
{
room.Corridors[i] = true;
posCorr[cInitialized] = aux.vector3;
posNoCorr[nCInitialized] = aux.vector3;
cInitialized++;
nCInitialized++;
if (aux.quaternion.eulerAngles.y == 90 ||
aux.quaternion.eulerAngles.y == 270)
{
Corridors.Add(new CorrH(aux.vector3, aux.quaternion, cInitialized));
}
else
{
Corridors.Add(new CorrV(aux.vector3, aux.quaternion, cInitialized));
}
}
}
}
} //foreach ends
}
/// <summary>
/// Creates a grid network of corridors within the Story and returns a list of spatially sorted RoomRows ready for population.
/// </summary>
/// <param name="rowLength">Distance between cross corridors.</param>
/// <param name="roomDepth">Desired depth of Rooms.</param>
/// <param name="corridorWidth">Width of all corridors.</param>
/// <returns>A List of RoomRow</returns>
public List <RoomRow> PlanGrid(double rowLength, double rowDepth, double corridorWidth = 3.0, bool split = true)
{
Corridors.Clear();
Rooms.Clear();
rowLength = rowLength.NearEqual(0.0) ? 1.0 : Math.Abs(rowLength);
rowDepth = rowLength.NearEqual(0.0) ? 1.0 : Math.Abs(rowDepth);
corridorWidth = rowLength.NearEqual(0.0) ? 1.0 : Math.Abs(corridorWidth);
var row = Perimeter.Segments().OrderByDescending(s => s.Length()).First();
var ang = Math.Atan2(row.End.Y - row.Start.Y, row.End.X - row.Start.X) * (180 / Math.PI);
var perimeterJig = Perimeter.Rotate(Vector3.Origin, ang * -1);
var grid = new Grid2d(perimeterJig);
grid.U.DivideByFixedLength(rowLength, FixedDivisionMode.RemainderAtBothEnds);
grid.V.DivideByFixedLength(rowDepth, FixedDivisionMode.RemainderAtBothEnds);
var uLines = grid.GetCellSeparators(GridDirection.U).Skip(1).Reverse().Skip(1).Reverse();
var vLines = grid.GetCellSeparators(GridDirection.V).Skip(1).Reverse().Skip(1).Reverse();
var ctrLines = new List <Line>();
foreach (var curve in uLines)
{
ctrLines.Add((Line)curve);
}
foreach (var curve in vLines)
{
ctrLines.Add((Line)curve);
}
foreach (var line in ctrLines)
{
var corridor = line.Thicken(corridorWidth);
if (perimeterJig.Compass().Box.Covers(corridor))
{
AddCorridor(new Room(corridor.Rotate(Vector3.Origin, ang), Height));
}
}
foreach (var cell in grid.CellsFlat)
{
var polygon = (Polygon)cell.GetCellGeometry();
var compass = polygon.Compass();
if (split)
{
var north = Polygon.Rectangle(compass.W, compass.NE).Rotate(Vector3.Origin, ang);
var south = Polygon.Rectangle(compass.SW, compass.E).Rotate(Vector3.Origin, ang);
AddRoom(new Room(north, Height));
AddRoom(new Room(south, Height));
continue;
}
else if (Math.Abs(compass.SizeY - rowDepth) <= 0.0001)
{
AddRoom(new Room(polygon.Rotate(Vector3.Origin, ang), Height));
}
}
var roomRows = new List <RoomRow>();
foreach (var room in Rooms)
{
roomRows.Add(new RoomRow(room.Perimeter));
}
Rooms.Clear();
return(roomRows);
}
