public static void onUpdate(object sender, EventArgs args)
{
try
{
Multiplayer.update();
// We need our load menu to be able to do things
if (Game1.activeClickableMenu is TitleMenu)
{
if (TitleMenu.subMenu != null && (TitleMenu.subMenu.GetType() == typeof(LoadGameMenu)))
{
LoadGameMenu oldLoadMenu = ( LoadGameMenu )TitleMenu.subMenu;
NewLoadMenu newLoadMenu = new NewLoadMenu();
IPrivateField <object> task = instance.Helper.Reflection.GetPrivateField <object>(oldLoadMenu, "_initTask");
newLoadMenu._initTask = (Task <List <SFarmer> >)task.GetValue();
TitleMenu.subMenu = newLoadMenu;
}
}
prevMenu = Game1.activeClickableMenu;
}
catch (Exception e)
{
Log.error("Exception during update: " + e);
}
}
public override void NextItem()
{
LoadGameMenu menu = stardewMenu as LoadGameMenu;
int currentItemIndex = ModEntry.GetHelper().Reflection.GetField <int>(menu, "currentItemIndex").GetValue();
if (current != null && current != backButton)
{
itemIdx += 1;
}
else
{
itemIdx = 0;
}
if (itemIdx < itemCount)
{
if (itemIdx >= LoadGameMenu.itemsPerPage)
{
ModEntry.GetHelper().Reflection.GetMethod(menu, "downArrowPressed").Invoke();
}
}
else
{
itemIdx = 0;
ModEntry.GetHelper().Reflection.GetField <int>(menu, "currentItemIndex").SetValue(0);
}
base.NextItem();
}
internal static void Activate()
{
saveGameMenu.gameObject.SetActive(true);
LoadGameMenu.SearchForSaves(content);
pathToSaveIn = defaultPathToSaveIn;
SaveNameInputField.UpdateInputFieldText();
}
public override void PrevItem()
{
LoadGameMenu menu = stardewMenu as LoadGameMenu;
int currentItemIndex = ModEntry.GetHelper().Reflection.GetField <int>(menu, "currentItemIndex").GetValue();
if (current != null && current != backButton)
{
itemIdx -= 1;
}
else if (current == null)
{
itemIdx = 0;
ModEntry.GetHelper().Reflection.GetField <int>(menu, "currentItemIndex").SetValue(0);
}
else if (current == backButton)
{
if (ModEntry.GetHelper().Reflection.GetField <int>(menu, "currentItemIndex").GetValue() == 0)//not scrolled
{
for (int i = 0; i <= itemCount - LoadGameMenu.itemsPerPage; i++)
{
ModEntry.GetHelper().Reflection.GetMethod(menu, "downArrowPressed").Invoke();
}
}
itemIdx = itemCount - 1;
}
if (itemIdx >= LoadGameMenu.itemsPerPage - 1)
{
ModEntry.GetHelper().Reflection.GetMethod(menu, "upArrowPressed").Invoke();
}
else
{
}
base.PrevItem();
}
/// <summary>Patch the textures in the load menu if it's active.</summary>
private void PatchLoadMenu()
{
if (!(Game1.activeClickableMenu is TitleMenu))
{
return;
}
// get load menu
LoadGameMenu loadMenu = TitleMenu.subMenu as LoadGameMenu;
if (loadMenu == null || loadMenu == this.PreviousLoadMenu)
{
return;
}
// wait until menu is initialised
if (this.Helper.Reflection.GetPrivateValue <Task <List <SFarmer> > >(loadMenu, "_initTask") != null)
{
return;
}
this.PreviousLoadMenu = loadMenu;
// override load-game textures
if (!this.Farmers.Any())
{
// get saves
this.Farmers = this.Helper.Reflection.GetPrivateValue <List <SFarmer> >(loadMenu, "saveGames").ToArray();
// override textures
foreach (SFarmer saveEntry in this.Farmers)
{
// get save info (save name stuffed into favorite thing field)
string saveName = saveEntry.favoriteThing;
LocalConfig config;
if (!this.FarmerConfigs.TryGetValue(saveName, out config))
{
//if (!this.FarmerConfigs.TryGetValue(saveName, out LocalConfig config))
continue;
}
// initialise for first run
if (config.FirstRun)
{
config.ChosenAccessory[0] = saveEntry.accessory;
config.FirstRun = false;
this.Helper.WriteJsonFile(Path.Combine("psconfigs", $"{config.SaveName}.json"), config);
}
// override textures
this.PatchFarmerTexture(saveEntry, config);
saveEntry.accessory = config.ChosenAccessory[0];
}
}
// inject new farmers
this.Helper.Reflection
.GetPrivateField <List <SFarmer> >(loadMenu, "saveGames")
.SetValue(this.Farmers.ToList());
}
public static bool Prefix(LoadGameMenu __instance)
{
if (__instance is CoopMenu menu)
{
StartPopulation?.Invoke(menu);
}
return(true);
}
void Start()
{
Instance = this;
GenerateLoadGamesMenu();
DeleteOldBackupFolders();
StartCoroutine(ContinuouslyCheckForNewSaves());
}
public static void Initialize()
{
mainMenu = new MainMenu();
LoadGameMenu = new LoadGameMenu();
ingameMenu = new IngameMenu();
newGameMenu = new NewGameMenu();
SlotSelector = new SlotSelector();
OptionMenuManager.Initialize();
}
public void CloseMenu(Menus menu)
{
switch (menu)
{
case Menus.MainMenu:
MainMenu.Close();
CurrentMenu = null;
break;
case Menus.NewGameMenu:
NewGameMenu.Close();
CurrentMenu = null;
break;
case Menus.GameInfoMenu:
GameInfoMenu.Close();
break;
case Menus.AdvancedSettingsMenu:
AdvancedSettingsMenu.Close();
break;
case Menus.HighscoresMenu:
HighscoresMenu.Close();
CurrentMenu = null;
break;
case Menus.LoadGameMenu:
LoadGameMenu.Close();
CurrentMenu = null;
break;
case Menus.ConfirmStepWindow:
ConfirmStepWindow.Close();
break;
case Menus.PlayAgainWindow:
PlayAgainWindow.Close();
break;
case Menus.PauseWindow:
PauseWindow.Close();
CurrentMenu = null;
break;
case Menus.SaveGameWindow:
SaveGameWindow.Close();
CurrentMenu = null;
break;
case Menus.LoadGameWindow:
LoadGameWindow.Close();
CurrentMenu = null;
break;
}
}
public void ResetLoadButtons()
{
LoadGameMenu menu = stardewMenu as LoadGameMenu;
int currentItemIndex = ModEntry.GetHelper().Reflection.GetField <int>(menu, "currentItemIndex").GetValue();
ClearItems();
string ShortDescr(int idx)
{
StardewValley.Farmer farmer = (menuSlots[idx] as LoadGameMenu.SaveFileSlot).Farmer;
return($"slot {idx + 1}: {farmer.Name} on {farmer.farmName} farm");
}
string LongDescr(int idx)
{
StardewValley.Farmer farmer = (menuSlots[idx] as LoadGameMenu.SaveFileSlot).Farmer;
string season = "";
switch (farmer.seasonForSaveGame)
{
case 0: season = "spring"; break;
case 1: season = "summer"; break;
case 2: season = "fall"; break;
case 3: season = "winter"; break;
default: season = ""; break;
}
string timePlayed = StardewValley.Utility.getHoursMinutesStringFromMilliseconds(farmer.millisecondsPlayed);
return($"Day {farmer.dayOfMonthForSaveGame} of {season} in year {farmer.yearForSaveGame}. Playtime {timePlayed}. Press delete button to delete.");
}
for (int j = 0; j < System.Math.Min(itemCount, LoadGameMenu.itemsPerPage); j++)
{
MenuItem menuItem = MenuItem.MenuItemFromComponent(menu.slotButtons[j], menu, ShortDescr(j));
menuItem.Description = LongDescr(j);
menuItem.TextOnAction = "Loading " + ShortDescr(j);
AddItem(menuItem);
}
for (int j = LoadGameMenu.itemsPerPage; j < itemCount; j++)
{
MenuItem menuItem = MenuItem.MenuItemFromComponent(menu.slotButtons[LoadGameMenu.itemsPerPage - 1], menu, ShortDescr(j));
menuItem.Description = LongDescr(j);
menuItem.TextOnAction = "Loading " + ShortDescr(j);
AddItem(menuItem);
}
backButton = MenuItem.MenuItemFromComponent(menu.backButton, StardewValley.Game1.activeClickableMenu);
backButton.Label = "back to title";
backButton.TextOnAction = AccessTitleMenu.Title();
AddItem(backButton);
}
/// <summary>Perform any logic needed on update while the animation is active.</summary>
/// <param name="playerAnimationID">The player's current animation ID.</param>
public override void Update(int playerAnimationID)
{
LoadGameMenu menu = (LoadGameMenu)this.Reflection.GetField <IClickableMenu>(typeof(TitleMenu), "_subMenu").GetValue();
IReflectedField <int> timerToLoad = this.GetTimerToLoad(menu);
for (int i = 1; i < this.Multiplier && timerToLoad.GetValue() > 0; i++)
{
menu.update(Game1.currentGameTime);
}
}
/// <summary>Perform any logic needed on update while the animation is active.</summary>
/// <param name="playerAnimationID">The player's current animation ID.</param>
public override void Update(int playerAnimationID)
{
LoadGameMenu menu = (LoadGameMenu)this.Reflection.GetField <IClickableMenu>(typeof(TitleMenu), "_subMenu").GetValue();
IReflectedField <int> timerToLoad = this.GetTimerToLoad(menu);
this.ApplySkips(
run: () => menu.update(Game1.currentGameTime),
until: () => timerToLoad.GetValue() <= 0
);
}
/// <summary>Patches the load menu</summary>
/// <param name="menu">The menu to patch</param>
private void PatchLoadMenu(LoadGameMenu menu)
{
//Don't want to patch the coop menu
if (menu is CoopMenu)
{
return;
}
//Relfedt into the task that is running
IReflectedField <Task <List <SFarmer> > > task = Entry.Helper.Reflection.GetField <Task <List <SFarmer> > >(menu, "_initTask");
if (!TaskStarted)
{
if (task == null || task.GetValue() == null)
{
return;
}
if (!task.GetValue().IsCompleted)
{
TaskStarted = true;
return;
}
}
else
{
if (task != null && task.GetValue() != null && !task.GetValue().IsCompleted)
{
return;
}
}
TaskStarted = false;
PreviousLoadMenu = menu;
//Find the saved games
if (!Farmers.Any())
{
Farmers = Entry.Helper.Reflection.GetMethod(typeof(LoadGameMenu), "FindSaveGames").Invoke <List <SFarmer> >();
}
//Create a new instance of the list
Type elementType = Type.GetType("StardewValley.Menus.LoadGameMenu+MenuSlot, Stardew Valley");
Type listType = typeof(List <>).MakeGenericType(new Type[] { elementType });
object list = Activator.CreateInstance(listType);
//Set value of the menu slots and invoke addSaveFiles method
Entry.Helper.Reflection.GetField <object>(menu, "menuSlots").SetValue(list);
Entry.Helper.Reflection.GetMethod(menu, "addSaveFiles").Invoke(Farmers);
//Add the Patch Farmer event
Entry.Helper.Events.GameLoop.UpdateTicked += OnUpdateTickedPatchLoadMenuFarmer;
}
void OnClick()
{
if (LoadGameMenu.selectedSavePath == null)
{
return;
}
SaveSystem.LoadSaveFile(LoadGameMenu.selectedSavePath);
LobbyPlayersCounter.OnLoadGame(SaveSystem.loadedSave.playersData.Count);
LobbyManager.lobbyManager.StartCoroutine(LobbyManager.ServerActivateLoadHeaders());
LoadGameMenu.Deactivate();
}
internal static void LoadGameMenuPatch(SaveFileSlot __instance, LoadGameMenu ___menu, int i)
{
try
{
int x = Game1.getMouseX(true), y = Game1.getMouseY(true);
if (___menu.slotButtons[i].containsPoint(x, y))
{
if (__instance.Farmer != null)
{
#region Farms
if (___menu.deleteButtons.Count > 0 && ___menu.deleteButtons[i].containsPoint(x, y))
{
MainClass.ScreenReader.SayWithChecker($"Delete {__instance.Farmer.farmName.Value} Farm", true);
return;
}
if (___menu.deleteConfirmationScreen)
{
// Used diff. functions to narrate to prevent it from speaking the message again on selecting another button.
string message = "Really delete farm?";
MainClass.ScreenReader.SayWithChecker(message, true);
if (___menu.okDeleteButton.containsPoint(x, y))
{
MainClass.ScreenReader.SayWithMenuChecker("Ok Button", false);
}
else if (___menu.cancelDeleteButton.containsPoint(x, y))
{
MainClass.ScreenReader.SayWithMenuChecker("Cancel Button", false);
}
return;
}
String farmerName = __instance.Farmer.displayName;
String farmName = __instance.Farmer.farmName.Value;
String money = __instance.Farmer.Money.ToString();
String hoursPlayed = Utility.getHoursMinutesStringFromMilliseconds(__instance.Farmer.millisecondsPlayed);
string dateStringForSaveGame = ((!__instance.Farmer.dayOfMonthForSaveGame.HasValue ||
!__instance.Farmer.seasonForSaveGame.HasValue ||
!__instance.Farmer.yearForSaveGame.HasValue) ? __instance.Farmer.dateStringForSaveGame : Utility.getDateStringFor(__instance.Farmer.dayOfMonthForSaveGame.Value, __instance.Farmer.seasonForSaveGame.Value, __instance.Farmer.yearForSaveGame.Value));
string toSpeak = $"{farmName} Farm Selected, \t\n Farmer:{farmerName}, \t\nMoney:{money}, \t\nHours Played:{hoursPlayed}, \t\nDate:{dateStringForSaveGame}";
MainClass.ScreenReader.SayWithChecker(toSpeak, true);
#endregion
}
}
}
catch (Exception e)
{
MainClass.ErrorLog($"Unable to narrate Text:\n{e.Message}\n{e.StackTrace}");
}
}
void OnClick()
{
switch (UnityEngine.SceneManagement.SceneManager.GetActiveScene().name)
{
case "TitleScene":
LoadGameMenu.SearchForSaves(LoadGameMenu.content);
break;
case "GameScene":
LoadGameMenu.SearchForSaves(SaveGameMenu.content);
SaveGameMenu.pathToSaveIn = SaveGameMenu.defaultPathToSaveIn;
SaveNameInputField.UpdateInputFieldText();
break;
}
}
private void Start()
{
mainMenu = this;
startGameMenu = transform.parent.Find("StartGameMenu");
joinGameMenu = transform.parent.Find("JoinGameMenu");
optionsMenu = transform.parent.Find("OptionsMenu");
profilePanel = transform.parent.Find("ProfilePanel");
lobby = transform.parent.Find("Lobby");
lobbyPanel = lobby.Find("LobbyPanel");
pILLoadHeader = lobbyPanel.transform.Find("LoadHeader").GetComponent <PILLoadHeader>();
PortInputField = joinGameMenu.Find("PortInput").GetComponent <TMP_InputField>();
IPAdressInputField = joinGameMenu.Find("IPAdressInput").GetComponent <TMP_InputField>();
NicknameInOptionsInput = optionsMenu.Find("NicknameInput").GetComponent <TMP_InputField>();
NicknameInProfilePanelText = profilePanel.Find("PlayersNickName").GetComponent <TextMeshProUGUI>();
LoadGameMenu.Initialize();
SetIPAdressToJoin();
SetPortToJoin();
}
public AccessLoadMenu(LoadGameMenu menu) : base(menu)
{
menuSlots = ModEntry.GetHelper().Reflection.GetField <List <LoadGameMenu.MenuSlot> >(menu, "menuSlots").GetValue();
itemCount = menuSlots.Count;
//ModEntry.Log($"menuSlots.Count == " + menuSlots.Count);
//ModEntry.Log($"slotButtons.Count == " + menu.slotButtons.Count);
//AddItem(menuItem);
//LoadGameMenu.itemsPerPage
//menu.slotButtons
//menuSlots
//down arrow
//up arrow
//deleteButtons
ResetLoadButtons();
confirmDeleteButton = MenuItem.MenuItemFromComponent(menu.okDeleteButton, menu, "delete save file");
confirmDeleteButton.speakOnClickAction -= confirmDeleteButton.DefaultSpeakOnClickAction;
//menuslots: all save file slots
//slotButtons: only 4 buttons
}
private void Event_PatchLoadMenuFarmer(object sender, EventArgs e)
{
if (!(Game1.activeClickableMenu is TitleMenu))
{
m_events.GameLoop.UpdateTicked -= Event_PatchLoadMenuFarmer;
return;
}
// get load menu
LoadGameMenu loadMenu = TitleMenu.subMenu as LoadGameMenu;
if (loadMenu == null || loadMenu != m_previousLoadMenu)
{
m_events.GameLoop.UpdateTicked -= Event_PatchLoadMenuFarmer;
return;
}
PatchLoadMenuFarmerTexture();
m_events.GameLoop.UpdateTicked -= Event_PatchLoadMenuFarmer;
}
public void Assign(LoadGameMenu menu, SavesFolder.Entry save)
{
Debug.Assert(menu);
Debug.Assert(save != null);
loadGameMenu = menu;
SaveEntry = save;
var incompatible = save.Header.Version != SaveHeader.CURRENT_VERSION;
if (incompatible)
{
entryText.text = "Incompatible save";
}
else
{
var time = save.Header.TimeStamp.ToString("yyyy/MM/dd HH:mm", CultureInfo.InvariantCulture);
entryText.text = string.Format("{0} - {1}", save.Header.CharacterName, time);
}
}
private void LoadExistingGame()
{
string[] fileNames = DataManager.GetSaveFiles("Saves");
string[] validFiles = DataManager.GetValidFiles(@"Saves\", fileNames);
if (validFiles.Length > 1)
{
//show menu and select SaveGame
Menu loadMenu = new LoadGameMenu(validFiles);
Display.ClearConsole();
loadMenu.DisplayMenuElements("Which game do you want to load?");
string playerChoice = loadMenu.GetChoiceFromPlayerInput();
currentSaveFileName = playerChoice;
LoadWorldAndPlayerFromSavedFile(playerChoice);
}
else
{
//automatically load the only file.
LoadWorldAndPlayerFromSavedFile(validFiles[0]);
currentSaveFileName = validFiles[0];
}
}
/// <summary>Update ticked event that allows the farmer textures to be patched</summary>
/// <param name="sender">The object</param>
/// <param name="e">The update ticked event argument</param>
private void OnUpdateTickedPatchLoadMenuFarmer(object sender, UpdateTickedEventArgs e)
{
//If it's not the title menu then remove the event
if (!(Game1.activeClickableMenu is TitleMenu))
{
Entry.Helper.Events.GameLoop.UpdateTicked -= OnUpdateTickedPatchLoadMenuFarmer;
return;
}
//Create a new load menu
LoadGameMenu loadMenu = TitleMenu.subMenu as LoadGameMenu;
if (loadMenu == null || loadMenu != PreviousLoadMenu)
{
Entry.Helper.Events.GameLoop.UpdateTicked -= OnUpdateTickedPatchLoadMenuFarmer;
return;
}
//Patch the farmer texture and remove the event
PatchLoadMenuFarmerTexture();
Entry.Helper.Events.GameLoop.UpdateTicked -= OnUpdateTickedPatchLoadMenuFarmer;
}
/// <summary>Raised after the game state is updated (≈60 times per second).</summary>
/// <param name="sender">The event sender.</param>
/// <param name="e">The event arguments.</param>
public static void OnUpdateTicked(object sender, UpdateTickedEventArgs e)
{
if (DEBUG)
{
Game1.options.pauseWhenOutOfFocus = false;
}
try
{
IPlatform.instance.update();
Multiplayer.update();
// We need our load menu to be able to do things
if (Game1.activeClickableMenu is TitleMenu)
{
if (TitleMenu.subMenu is LoadGameMenu)
{
Log.debug("Found vanilla load game menu, replacing with ours.");
Multiplayer.lobby = true;
LoadGameMenu oldLoadMenu = ( LoadGameMenu )TitleMenu.subMenu;
NewLoadMenu newLoadMenu = new NewLoadMenu();
IReflectedField <object> task = instance.Helper.Reflection.GetField <object>(oldLoadMenu, "_initTask");
newLoadMenu._initTask = (Task <List <SFarmer> >)task.GetValue();
Log.debug("Stole the save listing task, set it to: " + task);
TitleMenu.subMenu = newLoadMenu;
}
}
prevMenu = Game1.activeClickableMenu;
}
catch (Exception ex)
{
Log.error("Exception during update: " + ex);
}
}
/// <summary>Patch the textures in the load menu if it's active.</summary>
private void PatchLoadMenu(LoadGameMenu loadMenu)
{
// ignore multiplayer load menu
if (loadMenu is CoopMenu)
{
return;
}
//Monitor.Log("PatchLoadMenu");
// wait until menu is initialised
IReflectedField <Task <List <SFarmer> > > tsk = m_env.Helper.Reflection.GetField <Task <List <SFarmer> > >(loadMenu, "_initTask");
if (!m_taskStarted)
{
if (tsk == null || tsk.GetValue() == null)
{
return;
}
if (!tsk.GetValue().IsCompleted)
{
m_taskStarted = true;
return;
}
}
else
{
if (tsk != null && tsk.GetValue() != null && !tsk.GetValue().IsCompleted)
{
return;
}
}
m_taskStarted = false;
this.m_previousLoadMenu = loadMenu;
// load saves if empty
if (!m_farmers.Any())
{
m_farmers = m_env.Helper.Reflection.GetMethod(typeof(LoadGameMenu), "FindSaveGames").Invoke <List <SFarmer> >();
}
// create a new List<MenuSlot> instance to replace menuSlots
Type elementType = Type.GetType("StardewValley.Menus.LoadGameMenu+MenuSlot, Stardew Valley");
Type listType = typeof(List <>).MakeGenericType(new Type[] { elementType });
object list = Activator.CreateInstance(listType);
/*
* // add an instance to new list
* Type SaveFileSlotType = Type.GetType("StardewValley.Menus.LoadGameMenu+SaveFileSlot, Stardew Valley");
* object e = Activator.CreateInstance(SaveFileSlotType, loadMenu, Farmers[1]);
* list.GetType().GetMethod("Add").Invoke(list, new[] { e });
*/
// inject modified farmers
m_env.Helper.Reflection.GetField <object>(loadMenu, "menuSlots").SetValue(list);
m_env.Helper.Reflection.GetMethod(loadMenu, "addSaveFiles").Invoke(m_farmers);
// override textures. Since the texture will be override after addSaveFiles, do it in next UpdateTick
m_events.GameLoop.UpdateTicked += Event_PatchLoadMenuFarmer;
}
public override void Click(MouseEventArgs e, GUIContainer container)
{
FMODUtil.RaiseEvent(SoundsTable.UIClick);
LoadGameMenu.Initialize();
MainMenu.MainMenuID.PopupChild(LoadGameMenu.Menu);
}
//--------------------------------------------------------------------------------------------
public void Start()
{
//set mLoadMenuEventHandler and mDeleteMenuEventHandler
mLoadMenuEventHandler = transform.parent.parent.GetComponentInParent<LoadGameMenu>();
mDeleteMenuEventHandler = transform.parent.parent.GetComponentInParent<DeleteGameMenu>();
}
internal static void Initialize()
{
loadGameMenu = MainMenu.mainMenu.transform.parent.Find("LoadGameMenu").GetComponent <LoadGameMenu>();
content = loadGameMenu.transform.Find("Scroll View").Find("Viewport").Find("Content");
}
private void LoadGameButton_ClickEvent(object sender, Reusable.Event.ClickEventArgs e)
{
FMODUtil.RaiseEvent(SoundsTable.UIClick);
LoadGameMenu.Initialize();
MainMenu.MainMenuID.PopupChild(LoadGameMenu.Menu);
}
void OnClick()
{
LoadGameMenu.Deactivate();
}
/*********
** Private methods
*********/
/// <summary>Get the protected load game menu field which indicates whether it's currently counting down before loading a save.</summary>
/// <param name="menu">The load game menu.</param>
private IReflectedField <int> GetTimerToLoad(LoadGameMenu menu)
{
return(this.Reflection.GetField <int>(menu, "timerToLoad"));
}
