public void RemoteKill(AbstractRoom room)
{
UnityEngine.Debug.Log("Remote Kill");
isManagerRequest = true;
KillRoom(room);
isManagerRequest = false;
}
private static bool RegionGate_KarmaBlinkRed(On.RegionGate.orig_KarmaBlinkRed orig, RegionGate self)
{
int num = self.PlayersInZone();
if (num > 0)
{
AbstractRoom abstractRoom = self.room.abstractRoom;
string name = self.room.game.overWorld.activeWorld.name;
string[] arrayName = Regex.Split(abstractRoom.name, "_");
string text = "ERROR!";
if (arrayName.Length == 3)
{
for (int i = 1; i < 3; i++)
{
if (arrayName[i] != name)
{
text = arrayName[i];
break;
}
}
}
if (!self.room.game.overWorld.regions.Select(x => x.name).Contains(text) &&
!text.Equals("ERROR!"))
{
return(true);
}
}
return(orig(self));
}
private static void RealizeRoomHK(On.AbstractRoom.orig_RealizeRoom orig, AbstractRoom self, World world, RainWorldGame game)
{
orig(self, world, game);
if (MonklandSteamManager.isInGame)
{
MonklandSteamManager.WorldManager.ActivateRoom(self.index);
}
}
private static void AbstractizeHK(On.AbstractRoom.orig_Abstractize orig, AbstractRoom self)
{
orig(self);
if (MonklandSteamManager.isInGame)
{
MonklandSteamManager.WorldManager.DeactivateRoom(self.index);
}
}
public void ctor_Room(RainWorldGame game, World world, AbstractRoom abstractRoom)
{
OriginalConstructor(game, world, abstractRoom);
this.physicalObjects = new List <PhysicalObject> [5];
for (int i = 0; i < this.physicalObjects.Length; i++)
{
this.physicalObjects[i] = new List <PhysicalObject>();
}
}
public static AbsRoomFields GetField(AbstractRoom self)
{
if (fields.TryGetValue(self, out AbsRoomFields field))
{
return(field);
}
field = new AbsRoomFields(self);
fields.Add(self, field);
return(field);
}
public static bool ShouldScroll(RoomCamera rCam, string room)
{
AbstractRoom aroom = rCam.game.world.GetAbstractRoom(room);
if (aroom == null || aroom.realizedRoom == null)
{
return(room.Split('_')[1][0] != 'A');
}
return(ShouldScroll(aroom.realizedRoom));
}
//добавляем начало остова в список
void addAbstractStartRoom()
{
AbstractRoom startRoom = new AbstractRoom();
startRoom.countDoorway = 1;
startRoom.idRoom = countRooms;
mapedRooms.Add(startRoom);
Debug.Log("старт " + startRoom.idRoom + " намечен");
}
public void KillRoom(AbstractRoom room)
{
if (isManagerRequest)
{
orig_KillRoom(room);
}
else
{
MonklandSteamManager.RoomManager.SendRoomKillRequest(room);
}
}
void addAbstractRoom()
{
AbstractRoom room = new AbstractRoom();
room.countDoorway = 2;
countRooms++;
room.idRoom = countRooms;
mapedRooms.Add(room);
Debug.Log("комната " + room.idRoom + " намечена");
}
//добавляем комнату между архитипами
void addArchetypeConnector()
{
AbstractRoom room = new AbstractRoom();
room.countDoorway = 2;
countRooms++;
room.idRoom = countRooms;
mapedRooms.Add(room);
Debug.Log("комната архитипа " + room.idRoom + " намечена");
}
//добавляем конец остова в список
void addAbstractEndRoom()
{
addAbstractCorridor();
AbstractRoom endRoom = new AbstractRoom();
endRoom.countDoorway = 1;
countRooms++;
endRoom.idRoom = countRooms;
mapedRooms.Add(endRoom);
Debug.Log("конец " + endRoom.idRoom + " намечен");
}
public void CheckForCommonRooms()
{
commonRooms.Clear();
foreach (ulong player in roomDict.Keys)
{
if (player != playerID && roomDict.ContainsKey(player))
{
foreach (string otherRoom in roomDict[player])
{
if (roomDict.ContainsKey(playerID))
{
foreach (string myRoom in roomDict[playerID])
{
if (myRoom.Equals(otherRoom) && myRoom != null && myRoom != "" && !myRoom.Equals(""))
{
if (!commonRooms.ContainsKey(myRoom))
{
commonRooms.Add(myRoom, new List <ulong>());
}
if (!commonRooms[myRoom].Contains(player))
{
commonRooms[myRoom].Add(player);
}
}
}
}
}
}
}
foreach (string roomName in commonRooms.Keys)
{
AbstractRoom abstractRoom = patch_RainWorldGame.mainGame.world.GetAbstractRoom(roomName);
if (abstractRoom != null && abstractRoom.realizedRoom != null)
{
(abstractRoom.realizedRoom as patch_Room).MultiplayerNewToRoom(commonRooms[roomName]);
}
}
if (MonklandSteamManager.DEBUG)
{
string roomlist = "";
foreach (string room in commonRooms.Keys)
{
roomlist = roomlist + room + ", ";
}
MonklandSteamManager.Log("[World] Room Packet: Player shares " + roomlist + " rooms with other players.");
}
}
public void CheckForCommonRooms()
{
commonRooms.Clear();
foreach (ulong player in roomDict.Keys)
{
if (player != playerID && roomDict.ContainsKey(player))
{
foreach (int otherRoom in roomDict[player])
{
if (roomDict.ContainsKey(playerID))
{
foreach (int myRoom in roomDict[playerID])
{
if (myRoom.Equals(otherRoom) /*&& !string.IsNullOrEmpty(myRoom)*/) // WHEN DOES THIS HAPPEN
{
if (!commonRooms.ContainsKey(myRoom))
{
commonRooms.Add(myRoom, new List <ulong>());
}
if (!commonRooms[myRoom].Contains(player))
{
commonRooms[myRoom].Add(player);
}
}
}
}
}
}
}
foreach (int roomName in commonRooms.Keys)
{
AbstractRoom abstractRoom = RainWorldGameHK.mainGame.world.GetAbstractRoom(roomName);
if (abstractRoom != null && abstractRoom.realizedRoom != null)
{
RoomHK.MultiplayerNewToRoom(abstractRoom.realizedRoom, commonRooms[roomName]);
}
}
if (MonklandSteamManager.DEBUG)
{
string roomlist = "";
foreach (int room in commonRooms.Keys)
{
roomlist = roomlist + room + ", ";
}
MonklandSteamManager.Log("[World] Room Packet: Player shares " + roomlist + " rooms with other players.");
}
}
private static void RegionGate_Update(On.RegionGate.orig_Update orig, RegionGate self, bool eu)
{
orig(self, eu);
AbstractRoom abstractRoom = self.room.abstractRoom;
// Old World
string name = self.room.game.overWorld.activeWorld.name;
string[] arrayName = Regex.Split(abstractRoom.name, "_");
string text = "ERROR!";
if (arrayName.Length == 3)
{
for (int i = 1; i < 3; i++)
{
if (arrayName[i] != name)
{
text = arrayName[i];
break;
}
}
}
if (text.Equals("ERROR!"))
{
if (!loggedError)
{
// Extended gates support
CustomWorldMod.Log($"Gate [{abstractRoom.name}] does not follow naming GATE_XX_YY. " +
$"If you are using Extended Gates you can ignore this error", true);
loggedError = true;
}
return;
}
if (!self.room.game.overWorld.regions.Select(x => x.name).Contains(text))
{
self.dontOpen = true;
if (!loggedError)
{
CustomWorldMod.Log($"Gate is blocked. Trying to load a region which is not available [{text}]. " +
$"Loaded regions [{string.Join(", ", self.room.game.overWorld.regions.Select(x => x.name).ToArray())}] ", true);
loggedError = true;
}
}
}
public void ActivateRoom(AbstractRoom room)
{
if (firstRoom)
{
orig_ActivateRoom(room);
firstRoom = false;
return;
}
if (managerRequested)
{
orig_ActivateRoom(room);
}
else
{
MonklandSteamManager.RoomManager.SendRoomActivationRequest(room);
}
}
public void ReadPlayer(BinaryReader br, CSteamID sentPlayer)
{
if (!MonklandSteamManager.WorldManager.gameRunning)
{
return;
}
string roomName = br.ReadString();//Read Room Name
if (!MonklandSteamManager.WorldManager.commonRooms.ContainsKey(roomName))
{
return;
}
AbstractRoom abstractRoom = patch_RainWorldGame.mainGame.world.GetAbstractRoom(roomName);
if (abstractRoom == null || abstractRoom.realizedRoom == null)
{
return;
}
int dist = br.ReadInt32(); // Read Disinguisher
WorldCoordinate startPos = WorldCoordinateHandler.Read(ref br); // Read World Coordinate
foreach (AbstractCreature cr in abstractRoom.creatures)
{
if (((cr as AbstractPhysicalObject) as patch_AbstractPhysicalObject).dist == dist && cr.realizedCreature != null)
{
cr.realizedCreature = PlayerHandler.Read((cr.realizedCreature as Player), ref br);// Read Player
cr.pos.room = abstractRoom.index;
return;
}
}
startPos.room = abstractRoom.index;
startPos.abstractNode = -1;
AbstractCreature abstractCreature = new AbstractCreature(patch_RainWorldGame.mainGame.world, StaticWorld.GetCreatureTemplate("Slugcat"), null, startPos, new EntityID(-1, 1));
abstractCreature.state = new PlayerState(abstractCreature, 1, 0, false);
((abstractCreature as AbstractPhysicalObject) as patch_AbstractPhysicalObject).dist = dist;
((abstractCreature as AbstractPhysicalObject) as patch_AbstractPhysicalObject).owner = sentPlayer.m_SteamID;
abstractCreature.pos.room = abstractRoom.index;
patch_RainWorldGame.mainGame.world.GetAbstractRoom(abstractCreature.pos.room).AddEntity(abstractCreature);
abstractCreature.RealizeInRoom();
abstractCreature.realizedCreature = PlayerHandler.Read((abstractCreature.realizedCreature as Player), ref br);// Read Player
abstractCreature.pos.room = abstractRoom.index;
}
public void SendRoomKillRequest(AbstractRoom absRoom)
{
if (requestedKillRooms.Contains(absRoom.index))
{
return;
}
MonklandSteamManager.DataPacket dataPacket = MonklandSteamManager.instance.GetNewPacket(GAMEMANAGEMENT_CHANNEL, RoomHandler);
BinaryWriter writer = MonklandSteamManager.instance.GetWriterForPacket(dataPacket);
//Writes the message type
writer.Write(RoomKillRequestID);
//Send room ID that we want to activate
writer.Write(absRoom.index);
MonklandSteamManager.instance.FinalizeWriterToPacket(writer, dataPacket);
MonklandSteamManager.instance.SendPacket(dataPacket, (CSteamID)NetworkGameManager.managerID, EP2PSend.k_EP2PSendReliable);
requestedKillRooms.Add(absRoom.index);
MonklandUI.AddMessage("Requested realization of room " + absRoom.index);
Debug.Log("Requested killing of room " + absRoom.index);
}
/// <summary>
/// als een gast inchecked bij het hotel
/// </summary>
/// <param name="data"> een Dictionary met een wens en een Id</param>
public void WelcomeGuest(Dictionary <string, string> data)
{
//zet de value en key van de gegeven dictonary om naar variable
string value = data.Values.ToList().Last().ToString();
string key = data.Keys.ToList().Last().ToString();
//zet de value string om naar een wens
int wish = Int32.Parse(Regex.Match(value, @"\d+").Value);
//geef de gast een kamer
AbstractRoom GivenRoom = ((Reception)reception).giveRoom(wish);
//als de kamer niet null is voeg een nieuwe gast toe aan GuestList
if (GivenRoom != null)
{
GuestList.Add((Guest)humanFactory.CreateGuest(reception, value.Split(' ').Last(), GivenRoom, key));
}
else //laat een bericht zien dat de kamer niet beschikbaar is
{
Debug.WriteLine("No Room Available");
}
}
public patch_Room(RainWorldGame game, World world, AbstractRoom abstractRoom) : base(game, world, abstractRoom)
{
}
private static void AbstractRoom_RealizeRoom(On.AbstractRoom.orig_RealizeRoom orig, AbstractRoom self, World world, RainWorldGame game)
{
orig.Invoke(self, world, game);
if (!noRain)
{
//Add Weather Object
if (self.realizedRoom != null && self.realizedRoom.roomRain != null)
{
if (!self.shelter && !self.gate && self.realizedRoom.roomRain.dangerType != RoomRain.DangerType.Flood && !rainList.Contains(self.name))
{
ceilingCount = 0;
for (int r = 0; r < self.realizedRoom.TileWidth; r++)
{
if (self.realizedRoom.Tiles[r, self.realizedRoom.TileHeight - 1].Solid)
{
ceilingCount++;
}
}
if (ceilingCount < (self.realizedRoom.Width * 0.95))
{
rainList.Add(self.name);
self.realizedRoom.AddObject(new Preciptator(self.realizedRoom, Downpour.snow));
}
}
}
}
}
public extern void OriginalConstructor(RainWorldGame game, World world, AbstractRoom abstractRoom);
public void OnEnterRoom(AbstractRoom _room)
{
}
/// <summary>
/// Constructor voor Hotel
/// </summary>
public Hotel()
{
//maak nieuwe lijsten aan, maak een queue en zet de timer aan
Roomlist = new List <AbstractRoom>();
Employees = new List <Maid>();
GuestList = new List <Guest>();
_dirtyroom = new Queue <AbstractRoom>();
roomFactory = new RoomFactory();
humanFactory = new HumanFactory();
SetTimer();
//open de streamreader
using (StreamReader r =
new StreamReader(Path.Combine(Environment.CurrentDirectory, "..", "..", "..", "..", "HotelLayout/Hotel.layout")))
{
//String met alle data uit de layout file
string json = r.ReadToEnd();
//desirialiseer alle string json informatie naar een jsonObject die toegevoegd kunnen worden aan roomlist
Jsonobjectlist = JsonConvert.DeserializeObject <List <JsonObject> >(json);
//zet elke json object om naar de juiste kamer en voeg hem toe aan roomlist
foreach (JsonObject room in Jsonobjectlist)
{
switch (room.AreaType)
{
case "Cinema":
Roomlist.Add(roomFactory.CreateCinema(room.AreaType, room.Dimension, room.Position, room.Id));
break;
case "Restaurant":
Roomlist.Add(roomFactory.CreateRestaurant(room.Capacity, room.AreaType, room.Position, room.Dimension, room.Id));
break;
case "Room":
Roomlist.Add(roomFactory.CreateBedroom(room.Classification, room.AreaType, room.Position, room.Dimension, room.Id));
break;
case "Fitness":
Roomlist.Add(roomFactory.CreateGym(room.AreaType, room.Dimension, room.Position, room.Id));
break;
}
}
}
//maak een nieuwe receptie en voeg hem toe aan roomlist
reception = roomFactory.CreateReception(Roomlist);
Roomlist.Add(reception);
//voeg 2 schoonmaker toe aan de Employees lijst
Employees.Add((Maid)humanFactory.CreateMaid(reception));
Employees.Add((Maid)humanFactory.CreateMaid(reception));
//een for each om te bepalen welke posities al in genomen zijn
foreach (AbstractRoom r in Roomlist)
{
//hou max X bij
if (r.PositionX > maxX)
{
maxX = r.PositionX;
}
//hou max Y bij
if (r.PositionY > maxY)
{
maxY = r.PositionY;
}
//als de dimensie meer dan 1 is voeg dan alle posities van die kamer toe aan positions
if (r.DimensionX > 1 || r.DimensionY > 1)
{
for (int x = 0; x < r.DimensionX; x++)
{
for (int y = 0; y < r.DimensionY; y++)
{
positions.Add(new Point(r.PositionX + x, r.PositionY + y));
}
}
}
else // als een kamer 1 X 1 is voeg hem dan toe aan positions lijst
{
positions.Add(new Point(r.PositionX, r.PositionY));
}
}
//maak een lift aan
Elevator elevator = (Elevator)roomFactory.CreateElevator("Elevator", 1, 1, maxX + 1, 0);
//voeg lift en trap toe aan roomlist en zijn positie aan de positions lijst
for (int i = 0; i <= maxY; i++)
{
//voeg de trap en zijn positie toe
Roomlist.Add(roomFactory.CreateStairwell("Stairwell", 1, 1, 0, i));
positions.Add(new Point(0, i));
//maak een nieuwe shaft geef hem een refference naar de lift en voeg hem toe aan room list
ElevatorShaft tempShaft = (ElevatorShaft)roomFactory.CreateElevatorshaft("Elevatorshaft", 1, 1, maxX + 1, i);
tempShaft.setElevator(ref elevator);
Roomlist.Add(tempShaft);
//zet de lift op de positie van lift schaft
if (i == 0)
{
elevator.currentPosition = tempShaft;
}
//voeg de positie aan positions lijst
positions.Add(new Point(maxX + 1, i));
}
//voeg hallway toe om lege ruimtes op te vullen
for (int x = 0; x <= maxX; x++)
{
for (int y = 0; y <= maxY; y++)
{
//als de positie niet gevuld is maak dan een hallway met die positie
if (!positions.Contains(new Point(x, y)))
{
Roomlist.Add(roomFactory.CreateHallway("Hallway", 1, 1, x, y));
}
}
}
//buren toe voegen
foreach (AbstractRoom r in Roomlist)
{
//als het een trap of een lift schaft is
if (r.AreaType == "Stairwell" || r.AreaType == "Elevatorshaft")
{
//kijk of er boven buren zijn
if (Roomlist.Any(x => x.PositionY == r.PositionY + 1 && x.PositionX == r.PositionX))
{
//selecteer de boven buur
var linq = (from a in Roomlist
where (r.PositionY + 1) == a.PositionY && r.PositionX == a.PositionX
select a).ToList();
//maak er een Abstractroom van en voeg hem toe aan buren
AbstractRoom result = linq.First();
r.AddNeighbour(ref result, 1);
}
//kijk of er onder buren zijn
if (Roomlist.Any(x => x.PositionY == r.PositionY - 1 && x.PositionX == r.PositionX))
{
//selecteer de onder buur
var linq = (from a in Roomlist
where (r.PositionY - 1) == a.PositionY && r.PositionX == a.PositionX
select a).ToList();
//maak er een Abstractroom van en voeg hem toe aan buren
AbstractRoom result = linq.First();
r.AddNeighbour(ref result, 1);
}
}
//kijk of er rechter buren zijn
if (Roomlist.Any(x => x.PositionY == r.PositionY && x.PositionX == r.PositionX + r.DimensionX))
{
//selecteer rechter buur zolang het geen lift is
var linq = (from a in Roomlist
where r.PositionY == a.PositionY && (r.PositionX + r.DimensionX) == a.PositionX &&
a.AreaType != "Elevator" select a).ToList();
//maak er een Abstractroom van en voeg hem toe aan buren
AbstractRoom result = linq.First();
r.AddNeighbour(ref result, r.DimensionX);
}
else //als er geen rechter buur is
{
//kijk naar rechts tot je iets vindt of de maxX is bereikt
for (int i = r.PositionX + 1; i <= maxX + 1; i++)
{
//als er een kamer is gevonden die deze positie heeft
if (Roomlist.Any(x => x.PositionY == r.PositionY && x.PositionX == i))
{
//selecteer rechter buur
var linq = (from a in Roomlist
where r.PositionY == a.PositionY && i == a.PositionX
select a).ToList();
//maak er een Abstractroom van en voeg hem toe aan buren
AbstractRoom result = linq.First();
r.AddNeighbour(ref result, 1);
break;
}
}
}
//kijk of er linker buren zijn
if (Roomlist.Any(x => x.PositionY == r.PositionY && x.PositionX == r.PositionX - 1))
{
//selecteer linker buur
var linq = (from a in Roomlist
where r.PositionY == a.PositionY && (r.PositionX - 1) == a.PositionX
select a).ToList();
//maak er een Abstractroom van en voeg hem toe aan buren
AbstractRoom result = linq.First();
r.AddNeighbour(ref result, 1);
}
else //als er geen linker buur is
{
//kijk naar links tot je iets vindt of het begin is bereikt
for (int i = r.PositionX - 1; i >= 0; i--)
{
//als er een kamer is gevonden die deze positie heeft
if (Roomlist.Any(x => x.PositionY == r.PositionY && x.PositionX == i))
{
//selecteer linker buur
var linq = (from a in Roomlist
where r.PositionY == a.PositionY && i == a.PositionX
select a).ToList();
//maak er een Abstractroom van en voeg hem toe aan buren
AbstractRoom result = linq.First();
r.AddNeighbour(ref result, 1);
break;
}
}
}
}
//voeg lift toe aan roomlist
Roomlist.Add(elevator);
}
public AbsRoomFields(AbstractRoom self)
{
this.self = self;
}
private static void AbstractRoom_Abstractize(On.AbstractRoom.orig_Abstractize orig, AbstractRoom self)
{
orig.Invoke(self);
if (self != null && self.realizedRoom == null && rainList.Contains(self.name))
{
rainList.Remove(self.name);
}
}
public static void SaveCustomMapConfig(MapPage self, string customPropertiesFilePath)
{
Vector2 vector = new Vector2(0f, 0f);
Vector2 vector2 = new Vector2(0f, 0f);
int num = 0;
for (int i = 0; i < self.subNodes.Count; i++)
{
if (self.subNodes[i] is RoomPanel)
{
num++;
vector += (self.subNodes[i] as RoomPanel).pos;
vector2 += (self.subNodes[i] as RoomPanel).devPos;
}
}
vector /= (float)num;
vector2 /= (float)num;
for (int j = 0; j < self.subNodes.Count; j++)
{
if (self.subNodes[j] is RoomPanel)
{
(self.subNodes[j] as RoomPanel).pos -= vector;
(self.subNodes[j] as RoomPanel).devPos -= vector2;
}
else if (self.subNodes[j] is MapRenderDefaultMaterial)
{
(self.subNodes[j] as MapRenderDefaultMaterial).handleA.pos -= vector;
(self.subNodes[j] as MapRenderDefaultMaterial).handleB.pos -= vector;
}
}
using (StreamWriter streamWriter = File.CreateText(self.filePath))
{
for (int k = 0; k < self.subNodes.Count; k++)
{
if (self.subNodes[k] is RoomPanel)
{
streamWriter.WriteLine(string.Concat(new object[]
{
(self.subNodes[k] as RoomPanel).roomRep.room.name,
": ",
(self.subNodes[k] as RoomPanel).pos.x,
",",
(self.subNodes[k] as RoomPanel).pos.y,
",",
(self.subNodes[k] as RoomPanel).devPos.x,
",",
(self.subNodes[k] as RoomPanel).devPos.y,
",",
(self.subNodes[k] as RoomPanel).layer,
",",
(self.subNodes[k] as RoomPanel).roomRep.room.subRegion
}));
}
}
for (int l = 0; l < self.subNodes.Count; l++)
{
if (self.subNodes[l] is MapRenderDefaultMaterial)
{
streamWriter.WriteLine(string.Concat(new object[]
{
"Def_Mat: ",
(self.subNodes[l] as MapRenderDefaultMaterial).handleA.pos.x,
",",
(self.subNodes[l] as MapRenderDefaultMaterial).handleA.pos.y,
",",
(self.subNodes[l] as MapRenderDefaultMaterial).handleB.pos.x,
",",
(self.subNodes[l] as MapRenderDefaultMaterial).handleB.pos.y,
",",
((self.subNodes[l] as MapRenderDefaultMaterial).handleA.subNodes[0] as Panel).pos.x,
",",
((self.subNodes[l] as MapRenderDefaultMaterial).handleA.subNodes[0] as Panel).pos.y,
",",
(!(self.subNodes[l] as MapRenderDefaultMaterial).materialIsAir) ? "0" : "1"
}));
}
}
for (int m = 0; m < self.subNodes.Count; m++)
{
if (self.subNodes[m] is RoomPanel)
{
int index = (self.subNodes[m] as RoomPanel).roomRep.room.index;
for (int n = 0; n < (self.subNodes[m] as RoomPanel).roomRep.room.connections.Length; n++)
{
int num2 = (self.subNodes[m] as RoomPanel).roomRep.room.connections[n];
if (num2 > index)
{
RoomPanel roomPanel = null;
for (int num3 = 0; num3 < self.subNodes.Count; num3++)
{
if (self.subNodes[num3] is RoomPanel && (self.subNodes[num3] as RoomPanel).roomRep.room.index == num2)
{
roomPanel = (self.subNodes[num3] as RoomPanel);
break;
}
}
if (roomPanel != null && n > -1 && n < (self.subNodes[m] as RoomPanel).roomRep.nodePositions.Length)
{
Vector2 vector3 = (self.subNodes[m] as RoomPanel).roomRep.nodePositions[n];
int num4 = roomPanel.roomRep.room.ExitIndex(index);
if (num4 > -1)
{
Vector2 vector4 = roomPanel.roomRep.nodePositions[num4];
streamWriter.WriteLine(string.Concat(new object[]
{
"Connection: ",
(self.subNodes[m] as RoomPanel).roomRep.room.name,
",",
roomPanel.roomRep.room.name,
",",
vector3.x,
",",
vector3.y,
",",
vector4.x,
",",
vector4.y,
",",
(self.subNodes[m] as RoomPanel).roomRep.exitDirections[n],
",",
roomPanel.roomRep.exitDirections[num4]
}));
}
else
{
Debug.Log("failed connection: " + roomPanel.roomRep.room.name + " -> " +
(self.subNodes[m] as RoomPanel).roomRep.room.name);
}
}
}
}
}
}
}
List <string> list = new List <string>();
for (int num5 = self.owner.game.world.firstRoomIndex; num5 < self.owner.game.world.firstRoomIndex + self.owner.game.world.NumberOfRooms; num5++)
{
bool flag = false;
AbstractRoom abstractRoom = self.owner.game.world.GetAbstractRoom(num5);
int num6 = 0;
while (num6 < abstractRoom.roomAttractions.Length && !flag)
{
if (abstractRoom.roomAttractions[num6] != AbstractRoom.CreatureRoomAttraction.Neutral)
{
flag = true;
}
num6++;
}
if (flag)
{
string text = "Room_Attr: " + abstractRoom.name + ": ";
for (int num7 = 0; num7 < abstractRoom.roomAttractions.Length; num7++)
{
if (abstractRoom.roomAttractions[num7] != AbstractRoom.CreatureRoomAttraction.Neutral)
{
string text2 = text;
text = string.Concat(new object[]
{
text2,
StaticWorld.creatureTemplates[num7].type.ToString(),
"-",
(int)abstractRoom.roomAttractions[num7],
","
});
}
}
list.Add(text);
}
}
if (list.Count > 0)
{
string[] array = File.ReadAllLines(customPropertiesFilePath);
using (StreamWriter streamWriter2 = File.CreateText(customPropertiesFilePath))
{
for (int num8 = 0; num8 < array.Length; num8++)
{
if (array[num8].Substring(0, 10) != "Room_Attr:")
{
streamWriter2.WriteLine(array[num8]);
}
}
for (int num9 = 0; num9 < list.Count; num9++)
{
streamWriter2.WriteLine(list[num9]);
}
}
}
}
public static void SpawnArenaCreaturesVanilla(RainWorldGame game, ArenaSetup.GameTypeSetup.WildLifeSetting wildLifeSetting, ref List <AbstractCreature> availableCreatures, ref MultiplayerUnlocks unlocks, string[] array)
{
/*
* Dictionary<string, int> tempDictionary = null;
* Dictionary<string, int> tempDictionary2 = null;
*/
float num = 1f;
switch (wildLifeSetting)
{
case ArenaSetup.GameTypeSetup.WildLifeSetting.Off:
return;
case ArenaSetup.GameTypeSetup.WildLifeSetting.Low:
num = 0.5f;
break;
case ArenaSetup.GameTypeSetup.WildLifeSetting.Medium:
num = 1f;
break;
case ArenaSetup.GameTypeSetup.WildLifeSetting.High:
num = 1.5f;
break;
}
AbstractRoom abstractRoom = game.world.GetAbstractRoom(0);
List <ArenaCreatureSpawner.Spawner> list = new List <ArenaCreatureSpawner.Spawner>();
List <ArenaCreatureSpawner.CritterSpawnData> list2 = new List <ArenaCreatureSpawner.CritterSpawnData>();
List <ArenaCreatureSpawner.CreatureGroup> list3 = new List <ArenaCreatureSpawner.CreatureGroup>();
List <ArenaCreatureSpawner.SpawnSymbol> list4 = new List <ArenaCreatureSpawner.SpawnSymbol>();
List <ArenaCreatureSpawner.DenGroup> list5 = new List <ArenaCreatureSpawner.DenGroup>();
float num2 = -1f;
for (int i = 0; i < array.Length; i++)
{
if (array[i].Length > 2 && array[i].Substring(0, 2) != "//")
{
string[] array2 = Regex.Split(array[i], " - ");
int num3 = 1;
ArenaCreatureSpawner.Spawner spawner = null;
string text = array2[0];
int num4;
if (text != null)
{
if (ArenaCreatureSpawnerHook.tempDictionary == null)
{
Dictionary <string, int> dictionary = new Dictionary <string, int>(5);
dictionary.Add("Creature", 0);
dictionary.Add("CreatureGroup", 1);
dictionary.Add("DenGroup", 2);
dictionary.Add("PlayersGlow", 3);
dictionary.Add("GoalAmount", 4);
ArenaCreatureSpawnerHook.tempDictionary = dictionary;
}
if (ArenaCreatureSpawnerHook.tempDictionary.TryGetValue(text, out num4))
{
switch (num4)
{
case 0:
{
CreatureTemplate.Type?type = WorldLoader.CreatureTypeFromString(array2[1]);
if (type != null)
{
spawner = new ArenaCreatureSpawner.CritterSpawnData(type.Value);
}
else
{
CustomWorldMod.Log("not rec. " + array2[1]);
}
break;
}
case 1:
spawner = new ArenaCreatureSpawner.CreatureGroup(array2[1]);
break;
case 2:
{
list5.Add(new ArenaCreatureSpawner.DenGroup(array2[1]));
string[] array3 = array2[2].Split(new char[]
{
','
});
for (int j = 0; j < array3.Length; j++)
{
list5[list5.Count - 1].dens.Add(int.Parse(array3[j]));
}
break;
}
case 3:
game.GetArenaGameSession.playersGlowing = true;
break;
case 4:
num2 = float.Parse(array2[1]);
break;
}
}
}
if (spawner != null)
{
for (int k = 2; k < array2.Length; k++)
{
string[] array4 = Regex.Split(array2[k], ":");
text = array4[0];
if (text != null)
{
if (ArenaCreatureSpawnerHook.tempDictionary2 == null)
{
Dictionary <string, int> dictionary = new Dictionary <string, int>(8);
dictionary.Add("chance", 0);
dictionary.Add("RARE", 1);
dictionary.Add("group", 2);
dictionary.Add("dens", 3);
dictionary.Add("spawnDataString", 4);
dictionary.Add("amount", 5);
dictionary.Add("symbol", 6);
dictionary.Add("invSymbol", 7);
ArenaCreatureSpawnerHook.tempDictionary2 = dictionary;
}
if (ArenaCreatureSpawnerHook.tempDictionary2.TryGetValue(text, out num4))
{
switch (num4)
{
case 0:
spawner.spawnChance = float.Parse(array4[1]);
break;
case 1:
if (spawner is ArenaCreatureSpawner.CritterSpawnData)
{
(spawner as ArenaCreatureSpawner.CritterSpawnData).rare = true;
}
break;
case 2:
spawner.groupString = array4[1];
break;
case 3:
if (spawner is ArenaCreatureSpawner.CritterSpawnData)
{
bool flag = true;
for (int l = 0; l < list5.Count; l++)
{
if (list5[l].name == array4[1])
{
(spawner as ArenaCreatureSpawner.CritterSpawnData).dens = list5[l].dens;
flag = false;
break;
}
}
if (flag)
{
string[] array5 = array4[1].Split(new char[]
{
','
});
for (int m = 0; m < array5.Length; m++)
{
(spawner as ArenaCreatureSpawner.CritterSpawnData).dens.Add(int.Parse(array5[m]));
}
}
}
break;
case 4:
if (spawner is ArenaCreatureSpawner.CritterSpawnData)
{
(spawner as ArenaCreatureSpawner.CritterSpawnData).spawnDataString = array4[1];
}
break;
case 5:
if (spawner is ArenaCreatureSpawner.CritterSpawnData)
{
if (array4[1] == "players")
{
num3 = game.GetArenaGameSession.arenaSitting.players.Count;
}
else
{
string[] array5 = array4[1].Split(new char[]
{
'-'
});
if (array5.Length == 1)
{
num3 = int.Parse(array5[0]);
}
else
{
num3 = UnityEngine.Random.Range(int.Parse(array5[0]), int.Parse(array5[1]) + 1);
}
}
}
break;
case 6:
ArenaCreatureSpawner.AddToSymbol(array4[1], false, ref list4);
spawner.symbolString = array4[1];
break;
case 7:
ArenaCreatureSpawner.AddToSymbol(array4[1], true, ref list4);
spawner.invSymbolString = array4[1];
break;
}
}
}
}
if (num3 > 0)
{
if (spawner is ArenaCreatureSpawner.CreatureGroup)
{
list3.Add(spawner as ArenaCreatureSpawner.CreatureGroup);
}
else if (spawner is ArenaCreatureSpawner.CritterSpawnData)
{
list2.Add(spawner as ArenaCreatureSpawner.CritterSpawnData);
}
list.Add(spawner);
spawner.spawn = true;
for (int n = 1; n < num3; n++)
{
ArenaCreatureSpawner.CritterSpawnData critterSpawnData = new ArenaCreatureSpawner.CritterSpawnData((spawner as ArenaCreatureSpawner.CritterSpawnData).type);
critterSpawnData.dens = (spawner as ArenaCreatureSpawner.CritterSpawnData).dens;
critterSpawnData.groupString = (spawner as ArenaCreatureSpawner.CritterSpawnData).groupString;
critterSpawnData.symbolString = (spawner as ArenaCreatureSpawner.CritterSpawnData).symbolString;
critterSpawnData.invSymbolString = (spawner as ArenaCreatureSpawner.CritterSpawnData).invSymbolString;
critterSpawnData.spawnChance = (spawner as ArenaCreatureSpawner.CritterSpawnData).spawnChance;
critterSpawnData.spawnDataString = (spawner as ArenaCreatureSpawner.CritterSpawnData).spawnDataString;
critterSpawnData.rare = (spawner as ArenaCreatureSpawner.CritterSpawnData).rare;
list2.Add(critterSpawnData);
list.Add(critterSpawnData);
critterSpawnData.spawn = true;
}
}
}
}
}
for (int num5 = 0; num5 < list.Count; num5++)
{
if (list[num5].symbolString != null)
{
for (int num6 = 0; num6 < list4.Count; num6++)
{
if (list[num5].symbolString.Substring(0, 1) == list4[num6].name)
{
list[num5].symbol = list4[num6];
list4[num6].connectedSpawners.Add(list[num5]);
break;
}
}
}
if (list[num5].invSymbolString != null)
{
for (int num7 = 0; num7 < list4.Count; num7++)
{
if (list[num5].invSymbolString.Substring(0, 1) == list4[num7].name)
{
list[num5].invSymbol = list4[num7];
list4[num7].connectedSpawners.Add(list[num5]);
break;
}
}
}
if (list[num5].groupString != null)
{
for (int num8 = 0; num8 < list3.Count; num8++)
{
if (list[num5].groupString == list3[num8].name)
{
list[num5].group = list3[num8];
list3[num8].connectedSpawners.Add(list[num5]);
break;
}
}
}
}
Dictionary <CreatureTemplate.Type, bool> dictionary2 = new Dictionary <CreatureTemplate.Type, bool>();
float num9 = 0f;
List <CreatureTemplate.Type> list6 = new List <CreatureTemplate.Type>();
List <CreatureTemplate.Type> list7 = new List <CreatureTemplate.Type>();
for (int num10 = 0; num10 < list2.Count; num10++)
{
float num11 = Mathf.Clamp01(list2[num10].spawnChance);
if (list2[num10].group != null)
{
num11 *= Mathf.Clamp01(list2[num10].group.spawnChance);
}
if (list2[num10].symbol != null)
{
num11 *= 1f / (float)list2[num10].symbol.possibleOutcomes.Count;
}
if (list2[num10].invSymbol != null)
{
num11 *= 1f - 1f / (float)list2[num10].invSymbol.possibleOutcomes.Count;
}
if (unlocks.IsCreatureUnlockedForLevelSpawn(list2[num10].type))
{
if (!list6.Contains(list2[num10].type))
{
list6.Add(list2[num10].type);
}
}
else
{
if (!list7.Contains(list2[num10].type))
{
list7.Add(list2[num10].type);
}
CreatureTemplate.Type?type2 = unlocks.RecursiveFallBackCritter(new CreatureTemplate.Type?(list2[num10].type));
if (type2 != null)
{
CustomWorldMod.Log(list2[num10].type + " fall back to " + type2.Value);
list2[num10].type = type2.Value;
list2[num10].spawnChance = Mathf.Clamp01(list2[num10].spawnChance) * 0.01f;
num11 *= 0.5f;
}
else
{
list2[num10].Disable();
num11 *= 0f;
}
}
num9 += num11;
}
float num12 = (float)list6.Count / (float)(list6.Count + list7.Count);
CustomWorldMod.Log("percentCritTypesAllowed: " + num12);
float num13 = Mathf.InverseLerp(0.7f, 0.3f, num12);
if (num2 > 0f)
{
num2 *= Mathf.Lerp(Mathf.InverseLerp(0.15f, 0.75f, num12), 1f, 0.5f) * num;
}
CustomWorldMod.Log("diversify: " + num13);
for (int num14 = 0; num14 < list3.Count; num14++)
{
if (UnityEngine.Random.value > list3[num14].spawnChance || !list3[num14].AnyConnectedSpawnersActive())
{
list3[num14].Disable();
}
}
for (int num15 = 0; num15 < list2.Count; num15++)
{
if (list2[num15].rare && UnityEngine.Random.value > Mathf.Pow(list2[num15].spawnChance, Custom.LerpMap(num12, 0.35f, 0.85f, 0.5f, 0.05f)))
{
list2[num15].Disable();
}
}
for (int num16 = 0; num16 < list4.Count; num16++)
{
list4[num16].decidedOutcome = list4[num16].possibleOutcomes[UnityEngine.Random.Range(0, list4[num16].possibleOutcomes.Count)];
for (int num17 = 0; num17 < 10; num17++)
{
if (list4[num16].AnyConnectedSpawnersActiveUnderCurrentRoll())
{
break;
}
list4[num16].decidedOutcome = list4[num16].possibleOutcomes[UnityEngine.Random.Range(0, list4[num16].possibleOutcomes.Count)];
}
}
for (int num18 = 0; num18 < list.Count; num18++)
{
if (list[num18].group != null && !list[num18].group.spawn)
{
list[num18].Disable();
}
else if (list[num18].symbol != null && list[num18].symbol.decidedOutcome != list[num18].symbolString.Substring(1, 1))
{
list[num18].Disable();
}
else if (list[num18].invSymbol != null && list[num18].invSymbol.decidedOutcome == list[num18].invSymbolString.Substring(1, 1))
{
list[num18].Disable();
}
}
CustomWorldMod.Log(string.Concat(new object[]
{
"weight total pre rand: ",
num9,
" ga:",
num2
}));
if (num2 > -1f)
{
num9 = Mathf.Lerp(num9, num2, 0.5f);
}
num9 *= num * Mathf.Lerp(0.8f, 1.2f, UnityEngine.Random.value);
if (num2 > -1f)
{
num9 += Mathf.Lerp(-1.2f, 1.2f, Mathf.Pow(UnityEngine.Random.value, Custom.LerpMap(num9, num2 - 2f, num2 + 2f, 0.25f, 2f)));
}
else
{
num9 += Mathf.Lerp(-1.2f, 1.2f, Mathf.Pow(UnityEngine.Random.value, Custom.LerpMap(num9, 2f, 10f, 0.25f, 3f)));
}
CustomWorldMod.Log("weight total: " + num9);
int num19 = Custom.IntClamp(Mathf.RoundToInt(num9), (int)wildLifeSetting, 25);
CustomWorldMod.Log("creaturesToSpawn: " + num19);
List <ArenaCreatureSpawner.CritterSpawnData> list8 = new List <ArenaCreatureSpawner.CritterSpawnData>();
for (int num20 = 0; num20 < num19; num20++)
{
ArenaCreatureSpawner.CritterSpawnData critterSpawnData2 = ArenaCreatureSpawner.WeightedRandom(list2);
if (critterSpawnData2 != null)
{
critterSpawnData2.Disable();
list8.Add(critterSpawnData2);
if (num13 > 0f)
{
ArenaCreatureSpawner.Diversify(ref list2, critterSpawnData2.type, num13);
}
}
}
CustomWorldMod.Log("-- ACTUALLY SPAWNING");
for (int num21 = 0; num21 < list8.Count; num21++)
{
CustomWorldMod.Log(string.Concat(new object[]
{
num21,
" ---- ",
list8[num21].type,
"(",
list8[num21].ID,
")"
}));
}
int[] array6 = new int[abstractRoom.nodes.Length];
for (int num22 = 0; num22 < list8.Count; num22++)
{
ArenaCreatureSpawner.CritterSpawnData critterSpawnData3 = list8[num22];
if (critterSpawnData3.dens.Count < 1 || critterSpawnData3.dens[0] == -1)
{
AbstractCreature abstractCreature = ArenaCreatureSpawner.CreateAbstractCreature(game.world, critterSpawnData3.type, new WorldCoordinate(game.world.offScreenDen.index, -1, -1, 0), ref availableCreatures);
if (abstractCreature != null)
{
game.world.offScreenDen.AddEntity(abstractCreature);
}
}
else
{
int num23 = int.MaxValue;
for (int num24 = 0; num24 < critterSpawnData3.dens.Count; num24++)
{
num23 = Math.Min(num23, array6[critterSpawnData3.dens[num24]]);
}
List <int> list9 = new List <int>();
for (int num25 = 0; num25 < critterSpawnData3.dens.Count; num25++)
{
if (array6[critterSpawnData3.dens[num25]] <= num23)
{
list9.Add(critterSpawnData3.dens[num25]);
}
}
int num26 = list9[UnityEngine.Random.Range(0, list9.Count)];
array6[num26]++;
if (StaticWorld.GetCreatureTemplate(critterSpawnData3.type).quantified)
{
abstractRoom.AddQuantifiedCreature(num26, critterSpawnData3.type, UnityEngine.Random.Range(7, 11));
}
else
{
AbstractCreature abstractCreature2 = ArenaCreatureSpawner.CreateAbstractCreature(game.world, critterSpawnData3.type, new WorldCoordinate(abstractRoom.index, -1, -1, num26), ref availableCreatures);
if (abstractCreature2 != null)
{
abstractRoom.MoveEntityToDen(abstractCreature2);
CreatureTemplate.Type type3 = abstractCreature2.creatureTemplate.type;
if (type3 == CreatureTemplate.Type.BigNeedleWorm)
{
for (int num27 = UnityEngine.Random.Range(0, 4); num27 >= 0; num27--)
{
AbstractCreature ent = new AbstractCreature(game.world, StaticWorld.GetCreatureTemplate(CreatureTemplate.Type.SmallNeedleWorm), null, new WorldCoordinate(abstractRoom.index, -1, -1, num26), game.GetNewID());
abstractRoom.MoveEntityToDen(ent);
}
}
}
}
}
}
}
public float RoomPerformanceEstimation(AbstractRoom testRoom)
{
float num = Mathf.Lerp(2080f, (float)(testRoom.size.x * testRoom.size.y), 0.25f) / 40f;
for (int i = 0; i < testRoom.nodes.Length; i++)
{
if (testRoom.nodes[i].submerged)
{
num += Mathf.Lerp(50f, (float)testRoom.size.x, 0.5f) * 0.2f;
break;
}
}
if (testRoom.singleRealizedRoom)
{
num += performanceBudget * 0.55f;
}
for (int j = 0; j < testRoom.creatures.Count; j++)
{
if (testRoom.creatures[j].state.alive)
{
switch (testRoom.creatures[j].creatureTemplate.type)
{
case CreatureTemplate.Type.Fly:
num += 10f;
goto IL_253;
case CreatureTemplate.Type.Leech:
num += 10f;
goto IL_253;
case CreatureTemplate.Type.Snail:
num += 20f;
goto IL_253;
case CreatureTemplate.Type.Vulture:
num += 100f;
goto IL_253;
case CreatureTemplate.Type.GarbageWorm:
num += 30f;
goto IL_253;
case CreatureTemplate.Type.CicadaA:
case CreatureTemplate.Type.CicadaB:
case (CreatureTemplate.Type)patch_CreatureTemplate.Type.SeaDrake:
num += 25f;
goto IL_253;
case CreatureTemplate.Type.JetFish:
num += 25f;
goto IL_253;
case CreatureTemplate.Type.BigEel:
num += 300f;
goto IL_253;
case CreatureTemplate.Type.Deer:
case (CreatureTemplate.Type)patch_CreatureTemplate.Type.WalkerBeast:
case CreatureTemplate.Type.DaddyLongLegs:
case CreatureTemplate.Type.BrotherLongLegs:
num += 200f;
goto IL_253;
case CreatureTemplate.Type.Scavenger:
num += 300f;
goto IL_253;
case CreatureTemplate.Type.BigSpider:
num += 30f;
goto IL_253;
case CreatureTemplate.Type.SpitterSpider:
num += 50f;
goto IL_253;
case CreatureTemplate.Type.DropBug:
num += 20f;
goto IL_253;
case CreatureTemplate.Type.KingVulture:
num += 140f;
goto IL_253;
}
if (testRoom.creatures[j].creatureTemplate.TopAncestor().type == CreatureTemplate.Type.LizardTemplate)
{
num += 50f;
}
else
{
num += 10f;
}
}
IL_253 :;
}
return(num);
}
public void SetRoom(AbstractRoom _room)
{
Room = _room;
}
