public override void ApplyToPath(IRandom rand, FloorPlan floorPlan)
{
List <RoomHallIndex> candBranchPoints = new List <RoomHallIndex>();
for (int ii = 0; ii < floorPlan.RoomCount; ii++)
{
if (!BaseRoomFilter.PassesAllFilters(floorPlan.GetRoomPlan(ii), this.Filters))
{
continue;
}
candBranchPoints.Add(new RoomHallIndex(ii, false));
}
// compute a goal amount of terminals to connect
// this computation ignores the fact that some terminals may be impossible
int connectionsLeft = this.ConnectFactor.Pick(rand) * candBranchPoints.Count / 2 / 100;
while (candBranchPoints.Count > 0 && connectionsLeft > 0)
{
// choose random point to connect from
int randIndex = rand.Next(candBranchPoints.Count);
var chosenDestResult = ChooseConnection(rand, floorPlan, candBranchPoints);
if (chosenDestResult is ListPathTraversalNode chosenDest)
{
// connect
PermissiveRoomGen <T> hall = (PermissiveRoomGen <T>) this.GenericHalls.Pick(rand).Copy();
hall.PrepareSize(rand, chosenDest.Connector.Size);
hall.SetLoc(chosenDest.Connector.Start);
floorPlan.AddHall(hall, this.Components.Clone(), chosenDest.From, chosenDest.To);
candBranchPoints.RemoveAt(randIndex);
connectionsLeft--;
GenContextDebug.DebugProgress("Added Connection");
// check to see if connection destination was also a candidate,
// counting this as a double if so
for (int jj = 0; jj < candBranchPoints.Count; jj++)
{
if (candBranchPoints[jj] == chosenDest.To)
{
candBranchPoints.RemoveAt(jj);
connectionsLeft--;
break;
}
}
}
else
{
// remove the list anyway, but don't call it a success
candBranchPoints.RemoveAt(randIndex);
}
}
}
public virtual FloorPathBranch <T> .ListPathBranchExpansion?ChooseRoomExpansion(IRandom rand, FloorPlan floorPlan)
{
List <RoomHallIndex> availableExpansions = new List <RoomHallIndex>();
for (int ii = 0; ii < floorPlan.RoomCount; ii++)
{
if (!BaseRoomFilter.PassesAllFilters(floorPlan.GetRoomPlan(ii), this.Filters))
{
continue;
}
availableExpansions.Add(new RoomHallIndex(ii, false));
}
for (int ii = 0; ii < floorPlan.HallCount; ii++)
{
if (!BaseRoomFilter.PassesAllFilters(floorPlan.GetHallPlan(ii), this.Filters))
{
continue;
}
availableExpansions.Add(new RoomHallIndex(ii, true));
}
return(FloorPathBranch <T> .ChooseRoomExpansion(this.PrepareRoom, this.HallPercent, rand, floorPlan, availableExpansions));
}
public override void ApplyToPath(IRandom rand, FloorPlan floorPlan)
{
// choose certain rooms in the list to be special rooms
// special rooms are required; so make sure they don't overlap
IRoomGen newGen = this.Rooms.Pick(rand).Copy();
Loc size = newGen.ProposeSize(rand);
newGen.PrepareSize(rand, size);
int factor = floorPlan.DrawRect.Area / newGen.Draw.Area;
// TODO: accept smaller rooms to replace
// bulldozing the surrounding rooms to get the space
var room_indices = new SpawnList <RoomHallIndex>();
for (int ii = 0; ii < floorPlan.RoomCount; ii++)
{
FloorRoomPlan plan = floorPlan.GetRoomPlan(ii);
if (!plan.Immutable &&
plan.RoomGen.Draw.Width >= newGen.Draw.Width &&
plan.RoomGen.Draw.Height >= newGen.Draw.Height)
{
room_indices.Add(new RoomHallIndex(ii, false), ComputeRoomChance(factor, plan.RoomGen.Draw, newGen.Draw));
}
}
for (int ii = 0; ii < floorPlan.HallCount; ii++)
{
var roomHall = new RoomHallIndex(ii, true);
IFloorRoomPlan plan = floorPlan.GetRoomHall(roomHall);
if (plan.RoomGen.Draw.Width >= newGen.Draw.Width &&
plan.RoomGen.Draw.Height >= newGen.Draw.Height)
{
room_indices.Add(roomHall, ComputeRoomChance(factor, plan.RoomGen.Draw, newGen.Draw));
}
}
while (room_indices.Count > 0)
{
int ind = room_indices.PickIndex(rand);
RoomHallIndex oldRoomHall = room_indices.GetSpawn(ind);
Dictionary <Dir4, List <RoomHallIndex> > adjacentIndicesByDir = GetDirectionAdjacents(floorPlan, oldRoomHall);
var adjacentsByDir = new Dictionary <Dir4, List <IRoomGen> >();
foreach (Dir4 dir in DirExt.VALID_DIR4)
{
adjacentsByDir[dir] = new List <IRoomGen>();
foreach (RoomHallIndex adj in adjacentIndicesByDir[dir])
{
adjacentsByDir[dir].Add(floorPlan.GetRoomHall(adj).RoomGen);
}
}
Loc placement = this.FindPlacement(rand, adjacentsByDir, newGen, floorPlan.GetRoomHall(oldRoomHall).RoomGen);
if (placement != new Loc(-1))
{
newGen.SetLoc(placement);
this.PlaceRoom(rand, floorPlan, newGen, oldRoomHall);
GenContextDebug.DebugProgress("Set Special Room");
return;
}
room_indices.RemoveAt(ind);
}
}
private protected static List <List <RoomHallIndex> > GetBranchArms(FloorPlan floorPlan)
{
List <ListPathTraversalNode> endBranches = new List <ListPathTraversalNode>();
for (int ii = 0; ii < floorPlan.RoomCount; ii++)
{
FloorRoomPlan roomPlan = floorPlan.GetRoomPlan(ii);
if (roomPlan.Adjacents.Count == 1)
{
endBranches.Add(new ListPathTraversalNode(new RoomHallIndex(-1, false), new RoomHallIndex(ii, false)));
}
}
List <List <RoomHallIndex> > branchArms = new List <List <RoomHallIndex> >();
for (int nn = 0; nn < endBranches.Count; nn++)
{
ListPathTraversalNode chosenBranch = endBranches[nn];
List <RoomHallIndex> arm = new List <RoomHallIndex>();
while (true)
{
List <RoomHallIndex> connectors = new List <RoomHallIndex>();
List <RoomHallIndex> adjacents = floorPlan.GetRoomHall(chosenBranch.To).Adjacents;
foreach (RoomHallIndex dest in adjacents)
{
if (dest != chosenBranch.From)
{
connectors.Add(dest);
}
}
if (connectors.Count == 1)
{
arm.Add(chosenBranch.To);
chosenBranch = new ListPathTraversalNode(chosenBranch.To, connectors[0]);
}
else if (connectors.Count == 0)
{
// we've reached the other side of a single line; add
arm.Add(chosenBranch.To);
// but also find the other pending arm and remove it
for (int ii = endBranches.Count - 1; ii > nn; ii--)
{
ListPathTraversalNode otherBranch = endBranches[ii];
if (chosenBranch.To == otherBranch.To)
{
endBranches.RemoveAt(ii);
}
}
// end the loop
break;
}
else
{
break;
}
}
branchArms.Add(arm);
}
return(branchArms);
}
