private (int area, int rooms) ExpandPath(IRandom rand, FloorPlan floorPlan, bool branch)
{
ListPathBranchExpansion?expansionResult = this.ChooseRoomExpansion(rand, floorPlan, branch);
if (!expansionResult.HasValue)
{
return(0, 0);
}
var expansion = expansionResult.Value;
int tilesCovered = 0;
int roomsAdded = 0;
RoomHallIndex from = expansion.From;
if (expansion.Hall != null)
{
floorPlan.AddHall(expansion.Hall, this.HallComponents.Clone(), from);
from = new RoomHallIndex(floorPlan.HallCount - 1, true);
tilesCovered += expansion.Hall.Draw.Area;
roomsAdded++;
}
floorPlan.AddRoom(expansion.Room, this.RoomComponents.Clone(), from);
tilesCovered += expansion.Room.Draw.Area;
roomsAdded++;
GenContextDebug.DebugProgress(branch ? "Branched Path" : "Extended Path");
// report the added area coverage
return(tilesCovered, roomsAdded);
}
public override void ApplyToPath(IRandom rand, FloorPlan floorPlan)
{
int amount = this.Amount.Pick(rand);
for (int kk = 0; kk < amount; kk++)
{
FloorPathBranch <T> .ListPathBranchExpansion?expansionResult = this.ChooseRoomExpansion(rand, floorPlan);
if (!expansionResult.HasValue)
{
continue;
}
var expansion = expansionResult.Value;
RoomHallIndex from = expansion.From;
if (expansion.Hall != null)
{
floorPlan.AddHall(expansion.Hall, this.HallComponents.Clone(), from);
from = new RoomHallIndex(floorPlan.HallCount - 1, true);
}
floorPlan.AddRoom(expansion.Room, this.RoomComponents.Clone(), from);
GenContextDebug.DebugProgress("Extended with Room");
}
}
public void PlaceRoom(IRandom rand, FloorPlan floorPlan, IRoomGen newGen, RoomHallIndex oldRoomHall)
{
// first get the adjacents of the removed room
Dictionary <Dir4, List <RoomHallIndex> > adjacentsByDir = GetDirectionAdjacents(floorPlan, oldRoomHall);
IRoomGen oldGen = floorPlan.GetRoomHall(oldRoomHall).RoomGen;
// remove the room; update the adjacents too
floorPlan.EraseRoomHall(oldRoomHall);
foreach (Dir4 dir in DirExt.VALID_DIR4)
{
for (int jj = 0; jj < adjacentsByDir[dir].Count; jj++)
{
RoomHallIndex adjRoomHall = adjacentsByDir[dir][jj];
if (adjRoomHall.IsHall == oldRoomHall.IsHall &&
adjRoomHall.Index > oldRoomHall.Index)
{
adjacentsByDir[dir][jj] = new RoomHallIndex(adjRoomHall.Index - 1, adjRoomHall.IsHall);
}
}
}
var newAdjacents = new List <RoomHallIndex>();
var supportHalls = new Dictionary <Dir4, IPermissiveRoomGen>();
foreach (Dir4 dir in DirExt.VALID_DIR4)
{
if (newGen.Draw.GetScalar(dir) == oldGen.Draw.GetScalar(dir))
{
newAdjacents.AddRange(adjacentsByDir[dir]);
}
else if (adjacentsByDir[dir].Count > 0)
{
Rect supportRect = GetSupportRect(floorPlan, oldGen, newGen, dir, adjacentsByDir[dir]);
var supportHall = (IPermissiveRoomGen)this.Halls.Pick(rand).Copy();
supportHall.PrepareSize(rand, supportRect.Size);
supportHall.SetLoc(supportRect.Start);
supportHalls[dir] = supportHall;
}
}
// add the new room
var newRoomInd = new RoomHallIndex(floorPlan.RoomCount, false);
floorPlan.AddRoom(newGen, true, newAdjacents.ToArray());
// add supporting halls
foreach (Dir4 dir in DirExt.VALID_DIR4)
{
if (supportHalls.ContainsKey(dir))
{
// include an attachment to the newly added room
List <RoomHallIndex> adjToAdd = new List <RoomHallIndex> {
newRoomInd
};
adjToAdd.AddRange(adjacentsByDir[dir]);
floorPlan.AddHall(supportHalls[dir], adjToAdd.ToArray());
}
}
}
public void CreateErrorPath(IRandom rand, FloorPlan floorPlan)
{
floorPlan.Clear();
RoomGen <T> room = this.GetDefaultGen();
room.PrepareSize(rand, Loc.One);
room.SetLoc(Loc.Zero);
floorPlan.AddRoom(room, new ComponentCollection());
}
public override void ApplyToPath(IRandom rand, FloorPlan floorPlan)
{
int amount = this.Amount.Pick(rand);
for (int ii = 0; ii < amount; ii++)
{
// choose a room
RoomGen <T> room = this.GenericRooms.Pick(rand).Copy();
// decide on acceptable border/size/fulfillables
Loc size = room.ProposeSize(rand);
if (size.X > floorPlan.DrawRect.Width)
{
size.X = floorPlan.DrawRect.Width;
}
if (size.Y > floorPlan.DrawRect.Height)
{
size.Y = floorPlan.DrawRect.Height;
}
room.PrepareSize(rand, size);
for (int jj = 0; jj < 30; jj++)
{
// place in a random location
Loc testStart = new Loc(
rand.Next(floorPlan.DrawRect.Left, floorPlan.DrawRect.Right - room.Draw.Width + 1),
rand.Next(floorPlan.DrawRect.Top, floorPlan.DrawRect.Bottom - room.Draw.Height + 1));
Rect tryRect = new Rect(testStart, room.Draw.Size);
tryRect.Inflate(1, 1);
List <RoomHallIndex> collisions = floorPlan.CheckCollision(tryRect);
if (collisions.Count == 0)
{
room.SetLoc(testStart);
floorPlan.AddRoom(room, this.Components.Clone());
GenContextDebug.DebugProgress("Place Disconnected Room");
break;
}
}
}
}
public override void ApplyToPath(IRandom rand, FloorPlan floorPlan)
{
for (int ii = 0; ii < 10; ii++)
{
// always clear before trying
floorPlan.Clear();
int tilesToOpen = floorPlan.DrawRect.Area * this.FillPercent.Pick(rand) / 100;
if (tilesToOpen < 1)
{
tilesToOpen = 1;
}
int addBranch = this.BranchRatio.Pick(rand);
int tilesLeft = tilesToOpen;
// choose a room
IRoomGen room = this.PrepareRoom(rand, floorPlan, false);
// place in a random location
room.SetLoc(new Loc(
rand.Next(floorPlan.DrawRect.Left, floorPlan.DrawRect.Right - room.Draw.Width + 1),
rand.Next(floorPlan.DrawRect.Top, floorPlan.DrawRect.Bottom - room.Draw.Height + 1)));
floorPlan.AddRoom(room, this.RoomComponents.Clone());
GenContextDebug.DebugProgress("Start Room");
tilesLeft -= room.Draw.Area;
// repeat this process until the requisite room amount is met
int pendingBranch = 0;
while (tilesLeft > 0)
{
(int area, int rooms)terminalResult = this.ExpandPath(rand, floorPlan, false);
(int area, int rooms)branchResult = (0, 0);
if (terminalResult.area > 0)
{
tilesLeft -= terminalResult.area;
// add branch PER ROOM when we add over the min threshold
for (int jj = 0; jj < terminalResult.rooms; jj++)
{
if (floorPlan.RoomCount + floorPlan.HallCount - terminalResult.rooms + jj + 1 > 2)
{
pendingBranch += addBranch;
}
}
}
else if (this.NoForcedBranches)
{
break;
}
else
{
pendingBranch = 100;
}
while (pendingBranch >= 100 && tilesLeft > 0)
{
branchResult = this.ExpandPath(rand, floorPlan, true);
if (branchResult.area == 0)
{
break;
}
pendingBranch -= 100;
// if we add any more than one room, that also counts as a branchable node
pendingBranch += (branchResult.rooms - 1) * addBranch;
tilesLeft -= branchResult.area;
}
if (terminalResult.area == 0 && branchResult.area == 0)
{
break;
}
}
if (tilesLeft <= 0)
{
break;
}
}
}