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 static void AddLegalPlacements(SpawnList <Loc> possiblePlacements, FloorPlan floorPlan, RoomHallIndex indexFrom, IRoomGen roomFrom, IRoomGen room, Dir4 expandTo)
{
bool vertical = expandTo.ToAxis() == Axis4.Vert;
// this scaling factor equalizes the chances of long sides vs short sides
int reverseSideMult = vertical ? roomFrom.Draw.Width * room.Draw.Width : roomFrom.Draw.Height * room.Draw.Height;
IntRange side = roomFrom.Draw.GetSide(expandTo.ToAxis());
// subtract the room's original size, not the inflated trialrect size
side.Min -= (vertical ? room.Draw.Size.X : room.Draw.Size.Y) - 1;
Rect tryRect = room.Draw;
// expand in every direction
// this will create a one-tile buffer to check for collisions
tryRect.Inflate(1, 1);
int currentScalar = side.Min;
while (currentScalar < side.Max)
{
// compute the location
Loc trialLoc = roomFrom.GetEdgeRectLoc(expandTo, room.Draw.Size, currentScalar);
tryRect.Start = trialLoc + new Loc(-1, -1);
// check for collisions (not counting the rectangle from)
List <RoomHallIndex> collisions = floorPlan.CheckCollision(tryRect);
// find the first tile in which no collisions will be found
int maxCollideScalar = currentScalar;
bool collided = false;
foreach (RoomHallIndex collision in collisions)
{
if (collision != indexFrom)
{
IRoomGen collideRoom = floorPlan.GetRoomHall(collision).RoomGen;
// this is the point at which the new room will barely touch the collided room
// the +1 at the end will move it into the safe zone
maxCollideScalar = Math.Max(maxCollideScalar, vertical ? collideRoom.Draw.Right : collideRoom.Draw.Bottom);
collided = true;
}
}
// if no collisions were hit, do final checks and add the room
if (!collided)
{
Loc locTo = roomFrom.GetEdgeRectLoc(expandTo, room.Draw.Size, currentScalar);
// must be within the borders of the floor!
if (floorPlan.DrawRect.Contains(new Rect(locTo, room.Draw.Size)))
{
// check the border match and if add to possible placements
int chanceTo = FloorPlan.GetBorderMatch(roomFrom, room, locTo, expandTo);
if (chanceTo > 0)
{
possiblePlacements.Add(locTo, chanceTo * reverseSideMult);
}
}
}
currentScalar = maxCollideScalar + 1;
}
}
protected static ListPathTraversalNode?GetRoomToConnect(FloorPlan floorPlan, RoomHallIndex chosenFrom, Dir4 dir)
{
// extend a rectangle to the border of the floor in the chosen direction
bool vertical = dir.ToAxis() == Axis4.Vert;
int dirSign = dir.GetLoc().GetScalar(dir.ToAxis());
IRoomGen genFrom = floorPlan.GetRoomHall(chosenFrom).RoomGen;
Rect sampleRect = genFrom.Draw;
// expand from the start of that border direction to the borders of the floor
sampleRect.Start += dir.GetLoc() * sampleRect.Size.GetScalar(dir.ToAxis());
// it doesn't have to be exactly the borders so just add the total size to be sure
sampleRect.Expand(dir, vertical ? floorPlan.Size.Y : floorPlan.Size.X);
// find the closest room.
var chosenTo = new RoomHallIndex(-1, false);
foreach (RoomHallIndex collision in floorPlan.CheckCollision(sampleRect))
{
Rect collidedRect = floorPlan.GetRoomHall(collision).RoomGen.Draw;
// limit the expansion by direction
int sampleScalar = sampleRect.GetScalar(dir);
int collidedScalar = collidedRect.GetScalar(dir.Reverse());
bool limit = dirSign == Math.Sign(sampleScalar - collidedScalar);
if (limit)
{
// update the boundaries
sampleRect.SetScalar(dir, collidedScalar);
chosenTo = collision;
}
}
// if it didn't collide with ANYTHING, then quit
if (chosenTo.Index == -1)
{
return(null);
}
IRoomGen genTo = floorPlan.GetRoomHall(chosenTo).RoomGen;
// narrow the rectangle if touching something on the side
// widen the rectangle by width
Rect widthRect = sampleRect;
widthRect.Inflate(vertical ? 1 : 0, vertical ? 0 : 1);
bool retractLeft = false;
bool retractRight = false;
Dir4 leftDir = DirExt.AddAngles(dir, Dir4.Left);
Dir4 rightDir = DirExt.AddAngles(dir, Dir4.Right);
foreach (RoomHallIndex collision in floorPlan.CheckCollision(widthRect))
{
Rect collidedRect = floorPlan.GetRoomHall(collision).RoomGen.Draw;
if (!retractLeft)
{
if (collidedRect.GetScalar(leftDir.Reverse()) == sampleRect.GetScalar(leftDir))
{
retractLeft = true;
}
}
if (!retractRight)
{
if (collidedRect.GetScalar(rightDir.Reverse()) == sampleRect.GetScalar(rightDir))
{
retractRight = true;
}
}
}
// retract the rectangle
if (retractLeft)
{
sampleRect.Expand(leftDir, -1);
}
if (retractRight)
{
sampleRect.Expand(rightDir, -1);
}
// if the rectangle has been retracted too much, we can't go on
if (sampleRect.Area <= 0)
{
return(null);
}
// check for border availability between start and end
bool foundFrom = HasBorderOpening(genFrom, sampleRect, dir);
bool foundTo = HasBorderOpening(genTo, sampleRect, dir.Reverse());
// return the expansion if one is found
if (foundFrom && foundTo)
{
return(new ListPathTraversalNode(chosenFrom, chosenTo, sampleRect));
}
else
{
return(null);
}
}
