public override void DistributeSpawns(TGenContext map, List <TSpawnable> spawns)
{
// random per room, not per-tile
var spawningRooms = new SpawnList <RoomHallIndex>();
for (int ii = 0; ii < map.RoomPlan.RoomCount; ii++)
{
if (!BaseRoomFilter.PassesAllFilters(map.RoomPlan.GetRoomPlan(ii), this.Filters))
{
continue;
}
spawningRooms.Add(new RoomHallIndex(ii, false), 10);
}
if (this.IncludeHalls)
{
for (int ii = 0; ii < map.RoomPlan.HallCount; ii++)
{
if (!BaseRoomFilter.PassesAllFilters(map.RoomPlan.GetHallPlan(ii), this.Filters))
{
continue;
}
spawningRooms.Add(new RoomHallIndex(ii, true), 10);
}
}
this.SpawnRandInCandRooms(map, spawningRooms, spawns, 100);
}
public override void ApplyToPath(IRandom rand, GridPlan floorPlan)
{
List <int> candidates = new List <int>();
for (int ii = 0; ii < floorPlan.RoomCount; ii++)
{
if (!BaseRoomFilter.PassesAllFilters(floorPlan.GetRoomPlan(ii), this.Filters))
{
continue;
}
List <int> adjacents = floorPlan.GetAdjacentRooms(ii);
if (adjacents.Count > 1)
{
candidates.Add(ii);
}
}
// our candidates are all rooms except immutables and terminals
int amountToDefault = this.DefaultRatio.Pick(rand) * candidates.Count / 100;
for (int ii = 0; ii < amountToDefault; ii++)
{
int randIndex = rand.Next(candidates.Count);
GridRoomPlan plan = floorPlan.GetRoomPlan(candidates[randIndex]);
plan.RoomGen = new RoomGenDefault <T>();
plan.PreferHall = true;
candidates.RemoveAt(randIndex);
GenContextDebug.DebugProgress("Defaulted Room");
}
}
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 override void DistributeSpawns(TGenContext map, List <TSpawnable> spawns)
{
// gather up all rooms and put in a spawn list
// rooms that are farther from the start are more likely to have items
var spawningRooms = new SpawnList <RoomHallIndex>();
Dictionary <RoomHallIndex, int> roomWeights = new Dictionary <RoomHallIndex, int>();
// get the start room
int startRoom = 0;
for (int ii = 0; ii < map.RoomPlan.RoomCount; ii++)
{
FloorRoomPlan room = map.RoomPlan.GetRoomPlan(ii);
if (Collision.InBounds(room.RoomGen.Draw, map.GetLoc(0)))
{
startRoom = ii;
break;
}
}
int maxVal = 1;
void NodeAct(RoomHallIndex nodeIndex, int distance)
{
roomWeights[nodeIndex] = distance + 1;
maxVal = Math.Max(maxVal, roomWeights[nodeIndex]);
}
Graph.TraverseBreadthFirst(new RoomHallIndex(startRoom, false), NodeAct, map.RoomPlan.GetAdjacents);
int multFactor = int.MaxValue / maxVal / roomWeights.Count;
foreach (RoomHallIndex idx in roomWeights.Keys)
{
IFloorRoomPlan room = map.RoomPlan.GetRoomHall(idx);
if (idx.IsHall && !this.IncludeHalls)
{
continue;
}
if (!BaseRoomFilter.PassesAllFilters(room, this.Filters))
{
continue;
}
if (roomWeights[idx] == 0)
{
continue;
}
spawningRooms.Add(idx, roomWeights[idx] * multFactor);
}
this.SpawnRandInCandRooms(map, spawningRooms, spawns, this.SuccessPercent);
}
public override void Apply(T map)
{
foreach (IRoomPlan plan in map.GridPlan.GetAllPlans())
{
if (!BaseRoomFilter.PassesAllFilters(plan, this.Filters))
{
continue;
}
foreach (RoomComponent component in this.Components)
{
plan.Components.Set(component.Clone());
}
}
}
public override void Apply(TGenContext map)
{
List <int> room_indices = new List <int>();
for (int ii = 0; ii < map.RoomPlan.RoomCount; ii++)
{
if (!BaseRoomFilter.PassesAllFilters(map.RoomPlan.GetRoomPlan(ii), this.Filters))
{
continue;
}
room_indices.Add(ii);
}
List <int> used_indices = new List <int>();
Loc defaultLoc = Loc.Zero;
for (int ii = 0; ii < this.Entrances.Count; ii++)
{
int startRoom = NextRoom(map.Rand, room_indices, used_indices);
Loc start = GetOutlet <TEntrance>(map, startRoom);
if (start == new Loc(-1))
{
start = defaultLoc;
}
else
{
defaultLoc = start;
}
((IPlaceableGenContext <TEntrance>)map).PlaceItem(start, this.Entrances[ii]);
GenContextDebug.DebugProgress(nameof(this.Entrances));
}
for (int ii = 0; ii < this.Exits.Count; ii++)
{
int endRoom = NextRoom(map.Rand, room_indices, used_indices);
Loc end = GetOutlet <TExit>(map, endRoom);
if (end == new Loc(-1))
{
end = defaultLoc;
}
((IPlaceableGenContext <TExit>)map).PlaceItem(end, this.Exits[ii]);
GenContextDebug.DebugProgress(nameof(this.Exits));
}
}
public override void DistributeSpawns(TGenContext map, List <TSpawnable> spawns)
{
// random per room, not per-tile
var spawningRooms = new SpawnList <RoomHallIndex>();
var terminalRooms = new SpawnList <RoomHallIndex>();
// TODO: higher likelihoods for terminals at the ends of longer paths
for (int ii = 0; ii < map.RoomPlan.RoomCount; ii++)
{
if (!BaseRoomFilter.PassesAllFilters(map.RoomPlan.GetRoomPlan(ii), this.Filters))
{
continue;
}
spawningRooms.Add(new RoomHallIndex(ii, false), 10);
List <int> adjacent = map.RoomPlan.GetAdjacentRooms(ii);
if (adjacent.Count == 1)
{
terminalRooms.Add(new RoomHallIndex(ii, false), 10);
}
}
if (this.IncludeHalls)
{
for (int ii = 0; ii < map.RoomPlan.HallCount; ii++)
{
if (!BaseRoomFilter.PassesAllFilters(map.RoomPlan.GetHallPlan(ii), this.Filters))
{
continue;
}
spawningRooms.Add(new RoomHallIndex(ii, true), 10);
List <RoomHallIndex> adjacent = map.RoomPlan.GetRoomHall(new RoomHallIndex(ii, true)).Adjacents;
if (adjacent.Count == 1)
{
terminalRooms.Add(new RoomHallIndex(ii, true), 10);
}
}
}
// first attempt to spawn in the terminals; remove from terminal list if successful
this.SpawnRandInCandRooms(map, terminalRooms, spawns, 0);
this.SpawnRandInCandRooms(map, spawningRooms, spawns, 100);
}
public override void ApplyToPath(IRandom rand, GridPlan floorPlan)
{
IRoomGen newGen = this.Rooms.Pick(rand).Copy();
Loc size = newGen.ProposeSize(rand);
// choose certain rooms in the list to be special rooms
// special rooms are required; so make sure they don't overlap
List <int> room_indices = new List <int>();
for (int ii = 0; ii < floorPlan.RoomCount; ii++)
{
GridRoomPlan plan = floorPlan.GetRoomPlan(ii);
if (!BaseRoomFilter.PassesAllFilters(plan, this.Filters))
{
continue;
}
if (plan.PreferHall)
{
continue;
}
Loc boundsSize = GetBoundsSize(floorPlan, plan);
if (boundsSize.X >= size.X && boundsSize.Y >= size.Y)
{
room_indices.Add(ii);
}
}
if (room_indices.Count > 0)
{
int ind = rand.Next(room_indices.Count);
GridRoomPlan plan = floorPlan.GetRoomPlan(room_indices[ind]);
plan.RoomGen = newGen;
foreach (RoomComponent component in this.RoomComponents)
{
plan.Components.Set(component.Clone());
}
room_indices.RemoveAt(ind);
GenContextDebug.DebugProgress("Set Special Room");
}
}
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 (!BaseRoomFilter.PassesAllFilters(floorPlan.GetRoomPlan(ii), this.Filters))
{
continue;
}
if (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 (!BaseRoomFilter.PassesAllFilters(plan, this.Filters))
{
continue;
}
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);
}
}
public override void ApplyToPath(IRandom rand, GridPlan floorPlan)
{
List <LocRay4> endBranches = new List <LocRay4>();
for (int ii = 0; ii < floorPlan.RoomCount; ii++)
{
GridRoomPlan roomPlan = floorPlan.GetRoomPlan(ii);
if (!BaseRoomFilter.PassesAllFilters(roomPlan, this.Filters))
{
continue;
}
if (roomPlan.Bounds.Size == new Loc(1))
{
List <int> adjacents = floorPlan.GetAdjacentRooms(ii);
if (adjacents.Count == 1)
{
endBranches.Add(new LocRay4(roomPlan.Bounds.Start));
}
}
}
List <List <LocRay4> > candBranchPoints = new List <List <LocRay4> >();
for (int nn = 0; nn < endBranches.Count; nn++)
{
LocRay4 chosenBranch = endBranches[nn];
while (chosenBranch.Loc != new Loc(-1))
{
List <LocRay4> connectors = new List <LocRay4>();
List <LocRay4> candBonds = new List <LocRay4>();
foreach (Dir4 dir in DirExt.VALID_DIR4)
{
if (dir != chosenBranch.Dir)
{
if (floorPlan.GetHall(new LocRay4(chosenBranch.Loc, dir)) != null)
{
connectors.Add(new LocRay4(chosenBranch.Loc, dir));
}
else
{
Loc loc = chosenBranch.Loc + dir.GetLoc();
if (Collision.InBounds(floorPlan.GridWidth, floorPlan.GridHeight, loc) &&
floorPlan.GetRoomIndex(loc) > -1)
{
candBonds.Add(new LocRay4(chosenBranch.Loc, dir));
}
}
}
}
if (connectors.Count == 1)
{
if (candBonds.Count > 0)
{
candBranchPoints.Add(candBonds);
chosenBranch = new LocRay4(new Loc(-1));
}
else
{
chosenBranch = new LocRay4(connectors[0].Traverse(1), connectors[0].Dir.Reverse());
}
}
else
{
chosenBranch = new LocRay4(new Loc(-1));
}
}
}
// compute a goal amount of terminals to connect
// this computation ignores the fact that some terminals may be impossible
var randBin = new RandBinomial(candBranchPoints.Count, this.ConnectPercent);
int connectionsLeft = randBin.Pick(rand);
while (candBranchPoints.Count > 0 && connectionsLeft > 0)
{
// choose random point to connect
int randIndex = rand.Next(candBranchPoints.Count);
List <LocRay4> candBonds = candBranchPoints[randIndex];
LocRay4 chosenDir = candBonds[rand.Next(candBonds.Count)];
// connect
floorPlan.SetHall(chosenDir, this.GenericHalls.Pick(rand), this.HallComponents);
candBranchPoints.RemoveAt(randIndex);
GenContextDebug.DebugProgress("Connected Branch");
connectionsLeft--;
// check to see if connection destination was also a candidate,
// counting this as a double if so
for (int ii = candBranchPoints.Count - 1; ii >= 0; ii--)
{
if (candBranchPoints[ii][0].Loc == chosenDir.Traverse(1))
{
candBranchPoints.RemoveAt(ii);
connectionsLeft--;
}
}
}
}
public override void ApplyToPath(IRandom rand, FloorPlan floorPlan)
{
List <List <RoomHallIndex> > candBranchPoints = GetBranchArms(floorPlan);
// remove the rooms that do not pass filter
for (int xx = 0; xx < candBranchPoints.Count; xx++)
{
for (int yy = candBranchPoints[xx].Count - 1; yy >= 0; yy--)
{
IFloorRoomPlan plan = floorPlan.GetRoomHall(candBranchPoints[xx][yy]);
if (!BaseRoomFilter.PassesAllFilters(plan, this.Filters))
{
candBranchPoints[xx].RemoveAt(yy);
}
}
}
// compute a goal amount of branches to connect
// this computation ignores the fact that some terminals may be impossible
var randBin = new RandBinomial(candBranchPoints.Count, this.ConnectPercent);
int connectionsLeft = randBin.Pick(rand);
while (candBranchPoints.Count > 0 && connectionsLeft > 0)
{
// choose random point to connect from
int randIndex = rand.Next(candBranchPoints.Count);
var chosenDestResult = ChooseConnection(rand, floorPlan, candBranchPoints[randIndex]);
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 ii = candBranchPoints.Count - 1; ii >= 0; ii--)
{
for (int jj = 0; jj < candBranchPoints[ii].Count; jj++)
{
if (candBranchPoints[ii][jj] == chosenDest.To)
{
candBranchPoints.RemoveAt(ii);
connectionsLeft--;
break;
}
}
}
}
else
{
// remove the list anyway, but don't call it a success
candBranchPoints.RemoveAt(randIndex);
}
}
}