static void EnvironmentSave_ApplyData_Post(EnvironmentSave __instance)
{
_safeZoneColliders.Clear();
GameObject fxHolder = GameObject.Find("Environment/Assets/FX");
if (fxHolder == null)
{
return;
}
foreach (Transform fx in fxHolder.transform)
{
if (fx.GOName().ContainsSubstring("butterfly"))
{
AmbienceSound ambienceSound = fx.GetComponentInChildren <AmbienceSound>();
if (Random.value <= _butterfliesSpawnChance / 100f)
{
fx.GOSetActive(true);
ambienceSound.MinVolume = ambienceSound.MaxVolume = 1;
_safeZoneColliders.Add(fx.GetComponent <SphereCollider>());
}
else
{
fx.GOSetActive(false);
ambienceSound.MinVolume = ambienceSound.MaxVolume = 0;
}
}
}
SetButterfliesRadius();
}
private List <EnvironmentSave> AreasWithExistingStashChests(SaveInstance save, string excludedAreaName = null, bool excludeEmptyStashChests = true)
{
if (save == null)
{
Debug.LogWarning("Linked Stash Chests: Tried to stash chest area saves from non-existent save. Aborting.");
return(null);
}
var list = new List <EnvironmentSave>();
foreach (string text in StashAreaToStashUID.Keys)
{
if (!string.Equals(text, excludedAreaName) && save.PathToSceneSaves.ContainsKey(text))
{
EnvironmentSave environmentSave = GetEnvironmentSave(save, text);
if (excludeEmptyStashChests && GetSavedStashItems(environmentSave).Count == 0)
{
Debug.Log("Linked Stash Chests: Skipping empty stash chest in " + text);
}
else
{
list.Add(environmentSave);
}
}
}
return(list);
}
private void RemoveSavedStashItems(EnvironmentSave areaSave)
{
if (areaSave == null)
{
Debug.LogWarning("Linked Stash Chests: Tried to remove stash items from non-existent area save. Aborting.");
return;
}
RemoveChestItems(StashAreaToStashUID[areaSave.AreaName], areaSave.ItemList);
}
private List <BasicSaveData> GetSavedStashItems(EnvironmentSave areaSave, string targetChestIdentifier = null)
{
if (areaSave == null)
{
Debug.LogWarning("Linked Stash Chests: Tried to get stash items from non-existent area save. Aborting.");
return(null);
}
return(GetSavedChestItems(StashAreaToStashUID[areaSave.AreaName], areaSave.ItemList, targetChestIdentifier));
}
private static EnvironmentSave GetEnvironmentSave(SaveInstance save, string areaName)
{
var environmentSave = new EnvironmentSave {
AreaName = areaName
};
if (!environmentSave.LoadFromFile(save.SavePath))
{
Debug.LogWarning($"Linked Stash Chests: Tried load non-existent area save '{areaName}'. Aborting.");
return(null);
}
return(environmentSave);
}
public static bool ApplyData(EnvironmentSave __instance)
{
// LastGameTime must take the value of the last moment when we were on the map.
// This value will then be applied to items which will use it to calculate the durability cost.
RottenStashes.MyLogger.LogDebug($"ApplyData");
RottenStashes.MyLogger.LogDebug($" > SavedGameTime={GameTimetoDays(__instance.GameTime)}");
RottenStashes.MyLogger.LogDebug($" > CurrentGameTime={GameTimetoDays(EnvironmentConditions.GameTime)}");
RottenStashes.LastGameTime = __instance.GameTime > 0 ? __instance.GameTime : EnvironmentConditions.GameTime;
RottenStashes.MyLogger.LogDebug($" > LastGameTime={GameTimetoDays(RottenStashes.LastGameTime)}");
if (EnvironmentConditions.GameTime > 0)
{
RottenStashes.MyLogger.LogDebug($" > Diff={GameTimetoDays(EnvironmentConditions.GameTime - RottenStashes.LastGameTime)}");
}
return(true);
}
private void EnvironmentSave_ApplyData(On.EnvironmentSave.orig_ApplyData orig, EnvironmentSave self)
{
bool resetEnemies = false;
AreaManager.AreaEnum areaN = (AreaManager.AreaEnum)AreaManager.Instance.GetAreaIndexFromSceneName(self.AreaName);
if (areaN == AreaManager.AreaEnum.CierzoOutside ||
areaN == AreaManager.AreaEnum.Abrassar ||
areaN == AreaManager.AreaEnum.Emercar ||
areaN == AreaManager.AreaEnum.HallowedMarsh)
{
resetEnemies = true;
}
float num = (float)(self.GameTime - EnvironmentConditions.GameTime);
if (num > 0f)
{
EnvironmentConditions.GameTime = self.GameTime;
}
if (!AreaManager.Instance.IsAreaExpired(self.AreaName, num))
{
ItemManager.Instance.LoadItems(self.ItemList, _clearAllItems: true);
CharacterManager.Instance.LoadAiCharactersFromSave(self.CharList.ToArray());
SceneInteractionManager.Instance.LoadInteractableStates(self.InteractionActivatorList);
SceneInteractionManager.Instance.LoadDropTableStates(self.DropTablesList);
CampingEventManager.Instance.LoadEventTableData(self.CampingEventSaveData);
DefeatScenariosManager.Instance.LoadSaveData(self.DefeatScenarioSaveData);
EnvironmentConditions.Instance.LoadSoulSpots(self.UsedSoulSpots);
MapDisplay.Instance.Load(self.MapSaveData);
}
else if (resetEnemies)
{
CharacterManager.Instance.LoadAiCharactersFromSave(self.CharList.ToArray());
}
//OLogger.Log($"Enter {self.AreaName} at {GameTimetoDays(EnvironmentConditions.GameTime)}");
//OLogger.Log($" > Last visit was {GameTimetoDays(self.GameTime)})");
//orig.Invoke(self);
//ItemManager.Instance.LoadItems(self.ItemList, _clearAllItems: true);
//SceneInteractionManager.Instance.LoadInteractableStates(self.InteractionActivatorList);
//SceneInteractionManager.Instance.LoadDropTableStates(self.DropTablesList);
}
private bool SaveInstance_ApplyEnvironment(On.SaveInstance.orig_ApplyEnvironment orig, SaveInstance self)
{
bool result = orig.Invoke(self);
EnvironmentSave loadedScene = GetPrivatePart <EnvironmentSave, SaveInstance>(self, "m_loadedScene");
if (loadedScene == null || !StashAreaToStashUID.ContainsKey(loadedScene.AreaName))
{
return(result);
}
string areaName = loadedScene.AreaName;
List <EnvironmentSave> otherAreaSaves = AreasWithExistingStashChests(self, areaName);
if (otherAreaSaves.Count == 0)
{
Debug.Log("Linked Stash Chests: No other stash chests to sync with.");
return(result);
}
var treasureChest = (TreasureChest)ItemManager.Instance.GetItem(StashAreaToStashUID[areaName]);
if (treasureChest == null)
{
Debug.LogWarning("Linked Stash Chests: Could not get loaded stash chest in " + areaName + ". Aborting.");
return(result);
}
var bufferedLog = new StringBuilder();
try
{
BasicSaveData basicSaveData = null;
var currentStashItems = new List <BasicSaveData>();
if (self.PathToSceneSaves.ContainsKey(areaName))
{
basicSaveData = GetSavedStashChest(loadedScene);
currentStashItems = GetSavedStashItems(loadedScene);
}
if (basicSaveData == null)
{
basicSaveData = new BasicSaveData(treasureChest.UID, treasureChest.ToSaveData());
}
bufferedLog.AppendLine("--------------------------------- Linked Stash Chests ---------------------------------");
bufferedLog.AppendLine($"{areaName}'s stash chest BEFORE pulling all other stash chest items into it:");
bufferedLog.AppendLine($"{currentStashItems.Count} items: {basicSaveData.Identifier} {basicSaveData.SyncData}");
foreach (EnvironmentSave otherAreaSave in otherAreaSaves)
{
BasicSaveData otherStashChest = GetSavedStashChest(otherAreaSave);
List <BasicSaveData> otherStashItems = GetSavedStashItems(otherAreaSave, StashAreaToStashUID[areaName]);
bufferedLog.AppendLine();
bufferedLog.AppendLine($"{otherAreaSave.AreaName}'s SAVED stash chest BEFORE pulling all its items into {areaName}'s stash chest:");
bufferedLog.AppendLine($"{otherStashItems.Count} items: {(otherStashChest == null ? "null" : otherStashChest.Identifier + " " + otherStashChest.SyncData)}");
RemoveSavedStashItems(otherAreaSave);
ItemManager.Instance.LoadItems(otherStashItems);
int savedStashSilver = GetSavedStashSilver(otherStashChest);
SetSavedStashSilver(0, otherStashChest);
AddSavedStashSilver(savedStashSilver, basicSaveData);
ItemManager.Instance.LoadItems(new List <BasicSaveData>(1)
{
basicSaveData
});
currentStashItems.AddRange(otherStashItems);
otherAreaSave.ProcessSave();
otherStashItems = GetSavedStashItems(otherAreaSave, StashAreaToStashUID[areaName]);
bufferedLog.AppendLine($"{otherAreaSave.AreaName}'s SAVED stash chest AFTER pulling all its items into {areaName}'s stash chest:");
bufferedLog.AppendLine($"{otherStashItems.Count} items): {(otherStashChest == null ? "null" : otherStashChest.Identifier + " " + otherStashChest.SyncData)}");
}
bufferedLog.AppendLine();
bufferedLog.AppendLine($"{areaName}'s stash chest AFTER pulling all other stash chest items into it:");
bufferedLog.AppendLine($"{currentStashItems.Count} items: {basicSaveData.Identifier + " " + basicSaveData.SyncData}");
bufferedLog.AppendLine("---------------------------------------------------------------------------------------");
}
finally
{
Debug.Log(bufferedLog.ToString());
}
return(result);
}
private static void LoadItemsFromScene(TreasureChest currentStash, SaveInstance instance, string areaName)
{
// Load the save data for the area
var save = new EnvironmentSave();
save.AreaName = areaName;
if (save.LoadFromFile(instance.SavePath))
{
var otherStashUID = StashAreaToStashUID[areaName];
// the expected hierarchy data for items in the stashes
string oldStashHierarchy = $"Hierarchy>1{otherStashUID}";
string newStashHierarchy = $"Hierarchy>1{currentStash.UID}";
// get items in the stash, remove from old save and add to our list
bool needSaveOtherScene = false;
var dataToSync = new List <BasicSaveData>();
for (int i = save.ItemList.Count - 1; i >= 0; i--)
{
var data = save.ItemList[i];
// if item is in the stash
if (data.SyncData.Contains(oldStashHierarchy))
{
needSaveOtherScene = true;
// remove from the old scene save
save.ItemList.RemoveAt(i);
// change the parent from the old stash to the new one
data.SyncData = data.SyncData.Replace(oldStashHierarchy, newStashHierarchy);
// add to our data to sync
dataToSync.Add(data);
}
// if item is the stash itself
else if ((string)data.Identifier == otherStashUID)
{
// get the contained silver. could serialize it all and split, but this is a bit more optimized.
var sb = new StringBuilder();
// index of the silver value (string is 28 chars, plus the '/' separator)
int idx = data.SyncData.IndexOf("TreasureChestContainedSilver") + 29;
while (idx < data.SyncData.Length)
{
char c = data.SyncData[idx];
if (!char.IsDigit(c))
{
break;
}
sb.Append(c);
idx++;
}
int silver = int.Parse(sb.ToString());
if (silver > 0)
{
needSaveOtherScene = true;
// remove the silver
data.SyncData = data.SyncData.Replace($"TreasureChestContainedSilver/{silver};", "TreasureChestContainedSilver/0;");
// add to this scene
currentStash.AddSilver(silver);
}
}
}
if (needSaveOtherScene)
{
// save the other scene to finalize removing the items and silver
save.ProcessSave();
// load the item data into this scene's stash
if (dataToSync.Any())
{
ItemManager.Instance.LoadItems(dataToSync, false);
}
Log.LogMessage($"Loaded stashed items from {areaName}");
}
}
}
static bool EnvironmentSave_ApplyData_Pre(EnvironmentSave __instance)
{
#region quit
if (!_areasToggle)
{
return(true);
}
#endregion
// Initialize game time
if (GameTime < (float)__instance.GameTime)
{
GameTime = (float)__instance.GameTime;
}
// Persistent areas
AreaManager.AreaEnum areaEnum = (AreaManager.AreaEnum)AreaManager.Instance.GetAreaFromSceneName(__instance.AreaName).ID;
bool isAreaPermanent = AreaManager.Instance.PermenantAreas.Contains(areaEnum);
bool resetArea = _areasResetLayers.Value.HasFlag(AreasResetLayers.Cities) || !isAreaPermanent;
// Area modes
float sinceLastVisit = GameTime - (float)__instance.GameTime;
float sinceLastReset = GameTime - __instance.SaveCreationGameTime;
resetArea &= _areasMode == ResetMode.Always ||
_areasMode == ResetMode.Timer &&
sinceLastVisit >= _areasTimer * TIME_UNIT &&
sinceLastReset >= _areasTimerSinceReset * TIME_UNIT;
// Execute
if (resetArea)
{
__instance.SaveCreationGameTime = GameTime.RoundDown();
}
if (!resetArea || !_areasResetLayers.Value.HasFlag(AreasResetLayers.Enemies))
{
CharacterManager.Instance.LoadAiCharactersFromSave(__instance.CharList.ToArray());
}
else
{
RemovePouchItemsFromSaveData(__instance.ItemList);
}
if (!resetArea || !_areasResetLayers.Value.HasFlag(AreasResetLayers.ItemsAndContainers))
{
ItemManager.Instance.LoadItems(__instance.ItemList, true);
}
if (!resetArea || !_areasResetLayers.Value.HasFlag(AreasResetLayers.Switches))
{
SceneInteractionManager.Instance.LoadInteractableStates(__instance.InteractionActivatorList);
}
if (!resetArea || !_areasResetLayers.Value.HasFlag(AreasResetLayers.Gatherables))
{
SceneInteractionManager.Instance.LoadDropTableStates(__instance.DropTablesList);
}
if (!resetArea || !_areasResetLayers.Value.HasFlag(AreasResetLayers.AmbushEvents))
{
CampingEventManager.Instance.LoadEventTableData(__instance.CampingEventSaveData);
}
if (!resetArea || !_areasResetLayers.Value.HasFlag(AreasResetLayers.DeathEvents))
{
DefeatScenariosManager.Instance.LoadSaveData(__instance.DefeatScenarioSaveData);
}
if (!resetArea || !_areasResetLayers.Value.HasFlag(AreasResetLayers.Souls))
{
EnvironmentConditions.Instance.LoadSoulSpots(__instance.UsedSoulSpots);
}
return(false);
}
private void EnvironmentSave_PrepareSave(On.EnvironmentSave.orig_PrepareSave orig, EnvironmentSave self)
{
OLogger.Log($"Quit {self.AreaName} at {GameTimetoDays(EnvironmentConditions.GameTime)}");
//OLogger.Log($" > what is: {GameTimetoDays(self.GameTime)})");
double bkp = self.GameTime;
OLogger.Log($" > 1) {GameTimetoDays(self.GameTime)})");
orig.Invoke(self);
OLogger.Log($" > 2) {GameTimetoDays(self.GameTime)})");
//if (bkp > 0)
self.GameTime = bkp;
OLogger.Log($" > 3) {GameTimetoDays(self.GameTime)})");
}
