protected static SpawnList <ListPathTraversalNode> GetPossibleExpansions(FloorPlan floorPlan, List <RoomHallIndex> candList)
{
// get all probabilities.
// the probability of an extension is the distance that the target room is from the start room, in rooms
var expansions = new SpawnList <ListPathTraversalNode>();
for (int nn = 0; nn < candList.Count; nn++)
{
// find the room to connect to
// go through all sides of all rooms (randomly)
RoomHallIndex chosenFrom = candList[nn];
IFloorRoomPlan planFrom = floorPlan.GetRoomHall(chosenFrom);
// exhausting all possible directions (randomly)
foreach (Dir4 dir in DirExt.VALID_DIR4)
{
bool forbidExtend = false;
foreach (RoomHallIndex adjacent in planFrom.Adjacents)
{
Rect adjRect = floorPlan.GetRoomHall(adjacent).RoomGen.Draw;
if (planFrom.RoomGen.Draw.GetScalar(dir) == adjRect.GetScalar(dir.Reverse()))
{
forbidExtend = true;
break;
}
}
if (!forbidExtend)
{
// find a rectangle to connect it with
ListPathTraversalNode?expandToResult = GetRoomToConnect(floorPlan, chosenFrom, dir);
if (expandToResult is ListPathTraversalNode expandTo)
{
int prb = floorPlan.GetDistance(expandTo.From, expandTo.To);
if (prb < 0)
{
expansions.Add(expandTo, 1);
}
else if (prb > 0)
{
expansions.Add(expandTo, prb);
}
}
}
}
}
return(expansions);
}
/// <summary>
/// Decides on the bounds for each hall. Also writes to the adjacent rooms' SideReqs and tile permissions
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="vertical"></param>
/// <param name="rand">todo: describe rand parameter on ChooseHallBounds</param>
public void ChooseHallBounds(IRandom rand, int x, int y, bool vertical)
{
GridRoomPlan startRoom = this.GetRoomPlan(new Loc(x, y));
GridRoomPlan endRoom = this.GetRoomPlan(new Loc(x + (vertical ? 0 : 1), y + (vertical ? 1 : 0)));
GridHallGroup hallGroup = vertical ? this.VHalls[x][y] : this.HHalls[x][y];
if (hallGroup.MainHall != null)
{
// also sets the sidereqs
int tier = vertical ? x : y;
Dir4 dir = vertical ? Dir4.Down : Dir4.Right;
IntRange startRange = this.GetHallTouchRange(startRoom.RoomGen, dir, tier);
IntRange endRange = this.GetHallTouchRange(endRoom.RoomGen, dir.Reverse(), tier);
IntRange combinedRange = new IntRange(Math.Min(startRange.Min, endRange.Min), Math.Max(startRange.Max, endRange.Max));
Loc start = startRoom.RoomGen.Draw.End;
Loc end = endRoom.RoomGen.Draw.Start;
Rect startCell = this.GetCellBounds(startRoom.Bounds);
Rect endCell = this.GetCellBounds(endRoom.Bounds);
Rect bounds = vertical ? new Rect(combinedRange.Min, start.Y, combinedRange.Length, end.Y - start.Y)
: new Rect(start.X, combinedRange.Min, end.X - start.X, combinedRange.Length);
// a side constitutes intruding bound when the rectangle moves forward enough to go to the other side
// and the other side touched is outside of side B's bound (including borders)
// startRange intrudes if startRange goes outside end's tier (borders included)
bool startIntrude = !endCell.GetSide(dir.ToAxis()).Contains(startRange);
// and end is greater than the edge (borders excluded)
bool endTouch = bounds.GetScalar(dir) == endCell.GetScalar(dir.Reverse());
bool endIntrude = !startCell.GetSide(dir.ToAxis()).Contains(endRange);
// and end is greater than the edge (borders excluded)
bool startTouch = bounds.GetScalar(dir.Reverse()) == startCell.GetScalar(dir);
// neither side intrudes bound: use the computed rectangle
if ((!startIntrude && !endIntrude) || (endTouch && startTouch) ||
(!(startIntrude && endIntrude) && ((startIntrude && endTouch) || (endIntrude && startTouch))))
{
hallGroup.MainHall.RoomGen.PrepareSize(rand, bounds.Size);
hallGroup.MainHall.RoomGen.SetLoc(bounds.Start);
}
else
{
int divPoint = startCell.GetScalar(dir) + 1;
IntRange startDivRange = startRange;
IntRange endDivRange = endRange;
if (startIntrude && !endIntrude)
{
// side A intrudes bound, side B does not: divide A and B; doesn't matter who gets border
// side A touches border, side B does not: divide A and B; A gets border
//
// side A does not, side B touches border: A gets border; don't need B - this cannot happen
// side A touches border, side B touches border: A gets border; don't need B - this cannot happen
//
// in short, divide with start getting the border
// startDivRange needs to contain endRange
startDivRange = combinedRange;
}
else if (!startIntrude && endIntrude)
{
// side A does not, side B intrudes bound: divide A and B; doesn't matter who gets border
// side A does not, side B touches border: divide A and B; B gets border
//
// side A touches border, side B does not: B gets border; don't need A - this cannot happen
// side A touches border, side B touches border: B gets border; don't need B - this cannot happen
//
// in short, divide with end getting the border
// endDivRange needs to contain startRange
divPoint = startCell.GetScalar(dir);
endDivRange = combinedRange;
}
else
{
// side A intrudes bound, side B intrudes bound: divide A and B; doesn't matter who gets border
if (startTouch)
{
// side A touches border, side B does not: divide A and B; A gets border
}
if (endTouch)
{
// side A does not, side B touches border: divide A and B; B gets border
divPoint = startCell.GetScalar(dir);
}
// side A touches border, side B touches border: A gets border; don't need B - this cannot happen
// both sides need to cover the intersection of their cells
IntRange interCellSide = IntRange.Intersect(startCell.GetSide(dir.ToAxis()), endCell.GetSide(dir.ToAxis()));
startDivRange = IntRange.IncludeRange(startDivRange, interCellSide);
endDivRange = IntRange.IncludeRange(endDivRange, interCellSide);
}
Rect startBox = vertical ? new Rect(startDivRange.Min, start.Y, startDivRange.Length, divPoint - start.Y)
: new Rect(start.X, startDivRange.Min, divPoint - start.X, startDivRange.Length);
Rect endBox = vertical ? new Rect(endDivRange.Min, divPoint, endDivRange.Length, end.Y - divPoint)
: new Rect(divPoint, endDivRange.Min, end.X - divPoint, endDivRange.Length);
GridHallPlan originalHall = hallGroup.MainHall;
hallGroup.HallParts.Add(new GridHallPlan((IPermissiveRoomGen)originalHall.RoomGen.Copy(), originalHall.Components));
hallGroup.HallParts[0].RoomGen.PrepareSize(rand, startBox.Size);
hallGroup.HallParts[0].RoomGen.SetLoc(startBox.Start);
hallGroup.HallParts[1].RoomGen.PrepareSize(rand, endBox.Size);
hallGroup.HallParts[1].RoomGen.SetLoc(endBox.Start);
}
}
}
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);
}
}