public MaxSwarmer(AbstractPhysicalObject abstractPhysicalObject, World world) : base(abstractPhysicalObject, world)
{
this.travelDirection = Custom.RNV();
this.currentBehavior = new MaxSwarmer.Behavior(this);
this.color = this.currentBehavior.color;
this.stuckList = new List <Vector2>();
}
private static AbstractPhysicalObject SaveState_AbstractPhysicalObjectFromString(On.SaveState.orig_AbstractPhysicalObjectFromString orig, World world, string objString)
{
AbstractPhysicalObject result = orig(world, objString);
if (result != null && result.type == AbstractPhysicalObject.AbstractObjectType.DataPearl)
{
try
{
if (result is DataPearl.AbstractDataPearl dataPearl)
{
string[] array = Regex.Split(objString, "<oA>");
int hash = int.Parse(array[5]);
if (CustomWorldMod.customPearls.ContainsKey(hash))
{
CustomWorldMod.customPearls.TryGetValue(hash, out CustomWorldStructs.CustomPearl customPearl);
string pearlName = customPearl.name;
DataPearl.AbstractDataPearl.DataPearlType type = (DataPearl.AbstractDataPearl.DataPearlType)Enum.Parse(typeof(DataPearl.AbstractDataPearl.DataPearlType), pearlName);
CustomWorldMod.Log($"Loaded custom pearl [{type.ToString()}] Hash [{hash}]");
dataPearl.dataPearlType = type;
}
else if (hash > 0x25)
{
CustomWorldMod.Log($"Error loading data pearl (AbsPhysObj). You are missing dataPearls.txt or your pack needs to be updated", true);
}
}
}
catch (Exception e) { CustomWorldMod.Log($"Error while loading dataPearl from SaveState [{e}]"); }
}
return(result);
}
private void DisplayPlayerNames(RainWorldGame game)
{
if (trackedPlayer != null && currentRoom != null)
{
foreach (AbstractCreature cr in trackedPlayer.Room.creatures)
{
try
{
// Player in the same room
if (cr.realizedCreature is Player p)
{
AbstractPhysicalObject player = cr.realizedCreature.abstractPhysicalObject;
string playerName = SteamFriends.GetFriendPersonaName((CSteamID)AbstractPhysicalObjectHK.GetField(player).owner);
Color color = MonklandSteamManager.GameManager.playerColors[MonklandSteamManager.connectedPlayers.IndexOf(AbstractPhysicalObjectHK.GetField(player).owner)];
(currentRoom.game.cameras[0].hud.parts.Find(x => x is MultiplayerHUD) as MultiplayerHUD).AddLabel(player, playerName, color);
}
}
catch (Exception e)
{
// Throw exception
//Debug.LogException(e);
Debug.Log($"Error when trying to add label for Player" + e);
}
}
}
}
public void ctor(AbstractPhysicalObject abstractPhysicalObject, Room room)
{
orig_ctor(abstractPhysicalObject, room);
if (ID == OracleID.SS)
{
this.oracleBehavior = new FPOracleBehaviorHasMark(this);
}
else
{
health = 1f;
bodyChunks = new BodyChunk[2];
for (int i = 0; i < bodyChunks.Length; i++)
{
bodyChunks[i] = new BodyChunk(this, i, (ID != OracleID.SS) ? new Vector2(1585f + 5f * (float)i, 148f - 5f * (float)i) : new Vector2(350f, 350f), 6f, 0.5f);
}
bodyChunkConnections = new PhysicalObject.BodyChunkConnection[1];
bodyChunkConnections[0] = new PhysicalObject.BodyChunkConnection(bodyChunks[0], bodyChunks[1], 9f, BodyChunkConnection.Type.Normal, 1f, 0.5f);
mySwarmers = new System.Collections.Generic.List <OracleSwarmer>();
airFriction = 0.99f;
gravity = 0f;
bounce = 0.1f;
surfaceFriction = 0.17f;
collisionLayer = 1;
waterFriction = 0.92f;
buoyancy = 0.95f;
//this.moonmarbles = new List<MoonPearl>();
//this.SetUpMoonMarbles();
moonmarbles = new List <MoonPearl>();
SetUpMoonMarbles();
oracleBehavior = new LMOracleBehaviorHasMark(this);
arm = new patch_Oracle.OracleArm(this);
room.gravity = 0f;
}
}
// Token: 0x060022D6 RID: 8918 RVA: 0x00212894 File Offset: 0x00210A94
public LMOracleSwarmer(AbstractPhysicalObject abstractPhysicalObject, World world) : base(abstractPhysicalObject, world)
{
travelDirection = Custom.RNV();
currentBehavior = new LMOracleSwarmer.Behavior(this);
color = currentBehavior.color;
stuckList = new System.Collections.Generic.List <Vector2>();
}
public MUIPlayerTag(AbstractPhysicalObject player, string name, Color color, MultiplayerHUD owner)
{
//MonklandUI.AddMessage($"Added label for player {name}[{AbstractPhysicalObjectHK.GetField(player).owner}]");
this.player = player;
this.labelName = name;
this.pos = new Vector2(-1000f, -1000f);
this.gradient = new FSprite("Futile_White", true);
this.gradient.shader = owner.hud.rainWorld.Shaders["FlatLight"];
this.owner = owner;
this.owner.hud.fContainers[0].AddChild(this.gradient);
this.gradient.alpha = 0f;
this.gradient.x = -1000f;
this.label = new FLabel("font", labelName);
this.color = color;
this.label.color = color;
this.owner.hud.fContainers[0].AddChild(this.label);
this.label.alpha = 0f;
this.label.x = -1000f;
this.arrowSprite = new FSprite("Multiplayer_Arrow", true);
this.arrowSprite.color = color;
this.owner.hud.fContainers[0].AddChild(this.arrowSprite);
this.arrowSprite.alpha = 0f;
this.arrowSprite.x = -1000f;
this.blink = 1f;
}
private static void RoomLoadedPatch(On.Room.orig_Loaded orig, Room room)
{
if (room.abstractRoom.firstTimeRealized)
{
if (!room.abstractRoom.shelter && !room.abstractRoom.gate && room.game != null && (!room.game.IsArenaSession || room.game.GetArenaGameSession.GameTypeSetup.levelItems))
{
for (int i = (int)((float)room.TileWidth * (float)room.TileHeight * Mathf.Pow(room.roomSettings.RandomItemDensity * room.roomSettings.RandomItemSpearChance * clubReplaceChance, 2f) / 5f); i >= 0; i--)
{
IntVector2 spawnTile = room.RandomTile();
if (!room.GetTile(spawnTile).Solid)
{
bool canSpawnHere = true;
for (int j = -1; j < 2; j++)
{
if (!room.GetTile(spawnTile + new IntVector2(j, -1)).Solid)
{
canSpawnHere = false;
break;
}
}
if (canSpawnHere)
{
EntityID newID = room.game.GetNewID(-room.abstractRoom.index);
AbstractPhysicalObject entity = new AbstractPhysicalObject(room.world, EnumExt_NewItems.Club, null, new WorldCoordinate(room.abstractRoom.index, spawnTile.x, spawnTile.y, -1), newID);
room.abstractRoom.AddEntity(entity);
}
}
}
}
}
orig(room);
}
public void ctor_AbstractSpearAppendageStick(AbstractPhysicalObject spear, AbstractPhysicalObject stuckIn, int appendage, int prevSeg, float distanceToNext, float angle)
{
if (MonklandSteamManager.isInGame && spear != null && stuckIn != null && spear.Room != null && ((spear as patch_AbstractPhysicalObject).networkObject || (stuckIn as patch_AbstractPhysicalObject).networkObject))
{
MonklandSteamManager.EntityManager.SendSpearAppendageStick(A, B, A.Room, appendage, prevSeg, distanceToNext, angle);
}
OriginalConstructor(spear, stuckIn, appendage, prevSeg, distanceToNext, angle);
}
public void ctor_AbstractSpearStick(AbstractPhysicalObject spear, AbstractPhysicalObject stuckIn, int chunk, int bodyPart, float angle)
{
if (MonklandSteamManager.isInGame && spear != null && stuckIn != null && spear.Room != null && ((spear as patch_AbstractPhysicalObject).networkObject || (stuckIn as patch_AbstractPhysicalObject).networkObject))
{
MonklandSteamManager.EntityManager.SendSpearStick(A, B, A.Room, chunk, bodyPart, angle);
}
OriginalConstructor(spear, stuckIn, chunk, bodyPart, angle);
}
public void ctor_ImpaledOnSpearStick(AbstractPhysicalObject spear, AbstractPhysicalObject stuckIn, int chunk, int onSpearPosition)
{
if (MonklandSteamManager.isInGame && spear != null && stuckIn != null && spear.Room != null && ((spear as patch_AbstractPhysicalObject).networkObject || (stuckIn as patch_AbstractPhysicalObject).networkObject))
{
MonklandSteamManager.EntityManager.SendSpearImpaledStick(A, B, A.Room, chunk, onSpearPosition);
}
OriginalConstructor(spear, stuckIn, chunk, onSpearPosition);
}
public static void Write(AbstractPhysicalObject physicalObject, ref BinaryWriter writer)
{
EntityIDHandler.Write(physicalObject.ID, ref writer);
WorldCoordinateHandler.Write(physicalObject.pos, ref writer);
writer.Write(physicalObject.InDen);
writer.Write(physicalObject.timeSpentHere);
writer.Write((byte)physicalObject.type);
writer.Write((physicalObject as Patches.patch_AbstractPhysicalObject).dist);
}
public static AbstractPhysicalObject Orig_AbstractPhysicalObjectFromString(World world, string str)
{
// Generating a trampoline may cause a segfault
apofsDetour.Undo();
AbstractPhysicalObject ret = SaveState.AbstractPhysicalObjectFromString(world, str);
apofsDetour.Apply();
return(ret);
}
/* public static AbstractPhysicalObject Read(AbstractPhysicalObject physicalObject, ref BinaryReader reader)
* {
* physicalObject.ID = EntityIDHandler.Read(ref reader);
* physicalObject.pos = WorldCoordinateHandler.Read(ref reader);
* physicalObject.InDen = reader.ReadBoolean();
* physicalObject.timeSpentHere = reader.ReadInt32();
* physicalObject.type = (AbstractPhysicalObject.AbstractObjectType)reader.ReadByte();
* physicalObject.ID.number = reader.ReadInt32();
* physicalObject.destroyOnAbstraction = true;
* return physicalObject;
* } */
public static void Read(AbstractPhysicalObject physicalObject, ref BinaryReader reader)
{
physicalObject.ID = EntityIDHandler.Read(ref reader);
physicalObject.pos = WorldCoordinateHandler.Read(ref reader);
physicalObject.InDen = reader.ReadBoolean();
physicalObject.timeSpentHere = reader.ReadInt32();
physicalObject.type = (AbstractPhysicalObject.AbstractObjectType)reader.ReadByte();
physicalObject.ID.number = reader.ReadInt32();
physicalObject.destroyOnAbstraction = true;
}
public AbsPhyObjFields(AbstractPhysicalObject self)
{
this.self = self;
playerdist = UnityEngine.Random.Range(int.MinValue, int.MaxValue);
if (MonklandSteamManager.isInGame)
{
owner = NetworkGameManager.playerID;
}
}
public MoonPearl(AbstractPhysicalObject abstractPhysicalObject, World world) : base(abstractPhysicalObject, world)
{
otherMarbles = new List <MoonPearl>();
orbitAngle = UnityEngine.Random.value * 360f;
orbitSpeed = 3f;
orbitDistance = 50f;
collisionLayer = 0;
orbitFlattenAngle = UnityEngine.Random.value * 360f;
orbitFlattenFac = 0.5f + UnityEngine.Random.value * 0.5f;
}
public static AbstractPhysicalObject Read(AbstractPhysicalObject physicalObject, ref BinaryReader reader)
{
physicalObject.ID = EntityIDHandler.Read(ref reader);
physicalObject.pos = WorldCoordinateHandler.Read(ref reader);
physicalObject.InDen = reader.ReadBoolean();
physicalObject.timeSpentHere = reader.ReadInt32();
physicalObject.type = (AbstractPhysicalObject.AbstractObjectType)reader.ReadByte();
(physicalObject as Patches.patch_AbstractPhysicalObject).dist = reader.ReadInt32();
physicalObject.destroyOnAbstraction = true;
return(physicalObject);
}
public static AbsPhyObjFields GetField(AbstractPhysicalObject self)
{
if (fields.TryGetValue(self, out AbsPhyObjFields field))
{
return(field);
}
field = new AbsPhyObjFields(self);
fields.Add(self, field);
return(field);
}
private static void SpearAppStickCtorHK(On.AbstractPhysicalObject.AbstractSpearAppendageStick.orig_ctor orig, AbstractPhysicalObject.AbstractSpearAppendageStick self,
AbstractPhysicalObject spear, AbstractPhysicalObject stuckIn, int appendage, int prevSeg, float distanceToNext, float angle)
{
if (MonklandSteamManager.isInGame && spear != null && stuckIn != null && spear.Room != null && self.A != null && self.B != null)
{
AbsPhyObjFields As = GetField(self.A);
AbsPhyObjFields Bs = GetField(self.B);
if (As.networkObject || Bs.networkObject)
{
MonklandSteamManager.EntityManager.SendSpearAppendageStick(self.A, self.B, self.A.Room, appendage, prevSeg, distanceToNext, angle);
}
}
orig(self, spear, stuckIn, appendage, prevSeg, distanceToNext, angle);
}
private static void CtorHK(On.AbstractPhysicalObject.orig_ctor orig, AbstractPhysicalObject self,
World world, AbstractPhysicalObject.AbstractObjectType type, PhysicalObject realizedObject, WorldCoordinate pos, EntityID ID)
{
orig(self, world, type, realizedObject, pos, ID);
//if (ID.number != -1 && ID.number != 5 && ID.number != 0 && self.ID.number != 1 && self.ID.number != 2 && self.ID.number == 3) //What?
if (ID.number < -1 && ID.number > 5)
{
while (self.ID.number >= -1 && self.ID.number <= 15000)
{
self.ID.number = UnityEngine.Random.Range(int.MinValue, int.MaxValue);
}
}
GetField(self);
}
// Token: 0x060018D4 RID: 6356 RVA: 0x0013EABC File Offset: 0x0013CCBC
public TreeFruit(AbstractPhysicalObject abstractPhysicalObject) : base(abstractPhysicalObject)
{
bites = 2;
bodyChunks = new BodyChunk[1];
bodyChunks[0] = new BodyChunk(this, 0, new Vector2(0f, 0f), 8f, 0.2f);
bodyChunkConnections = new PhysicalObject.BodyChunkConnection[0];
airFriction = 0.999f;
gravity = 0.9f;
bounce = 0.2f;
surfaceFriction = 0.7f;
collisionLayer = 1;
waterFriction = 0.95f;
buoyancy = 1.1f;
}
private static void SpearStickCtorHK(On.AbstractPhysicalObject.AbstractSpearStick.orig_ctor orig, AbstractPhysicalObject.AbstractSpearStick self,
AbstractPhysicalObject spear, AbstractPhysicalObject stuckIn, int chunk, int bodyPart, float angle)
{
if (MonklandSteamManager.isInGame && spear != null && stuckIn != null && spear.Room != null && self.A != null && self.B != null)
{
AbsPhyObjFields As = GetField(self.A);
AbsPhyObjFields Bs = GetField(self.B);
if (As.networkObject || Bs.networkObject)
{
MonklandSteamManager.EntityManager.SendSpearStick(self.A, self.B, self.A.Room, chunk, bodyPart, angle);
}
}
orig(self, spear, stuckIn, chunk, bodyPart, angle);
}
public void AddLabel(AbstractPhysicalObject player, string name, Color color)
{
try
{
if (!playerLabels.ContainsKey(AbstractPhysicalObjectHK.GetField(player).owner))
{
playerLabels.Add(AbstractPhysicalObjectHK.GetField(player).owner, new MUIPlayerTag(player, name, color, this));
}
}
catch //(Exception e)
{
// Exception
// Debug.Log("Playerlabel " + e);
}
}
private void Player_Update(On.Player.orig_Update orig, Player self, bool eu)
{
orig.Invoke(self, eu);
if (self.room?.game?.devToolsActive ?? false)
{
if (Input.GetKey(KeyCode.T) && !_spawnBomb)
{
AbstractPhysicalObject bomb = new AbstractPhysicalObject(self.room.world, AbstractPhysicalObject.AbstractObjectType.ScavengerBomb, null, self.coord, self.room.game.GetNewID());
bomb.pos = self.coord;
self.room.abstractRoom.AddEntity(bomb);
bomb.RealizeInRoom();
bomb.realizedObject.firstChunk.HardSetPosition(self.mainBodyChunk.pos + Vector2.up * 40f);
}
_spawnBomb = Input.GetKey(KeyCode.T);
}
}
public static void AddInventory(StoryGameSession self, AbstractCreature player)
{
foreach (AbstractCreature ac in self.Players)
{
if (ac == player && !Inventories.ContainsKey((ac.state as PlayerState).playerNumber))
{
if (InventorySave != null && InventorySave != string.Empty)
{
List <AbstractPhysicalObject> content = new List <AbstractPhysicalObject>();
string[] arrayPlayers = Regex.Split(InventorySave, "<svC>");
for (int m = 0; m < arrayPlayers.Length; m++)
{
string[] arrayContent = Regex.Split(arrayPlayers[m], "<svD>");
if (int.Parse(arrayContent[0]) == (player.state as PlayerState).playerNumber)
{
for (int n = 1; n < arrayContent.Length; n++)
{
AbstractPhysicalObject apo = null;
if (arrayContent[n].Contains("<oA>"))
{
apo = SaveState.AbstractPhysicalObjectFromString(self.game.world, arrayContent[n]);
}
else if (arrayContent[n].Contains("<cA>"))
{
apo = SaveState.AbstractCreatureFromString(self.game.world, arrayContent[n], false);
}
if (apo != null)
{
apo.pos = ac.pos;
}
content.Add(apo);
}
}
}
Inventories.Add((ac.state as PlayerState).playerNumber, content);
}
else
{
Inventories.Add((ac.state as PlayerState).playerNumber, new List <AbstractPhysicalObject>());
}
}
}
}
public Bow(AbstractPhysicalObject abstractPhysicalObject, World world) : base(abstractPhysicalObject, world)
{
base.bodyChunks = new BodyChunk[1];
base.bodyChunks[0] = new BodyChunk(this, 0, new Vector2(0f, 0f), 5f, 0.07f);
bodyChunkConnections = new BodyChunkConnection[0];
base.airFriction = 0.999f;
base.gravity = 0.9f;
bounce = 0.4f;
drawProgress = 0.0f;
surfaceFriction = 0.4f;
collisionLayer = 2;
base.waterFriction = 0.98f;
base.buoyancy = 1.0f;
spinning = false;
base.firstChunk.loudness = 7f;
soundLoop = new ChunkDynamicSoundLoop(base.firstChunk);
}
public LargePiston(AbstractPhysicalObject abstractPhysicalObject) : base(abstractPhysicalObject)
{
bodyChunks = new BodyChunk[1];
bodyChunks[0] = new BodyChunk(this, 0, new Vector2(0f, 0f), 30f, 14f);
bodyChunkConnections = new BodyChunkConnection[0];
airFriction = 0.9f;
gravity = 0f;
bounce = 0f;
surfaceFriction = 9.9f;
collisionLayer = 1;
deathmode = (abstractPhysicalObject as AbstractLargePiston).deathmode;
deathtop = (abstractPhysicalObject as AbstractLargePiston).deathtop;
waterFriction = 0.1f;
buoyancy = 0f;
bodyChunks[0].collideWithObjects = true;
bodyChunks[0].collideWithTerrain = false;
bodyChunks[0].collideWithSlopes = false;
offset = UnityEngine.Random.Range(-1f, 1f);
}
public Quiver(AbstractPhysicalObject abstractPhysicalObject, World world) : base(abstractPhysicalObject, world)
{
base.bodyChunks = new BodyChunk[1];
base.bodyChunks[0] = new BodyChunk(this, 0, new Vector2(0f, 0f), 2.5f, 0.05f);
bodyChunkConnections = new BodyChunkConnection[0];
base.airFriction = 0.999f;
base.gravity = 0.9f;
bounce = 0.4f;
surfaceFriction = 0.4f;
collisionLayer = 2;
base.waterFriction = 0.98f;
base.buoyancy = 1.0f;
base.firstChunk.loudness = 7f;
tailPos = base.firstChunk.pos;
soundLoop = new ChunkDynamicSoundLoop(base.firstChunk);
base.armorMode = ArmorMode.Free;
base.armorSlot = ArmorSlot.Accessory;
strap = new Vector2[UnityEngine.Random.Range(4, UnityEngine.Random.Range(4, 10)), 6];
}
public Arrow(AbstractPhysicalObject abstractPhysicalObject, World world)
: base(abstractPhysicalObject, world)
{
base.bodyChunks = new BodyChunk[1];
base.bodyChunks[0] = new BodyChunk(this, 0, new Vector2(0f, 0f), 5f, 0.035f);
base.bodyChunkConnections = new BodyChunkConnection[0];
base.airFriction = 0.999f;
base.gravity = 0.75f;
bounce = 0.1f;
surfaceFriction = 0.1f;
collisionLayer = 2;
base.waterFriction = 0.98f;
base.buoyancy = 1.0f;
pivotAtTip = false;
spinning = true;
lastPivotAtTip = false;
stuckBodyPart = -1;
base.firstChunk.loudness = 7f;
tailPos = base.firstChunk.pos;
soundLoop = new ChunkDynamicSoundLoop(base.firstChunk);
stillFlyingCounter = maxFlyingCount;
}
public MaxOracle(AbstractPhysicalObject abstractPhysicalObject, Room room) : base(abstractPhysicalObject, room)
{
this.room = room;
this.ID = OracleID.DJ;
base.bodyChunks = new BodyChunk[2];
for (int i = 0; i < base.bodyChunks.Length; i++)
{
base.bodyChunks[i] = new BodyChunk(this, i, new Vector2(350f, 350f), 6f, 0.5f);
}
this.bodyChunkConnections = new PhysicalObject.BodyChunkConnection[1];
this.bodyChunkConnections[0] = new PhysicalObject.BodyChunkConnection(base.bodyChunks[0], base.bodyChunks[1], 9f, PhysicalObject.BodyChunkConnection.Type.Normal, 1f, 0.5f);
this.mySwarmers = new List <OracleSwarmer>();
base.airFriction = 0.99f;
base.gravity = 0.0f;
this.bounce = 0.1f;
this.surfaceFriction = 0.17f;
this.collisionLayer = 1;
base.waterFriction = 0.92f;
base.buoyancy = 0.95f;
this.oracleBehavior = new MaxOracleBehavior(this);
this.myScreen = new OracleProjectionScreen(room, this.oracleBehavior);
room.AddObject(this.myScreen);
this.marbles = new List <PebblesPearl>();
//this.SetUpMarbles();
room.gravity = 0f;
for (int j = 0; j < room.updateList.Count; j++)
{
if (room.updateList[j] is AntiGravity)
{
(room.updateList[j] as AntiGravity).active = false;
break;
}
}
this.arm = new OracleArm(this);
}
// Called on re-gear for Trade-mission scavs. If the region has a special item assigned, re-gear with that.
private static AbstractPhysicalObject ScavengerAbstractAI_TradeItem(On.ScavengerAbstractAI.orig_TradeItem orig, ScavengerAbstractAI self, bool main)
{
if (main)
{
World world = self.world;
if (world != null && !world.singleRoomWorld && world.region != null && TryGetSpecialScavItem(world.region.name, out AbstractPhysicalObject.AbstractObjectType specialItem))
{
try
{
AbstractPhysicalObject abstractPhysicalObject = InstantiateCustomScavItemAbstract(specialItem, self);
if (abstractPhysicalObject == null)
{
throw new Exception("Cannot instantiate item of type " + specialItem.ToString());
}
return(abstractPhysicalObject);
}
catch (Exception e)
{
CustomWorldMod.Log($"Error at TradeItem for [{specialItem}]. {e}", true);
}
}
}
return(orig(self, main));
}
