private VehicleRoom FindCurrentRegionGroupNeighborWithMostRegions(out bool multipleOldNeighborRooms)
{
multipleOldNeighborRooms = false;
VehicleRoom room = null;
for (int i = 0; i < currentRegionGroup.Count; i++)
{
foreach (VehicleRegion region in currentRegionGroup[i].NeighborsOfSameType)
{
if (region.Room != null && !reusedOldRooms.Contains(region.Room))
{
if (room == null)
{
room = region.Room;
}
else if (region.Room != room)
{
multipleOldNeighborRooms = true;
if (region.Room.RegionCount > room.RegionCount)
{
room = region.Room;
}
}
}
}
}
return(room);
}
public static VehicleRoom FloodAndSetRooms(VehicleRegion root, Map map, VehicleRoom existingRoom)
{
VehicleRoom floodingRoom;
if (existingRoom == null)
{
floodingRoom = VehicleRoom.MakeNew(map);
}
else
{
floodingRoom = existingRoom;
}
root.Room = floodingRoom;
if (!root.type.AllowsMultipleRegionsPerRoom())
{
return(floodingRoom);
}
bool entryCondition(VehicleRegion from, VehicleRegion r) => r.type == root.type && r.Room != floodingRoom;
bool regionProcessor(VehicleRegion r)
{
r.Room = floodingRoom;
return(false);
}
BreadthFirstTraverse(root, entryCondition, regionProcessor, 999999, RegionType.Set_All);
return(floodingRoom);
}
private bool ShouldBeInTheSameRoomGroup(VehicleRoom a, VehicleRoom b)
{
RegionType regionType = a.RegionType;
RegionType regionType2 = b.RegionType;
return((regionType == RegionType.Normal || regionType == RegionType.ImpassableFreeAirExchange) && (regionType2 == RegionType.Normal || regionType2 == RegionType.ImpassableFreeAirExchange));
}
private int CombineNewAndReusedRoomsIntoContiguousGroups()
{
int num = 0;
foreach (VehicleRoom room in reusedOldRooms)
{
room.newOrReusedRoomGroupIndex = -1;
}
foreach (VehicleRoom room2 in reusedOldRooms.Concat(newRooms))
{
if (room2.newOrReusedRoomGroupIndex < 0)
{
tmpRoomStack.Clear();
tmpRoomStack.Push(room2);
room2.newOrReusedRoomGroupIndex = num;
while (tmpRoomStack.Count != 0)
{
VehicleRoom room3 = tmpRoomStack.Pop();
foreach (VehicleRoom room4 in room3.Neighbors)
{
if (room4.newOrReusedRoomGroupIndex < 0 && ShouldBeInTheSameRoomGroup(room3, room4))
{
room4.newOrReusedRoomGroupIndex = num;
tmpRoomStack.Push(room4);
}
}
}
tmpRoomStack.Clear();
num++;
}
}
return(num);
}
public static VehicleRoom MakeNew(Map map)
{
VehicleRoom room = new VehicleRoom
{
mapIndex = (sbyte)map.Index,
ID = nextRoomID
};
nextRoomID++;
return(room);
}
private void CreateOrAttachToExistingRooms(int numRegionGroups)
{
for (int i = 0; i < numRegionGroups; i++)
{
currentRegionGroup.Clear();
for (int j = 0; j < newRegions.Count; j++)
{
if (newRegions[j].newRegionGroupIndex == i)
{
currentRegionGroup.Add(newRegions[j]);
}
}
if (!currentRegionGroup[0].type.AllowsMultipleRegionsPerRoom())
{
if (currentRegionGroup.Count != 1)
{
Log.Error("Region type doesn't allow multiple regions per room but there are >1 regions in this group.");
}
VehicleRoom room = VehicleRoom.MakeNew(map);
currentRegionGroup[0].Room = room;
newRooms.Add(room);
}
else
{
VehicleRoom room2 = FindCurrentRegionGroupNeighborWithMostRegions(out bool flag);
if (room2 is null)
{
VehicleRoom item = WaterRegionTraverser.FloodAndSetRooms(currentRegionGroup[0], map, null);
newRooms.Add(item);
}
else if (!flag)
{
for (int k = 0; k < currentRegionGroup.Count; k++)
{
currentRegionGroup[k].Room = room2;
}
reusedOldRooms.Add(room2);
}
else
{
WaterRegionTraverser.FloodAndSetRooms(currentRegionGroup[0], map, room2);
reusedOldRooms.Add(room2);
}
}
}
}
public static VehicleRoom RoomAtOrAdjacent(IntVec3 c, Map map, RegionType allowedRegionTypes = RegionType.Set_Passable)
{
VehicleRoom room = RoomAt(c, map, allowedRegionTypes);
if (!(room is null))
{
return(room);
}
for (int i = 0; i < 8; i++)
{
IntVec3 c2 = c + GenAdj.AdjacentCells[i];
room = RoomAt(c2, map, allowedRegionTypes);
if (!(room is null))
{
return(room);
}
}
return(room);
}
