public void Update()
{
if (mainGame == null)
{
mainGame = this;
}
if (!lastPauseButton)
{
lastPauseButton = MonklandSteamManager.isInGame;
}
orig_Update();
//New Code:
try {
if (MonklandSteamManager.isInGame)
{
if (MonklandSteamManager.monklandUI != null)
{
MonklandSteamManager.monklandUI.Update(this);
}
MonklandSteamManager.WorldManager.TickCycle();
}
} catch (System.Exception e) {
Debug.LogError(e);
}
}
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 ShutDownProcess()
{
mainGame = null;
MonklandSteamManager.instance.OnGameExit();
OriginalShutdown();
patch_World.firstRoom = true;
}
public void RealizeRoom(World world, RainWorldGame game)
{
orig_RealizeRoom(world, game);
if (MonklandSteamManager.isInGame)
{
MonklandSteamManager.WorldManager.ActivateRoom(this.name);
}
}
public SoundingGameSession(RainWorldGame game) : base(game)
{
this.PlayMode = false;
this.arenaSitting.currentLevel = 0;
if (this.noRain == null)
{
base.AddBehavior(new NoRain(this));
}
}
public void UpdateRoomList()
{
if (this.rainworldInstance.processManager.currentMainLoop is RainWorldGame)
{
RainWorldGame rainWorldGame = this.rainworldInstance.processManager.currentMainLoop as RainWorldGame;
this.loadedRooms.Clear();
this.loadedRooms.AddRange(rainWorldGame.world.activeRooms);
}
}
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>();
}
}
private static EntityID GetNewIDSwap(On.RainWorldGame.orig_GetNewID orig, RainWorldGame self)
{
int newID = UnityEngine.Random.Range(int.MinValue, int.MaxValue);
while (newID >= -1 && newID <= 15000)
{
newID = UnityEngine.Random.Range(int.MinValue, int.MaxValue);
}
return(new EntityID(-1, newID));
}
public static void RainWorldGame_Ctor_Post(RainWorldGame __instance, ProcessManager manager)
{
_player = __instance.session.Players[0];
if (!Directory.Exists(RecordingFolder))
{
Directory.CreateDirectory(RecordingFolder);
}
_writer = new StreamWriter(Path.Combine(RecordingFolder, GetNewReplayFileName()), false);
}
public new void LoadGame(string str, RainWorldGame game)
{
orig_LoadGame(str, game);
if (denPosition.Equals("SU_C04"))
{
Debug.Log("New Save File Created");
denPosition = "FS_A01";
this.deathPersistentSaveData.theMark = true;
}
}
private void FindPlayer(RainWorldGame game)
{
if (game.Players.Count > 0)
{
trackedPlayer = game.Players[0];
if (trackedPlayer != null)
{
currentRoom = trackedPlayer.Room.realizedRoom;
}
}
}
private void UpdateActive(RainWorldGame game)
{
if (Input.GetKey(KeyCode.O) && !oDown)
{
active = !active;
}
oDown = Input.GetKey(KeyCode.O);
game.devToolsActive = active;
game.devToolsLabel.isVisible = active;
setDevToolsActive?.Invoke(active);
}
private static void RainWorldGame_Win(On.RainWorldGame.orig_Win orig, RainWorldGame self, bool malnourished)
{
if (self.manager.upcomingProcess != null)
{
return;
}
Debug.Log("MALNOURISHED: " + malnourished);
if (!malnourished && !self.rainWorld.saveBackedUp)
{
self.rainWorld.saveBackedUp = true;
self.rainWorld.progression.BackUpSave("_Backup");
}
DreamsState dreamsState = self.GetStorySession.saveState.dreamsState;
if (self.manager.rainWorld.progression.miscProgressionData.starvationTutorialCounter > -1)
{
self.manager.rainWorld.progression.miscProgressionData.starvationTutorialCounter++;
}
if (self.GetStorySession.saveState.miscWorldSaveData.privSlOracleState != null && self.GetStorySession.saveState.miscWorldSaveData.privSlOracleState.playerEncounters > EncTresh)
{
if (!self.GetStorySession.lastEverMetMoon)
{
self.manager.CueAchievement((self.GetStorySession.saveState.miscWorldSaveData.SLOracleState.neuronsLeft < NeuronTresh) ? RainWorld.AchievementID.MoonEncounterBad : RainWorld.AchievementID.MoonEncounterGood, 5f);
if (dreamsState != null)
{
dreamsState.InitiateEventDream((self.GetStorySession.saveState.miscWorldSaveData.SLOracleState.neuronsLeft < NeuronTresh) ? DreamsState.DreamID.MoonThief : DreamsState.DreamID.MoonFriend);
}
}
else if (dreamsState != null && !dreamsState.everAteMoonNeuron && self.GetStorySession.saveState.miscWorldSaveData.SLOracleState.neuronsLeft < NeuronTresh)
{
dreamsState.InitiateEventDream(DreamsState.DreamID.MoonThief);
}
}
if (!self.GetStorySession.lastEverMetPebbles && self.GetStorySession.saveState.miscWorldSaveData.SSaiConversationsHad > 0)
{
self.manager.CueAchievement(RainWorld.AchievementID.PebblesEncounter, 5f);
if (self.StoryCharacter == 2)
{
self.manager.rainWorld.progression.miscProgressionData.redHasVisitedPebbles = true;
}
if (dreamsState != null)
{
dreamsState.InitiateEventDream(DreamsState.DreamID.Pebbles);
}
}
if (dreamsState != null)
{
dreamsState.EndOfCycleProgress(self.GetStorySession.saveState, self.world.region.name, self.world.GetAbstractRoom(self.Players[0].pos).name);
}
self.GetStorySession.saveState.SessionEnded(self, true, malnourished);
self.manager.RequestMainProcessSwitch((dreamsState == null || !dreamsState.AnyDreamComingUp) ? ProcessManager.ProcessID.SleepScreen : ProcessManager.ProcessID.Dream);
}
public void Update(RainWorldGame game)
{
if (Input.GetKeyDown(KeyCode.J))
{
shouldDisplayMessages = !shouldDisplayMessages;
}
FindPlayer(game);
DisplayQuickMessages();
}
private static void ShutDownProcessHK(On.RainWorldGame.orig_ShutDownProcess orig, RainWorldGame self)
{
if (MonklandSteamManager.isInGame)
{
MonklandSteamManager.monklandUI.ClearSprites();
MonklandSteamManager.monklandUI = null;
MonklandSteamManager.WorldManager.GameEnd();
mainGame = null;
}
orig(self);
}
public void ShutDownProcess()
{
if (MonklandSteamManager.isInGame)
{
MonklandSteamManager.monklandUI.ClearSprites();
MonklandSteamManager.monklandUI = null;
MonklandSteamManager.WorldManager.GameEnd();
mainGame = null;
}
OriginalShutdown();
}
private void RainWorldGame_GrafUpdate(On.RainWorldGame.orig_GrafUpdate orig, RainWorldGame self, float timeStacker)
{
if (disableInterpolation)
{
timeStacker = 1f;
}
orig(self, timeStacker);
foreach (InputGraphic display in inputGraphics)
{
display?.Update(timeStacker);
}
}
public void ctor(RainWorldGame game, Region region, string name, bool singleRoomWorld)
{
orig_ctor(game, region, name, singleRoomWorld);
if (game != null && !singleRoomWorld && game.session is StoryGameSession)
{
int oldSeed = UnityEngine.Random.seed;
UnityEngine.Random.seed = (game.session as StoryGameSession).saveState.seed + (game.session as StoryGameSession).saveState.cycleNumber;
this.rainCycle = new RainCycle(this, Mathf.Lerp((float)game.rainWorld.setup.cycleTimeMin, (float)game.rainWorld.setup.cycleTimeMax, UnityEngine.Random.value) / 60f);
UnityEngine.Random.seed = oldSeed;
Debug.Log("Cycle Length: " + this.rainCycle.cycleLength);
}
}
private void RoomCamera_ctor(On.RoomCamera.orig_ctor orig, RoomCamera self, RainWorldGame game, int cameraNumber)
{
orig(self, game, cameraNumber);
if (inputGraphics.Length <= cameraNumber)
{
Array.Resize(ref inputGraphics, cameraNumber + 1);
}
inputGraphics[self.cameraNumber]?.Remove();
InputGraphic ig = new InputGraphic(self);
inputGraphics[cameraNumber] = ig;
ig.Move();
}
public void Update()
{
if (mainGame == null)
{
mainGame = this;
}
orig_Update();
try {
MonklandSteamManager.monklandUI.Update(this);
} catch (System.Exception e) {
Debug.LogError(e);
}
}
public OptionalGameSession(RainWorldGame game) : base(game)
{
//this.PlayMode = this.arenaSitting.sandboxPlayMode;
//if (!this.PlayMode)
//{
this.arenaSitting.currentLevel = 0;
if (this.noRain == null)
{
base.AddBehavior(new NoRain(this));
}
//}
//else
//{
//this.arenaSitting.gameTypeSetup.UpdateCustomWinCondition();
//this.checkWinLose = (this.arenaSitting.players.Count > 0 && this.arenaSitting.gameTypeSetup.customWinCondition);
//}
}
public void ctor_RainWorldGame(ProcessManager manager)
{
OriginalConstructor(manager);
if (MonklandSteamManager.isInGame)
{
if (this.rainWorld.buildType == RainWorld.BuildType.Development)
{
this.devToolsActive = MonklandSteamManager.DEBUG;
}
MonklandSteamManager.monklandUI = new UI.MonklandUI(Futile.stage);
}
if (mainGame == null)
{
mainGame = this;
}
}
private static void ArenaCreatureSpawner_SpawnArenaCreatures(On.ArenaCreatureSpawner.orig_SpawnArenaCreatures orig,
RainWorldGame game, ArenaSetup.GameTypeSetup.WildLifeSetting wildLifeSetting, ref List <AbstractCreature> availableCreatures,
ref MultiplayerUnlocks unlocks)
{
foreach (KeyValuePair <string, string> keyValues in CustomWorldMod.activatedPacks)
{
string settingsPath = CRExtras.BuildPath(keyValues.Value, CRExtras.CustomFolder.Levels) + game.world.GetAbstractRoom(0).name + "_Arena.txt";
if (File.Exists(settingsPath))
{
CustomWorldMod.Log($"Custom Regions: Loading settings file in SpawnArenaCreatures. Path [{settingsPath}]");
string[] settingsFile = File.ReadAllLines(settingsPath);
SpawnArenaCreaturesVanilla(game, wildLifeSetting, ref availableCreatures, ref unlocks, settingsFile);
break;
}
}
orig(game, wildLifeSetting, ref availableCreatures, ref unlocks);
}
public void BringStomachUpToDate(RainWorldGame game)
{
bool flag = false;
for (int i = 0; i < game.session.Players.Count; i++)
{
if ((game.session.Players[i].realizedCreature as Player).objectInStomach != null)
{
flag = true;
break;
}
}
if (flag)
{
this.swallowedItems = new string[game.session.Players.Count];
for (int j = 0; j < game.session.Players.Count; j++)
{
if ((game.session.Players[j].realizedCreature as Player).objectInStomach != null)
{
if ((game.session.Players[j].realizedCreature as Player).objectInStomach is AbstractCreature)
{
AbstractCreature abstractCreature = (game.session.Players[j].realizedCreature as Player).objectInStomach as AbstractCreature;
if (game.world.GetAbstractRoom(abstractCreature.pos.room) == null)
{
abstractCreature.pos = (game.session.Players[j].realizedCreature as Player).coord;
}
this.swallowedItems[j] = SaveState.AbstractCreatureToString(abstractCreature);
}
else
{
this.swallowedItems[j] = (game.session.Players[j].realizedCreature as Player).objectInStomach.ToString();
}
}
else
{
this.swallowedItems[j] = "0";
}
}
}
else
{
this.swallowedItems = null;
}
}
private static void CtorHK(On.RainWorldGame.orig_ctor orig, RainWorldGame self, ProcessManager manager)
{
orig(self, manager);
if (MonklandSteamManager.isInGame)
{
lastMultiPauseButton = false;
if (self.rainWorld.buildType == RainWorld.BuildType.Development)
{
self.devToolsActive = MonklandSteamManager.DEBUG;
}
MonklandSteamManager.monklandUI = new UI.MonklandUI(Futile.stage);
}
if (mainGame == null)
{
mainGame = self;
}
}
public void Update(RainWorldGame game)
{
if (Input.GetKeyDown(KeyCode.Alpha1))
{
shouldDisplayOwners = !shouldDisplayOwners;
}
if (Input.GetKeyDown(KeyCode.Alpha2))
{
shouldDisplayBoxes = !shouldDisplayBoxes;
}
if (Input.GetKeyDown(KeyCode.Alpha3))
{
shouldDisplayMessages = !shouldDisplayMessages;
}
FindPlayer(game);
DisplayQuickMessages();
DisplayObjectOwners();
DisplayQuickBoxes();
}
private static void UpdateHK(On.RainWorldGame.orig_Update orig, RainWorldGame self)
{
if (mainGame == null)
{
mainGame = self;
}
if (!self.lastPauseButton)
{
self.lastPauseButton = MonklandSteamManager.isInGame;
}
orig(self);
try
{
if (MonklandSteamManager.isInGame)
{
if (MonklandSteamManager.monklandUI != null)
{
MonklandSteamManager.monklandUI.Update(self);
}
MonklandSteamManager.WorldManager.TickCycle();
bool flag = Input.GetKey(self.rainWorld.options.controls[0].KeyboardPause) || Input.GetKey(self.rainWorld.options.controls[0].GamePadPause) || Input.GetKey(KeyCode.Escape);
if (flag && !lastMultiPauseButton && (self.cameras[0].hud != null || self.cameras[0].hud.map.fade < 0.1f) && !self.cameras[0].hud.textPrompt.gameOverMode)
{
(self.cameras[0].hud.parts.Find(x => x is MultiplayerHUD) as MultiplayerHUD).ShowMultiPauseMenu();
}
lastMultiPauseButton = flag;
}
}
catch (Exception e)
{
Debug.LogError(e);
}
}
static void RainWorldGame_Update(On.RainWorldGame.orig_Update orig, RainWorldGame self)
{
orig(self);
if (self.Players.Count < 1)
{
return;
}
AbstractWorldEntity[] entities = self.world.offScreenDen.entitiesInDens.ToArray();
foreach (AbstractWorldEntity aEntity in entities)
{
if (aEntity is AbstractCreature aCreature && aCreature.creatureTemplate.type == CreatureTemplate.Type.Overseer)
{
OverseersPlugin.Logger_.LogInfo($"moving overseer {aCreature.ID} " +
$"from offscreen den to {self.Players[0].Room.name}");
aCreature.ChangeRooms(new WorldCoordinate(self.Players[0].Room.index, 1, 1, 0));
self.world.offScreenDen.entitiesInDens.Remove(aCreature);
}
}
}
private static void StoryGameSession_ctor(On.StoryGameSession.orig_ctor orig, StoryGameSession self, int saveStateNumber, RainWorldGame game)
{
orig.Invoke(self, saveStateNumber, game);
string saveFilePath = string.Concat(new object[]
{
Custom.RootFolderDirectory(),
"UserData",
Path.DirectorySeparatorChar,
self.game.rainWorld.options.SaveFileName,
".txt"
});
if (!File.Exists(saveFilePath) || !game.manager.menuSetup.LoadInitCondition || self.saveState.cycleNumber == 0) //New game
{
self.saveState.deathPersistentSaveData.theMark = true;
if (self.saveState.deathPersistentSaveData.karmaCap < KarmaAppetite.STARTING_MAX_KARMA)
{
self.saveState.deathPersistentSaveData.karmaCap = KarmaAppetite.STARTING_MAX_KARMA;
}
if (self.saveStateNumber != 2)
{
self.saveState.denPosition = "SB_S07";
if (self.saveState.miscWorldSaveData.privSlOracleState == null)
{
self.saveState.miscWorldSaveData.privSlOracleState = new SLOrcacleState(false, saveStateNumber);
}
self.saveState.miscWorldSaveData.privSlOracleState.miscPearlCounter = 6;
self.saveState.miscWorldSaveData.privSlOracleState.totalPearlsBrought = 6;
self.saveState.miscWorldSaveData.privSlOracleState.neuronsLeft = 6;
self.saveState.miscWorldSaveData.privSlOracleState.totNeuronsGiven = 1;
self.saveState.miscWorldSaveData.privSlOracleState.neuronGiveConversationCounter = 1;
self.saveState.miscWorldSaveData.privSlOracleState.totalItemsBrought = 7;
self.saveState.miscWorldSaveData.privSlOracleState.playerEncountersWithMark = 6;
self.saveState.miscWorldSaveData.privSlOracleState.playerEncounters = 7;
self.saveState.miscWorldSaveData.privSlOracleState.likesPlayer = 1f;
KarmaAppetite_MoonFix.FixInfluenceCap(self.saveState.miscWorldSaveData.privSlOracleState);
}
}
int neuronTresh = (self.saveState.saveStateNumber != 2) ? 6 : 5;
int encTresh = (self.saveState.saveStateNumber != 2) ? 7 : 0;
KarmaAppetite_MoonFix.SetTreshholds(encTresh, neuronTresh);
self.lastEverMetMoon = self.saveState.miscWorldSaveData.privSlOracleState != null && self.saveState.miscWorldSaveData.privSlOracleState.playerEncounters > encTresh;
KarmaAppetite.KarmaToFood(self.characterStats, self.saveState.deathPersistentSaveData.karma);
KarmaAppetite.FoodToStats(self.characterStats, self.saveState.food, self.saveState.deathPersistentSaveData.karma >= 9);
}
public patch_Room(RainWorldGame game, World world, AbstractRoom abstractRoom) : base(game, world, abstractRoom)
{
}
