From 27dece2cf445147c5e2848f9ec26f38a101f50fc Mon Sep 17 00:00:00 2001 From: Gormogon Date: Sun, 29 May 2016 18:23:01 -0400 Subject: Attempt to migrate to new directory structure. --- src/StardewModdingAPI/App.config | 10 + src/StardewModdingAPI/Command.cs | 109 ++ src/StardewModdingAPI/Config.cs | 176 ++ src/StardewModdingAPI/Constants.cs | 67 + src/StardewModdingAPI/Entities/SCharacter.cs | 6 + src/StardewModdingAPI/Entities/SFarm.cs | 6 + src/StardewModdingAPI/Entities/SFarmAnimal.cs | 6 + src/StardewModdingAPI/Entities/SNpc.cs | 6 + src/StardewModdingAPI/Entities/SPlayer.cs | 33 + src/StardewModdingAPI/Events/Controls.cs | 58 + src/StardewModdingAPI/Events/EventArgs.cs | 272 +++ src/StardewModdingAPI/Events/Game.cs | 123 ++ src/StardewModdingAPI/Events/Graphics.cs | 162 ++ src/StardewModdingAPI/Events/Location.cs | 30 + src/StardewModdingAPI/Events/Menu.cs | 21 + src/StardewModdingAPI/Events/Mine.cs | 14 + src/StardewModdingAPI/Events/Player.cs | 35 + src/StardewModdingAPI/Events/Time.cs | 42 + src/StardewModdingAPI/Extensions.cs | 135 ++ src/StardewModdingAPI/FodyWeavers.xml | 5 + .../Inheritance/ItemStackChange.cs | 18 + .../Inheritance/Menus/SBobberBar.cs | 288 ++++ .../Inheritance/Menus/SGameMenu.cs | 48 + .../Inheritance/Menus/SInventoryPage.cs | 19 + .../Inheritance/Minigames/SMinigameBase.cs | 34 + src/StardewModdingAPI/Inheritance/SBareObject.cs | 20 + src/StardewModdingAPI/Inheritance/SGame.cs | 1726 ++++++++++++++++++++ src/StardewModdingAPI/Inheritance/SObject.cs | 277 ++++ src/StardewModdingAPI/JsonResolver.cs | 212 +++ src/StardewModdingAPI/Logger.cs | 326 ++++ src/StardewModdingAPI/Manifest.cs | 89 + src/StardewModdingAPI/Mod.cs | 51 + src/StardewModdingAPI/ModItem.cs | 15 + src/StardewModdingAPI/Program.cs | 451 +++++ src/StardewModdingAPI/Properties/AssemblyInfo.cs | 39 + src/StardewModdingAPI/StardewModdingAPI.csproj | 216 +++ src/StardewModdingAPI/Version.cs | 23 + src/StardewModdingAPI/icon.ico | Bin 0 -> 4286 bytes src/StardewModdingAPI/packages.config | 7 + src/StardewModdingAPI/steam_appid.txt | 1 + 40 files changed, 5176 insertions(+) create mode 100644 src/StardewModdingAPI/App.config create mode 100644 src/StardewModdingAPI/Command.cs create mode 100644 src/StardewModdingAPI/Config.cs create mode 100644 src/StardewModdingAPI/Constants.cs create mode 100644 src/StardewModdingAPI/Entities/SCharacter.cs create mode 100644 src/StardewModdingAPI/Entities/SFarm.cs create mode 100644 src/StardewModdingAPI/Entities/SFarmAnimal.cs create mode 100644 src/StardewModdingAPI/Entities/SNpc.cs create mode 100644 src/StardewModdingAPI/Entities/SPlayer.cs create mode 100644 src/StardewModdingAPI/Events/Controls.cs create mode 100644 src/StardewModdingAPI/Events/EventArgs.cs create mode 100644 src/StardewModdingAPI/Events/Game.cs create mode 100644 src/StardewModdingAPI/Events/Graphics.cs create mode 100644 src/StardewModdingAPI/Events/Location.cs create mode 100644 src/StardewModdingAPI/Events/Menu.cs create mode 100644 src/StardewModdingAPI/Events/Mine.cs create mode 100644 src/StardewModdingAPI/Events/Player.cs create mode 100644 src/StardewModdingAPI/Events/Time.cs create mode 100644 src/StardewModdingAPI/Extensions.cs create mode 100644 src/StardewModdingAPI/FodyWeavers.xml create mode 100644 src/StardewModdingAPI/Inheritance/ItemStackChange.cs create mode 100644 src/StardewModdingAPI/Inheritance/Menus/SBobberBar.cs create mode 100644 src/StardewModdingAPI/Inheritance/Menus/SGameMenu.cs create mode 100644 src/StardewModdingAPI/Inheritance/Menus/SInventoryPage.cs create mode 100644 src/StardewModdingAPI/Inheritance/Minigames/SMinigameBase.cs create mode 100644 src/StardewModdingAPI/Inheritance/SBareObject.cs create mode 100644 src/StardewModdingAPI/Inheritance/SGame.cs create mode 100644 src/StardewModdingAPI/Inheritance/SObject.cs create mode 100644 src/StardewModdingAPI/JsonResolver.cs create mode 100644 src/StardewModdingAPI/Logger.cs create mode 100644 src/StardewModdingAPI/Manifest.cs create mode 100644 src/StardewModdingAPI/Mod.cs create mode 100644 src/StardewModdingAPI/ModItem.cs create mode 100644 src/StardewModdingAPI/Program.cs create mode 100644 src/StardewModdingAPI/Properties/AssemblyInfo.cs create mode 100644 src/StardewModdingAPI/StardewModdingAPI.csproj create mode 100644 src/StardewModdingAPI/Version.cs create mode 100644 src/StardewModdingAPI/icon.ico create mode 100644 src/StardewModdingAPI/packages.config create mode 100644 src/StardewModdingAPI/steam_appid.txt (limited to 'src/StardewModdingAPI') diff --git a/src/StardewModdingAPI/App.config b/src/StardewModdingAPI/App.config new file mode 100644 index 00000000..6664f1ed --- /dev/null +++ b/src/StardewModdingAPI/App.config @@ -0,0 +1,10 @@ + + + + + + + + + + \ No newline at end of file diff --git a/src/StardewModdingAPI/Command.cs b/src/StardewModdingAPI/Command.cs new file mode 100644 index 00000000..4214b1a7 --- /dev/null +++ b/src/StardewModdingAPI/Command.cs @@ -0,0 +1,109 @@ +using System; +using System.Collections.Generic; +using StardewModdingAPI.Events; + +namespace StardewModdingAPI +{ + public class Command + { + internal static List RegisteredCommands = new List(); + public string[] CalledArgs; + public string[] CommandArgs; + public string CommandDesc; + + public string CommandName; + + /// + /// Creates a Command from a Name, Description, and Arguments + /// + /// Name + /// Description + /// Arguments + public Command(string cname, string cdesc, string[] args = null) + { + CommandName = cname; + CommandDesc = cdesc; + if (args == null) + args = new string[0]; + CommandArgs = args; + } + + public event EventHandler CommandFired; + + /// + /// Calls the specified command. (It runs the command) + /// + /// The command to run + public static void CallCommand(string input) + { + input = input.TrimEnd(' '); + var args = new string[0]; + Command fnd; + if (input.Contains(" ")) + { + args = input.Split(new[] {" "}, 2, StringSplitOptions.RemoveEmptyEntries); + fnd = FindCommand(args[0]); + args = args[1].Split(new[] {" "}, StringSplitOptions.RemoveEmptyEntries); + } + else + { + fnd = FindCommand(input); + } + + if (fnd != null) + { + fnd.CalledArgs = args; + fnd.Fire(); + } + else + { + Log.AsyncR("Unknown Command"); + } + } + + /// + /// Registers a command to the list of commands properly + /// + /// Name of the command to register + /// Description + /// Arguments (these are purely for viewing so that a user can see what an argument needs to be) + /// + public static Command RegisterCommand(string command, string cdesc, string[] args = null) + { + var c = new Command(command, cdesc, args); + if (RegisteredCommands.Contains(c)) + { + Log.AsyncR($"Command already registered! [{c.CommandName}]"); + return RegisteredCommands.Find(x => x.Equals(c)); + } + + RegisteredCommands.Add(c); + Log.Async("Registered command: " + command); + + return c; + } + + /// + /// Looks up a command in the list of registered commands. Returns null if it doesn't exist (I think) + /// + /// Name of command to find + /// + public static Command FindCommand(string name) + { + return RegisteredCommands.Find(x => x.CommandName.Equals(name)); + } + + /// + /// Runs a command. Fires it. Calls it. Any of those. + /// + public void Fire() + { + if (CommandFired == null) + { + Log.AsyncR("Command failed to fire because it's fire event is null: " + CommandName); + return; + } + CommandFired.Invoke(this, new EventArgsCommand(this)); + } + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/Config.cs b/src/StardewModdingAPI/Config.cs new file mode 100644 index 00000000..c5b7beca --- /dev/null +++ b/src/StardewModdingAPI/Config.cs @@ -0,0 +1,176 @@ +/* + Copyright 2016 Zoey (Zoryn) +*/ + +using System; +using System.IO; +using System.Linq; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; + +namespace StardewModdingAPI +{ + public class Config + { + [JsonIgnore] + public virtual string ConfigLocation { get; protected internal set; } + + [JsonIgnore] + public virtual string ConfigDir => Path.GetDirectoryName(ConfigLocation); + + public virtual Config Instance() where T : Config => Activator.CreateInstance(); + + /// + /// Loads the config from the json blob on disk, updating and re-writing to the disk if needed. + /// + /// + /// + public virtual T LoadConfig() where T : Config + { + if (string.IsNullOrEmpty(ConfigLocation)) + { + Log.AsyncR("A config tried to load without specifying a location on the disk."); + return null; + } + + T ret = null; + + if (!File.Exists(ConfigLocation)) + { + //no config exists, generate default values + var c = GenerateDefaultConfig(); + c.ConfigLocation = ConfigLocation; + ret = c; + } + else + { + try + { + //try to load the config from a json blob on disk + var c = JsonConvert.DeserializeObject(File.ReadAllText(ConfigLocation), new JsonSerializerSettings {ContractResolver = new JsonResolver()}); + + c.ConfigLocation = ConfigLocation; + + //update the config with default values if needed + ret = c.UpdateConfig(); + + c = null; + } + catch (Exception ex) + { + Log.AsyncR($"Invalid JSON ({GetType().Name}): {ConfigLocation} \n{ex}"); + return GenerateDefaultConfig(); + } + } + + ret.WriteConfig(); + return ret; + } + + /// + /// MUST be implemented in inheriting class! + /// + public virtual T GenerateDefaultConfig() where T : Config + { + return null; + } + + /// + /// Merges a default-value config with the user-config on disk. + /// + /// + /// + public virtual T UpdateConfig() where T : Config + { + try + { + //default config + var b = JObject.FromObject(Instance().GenerateDefaultConfig(), new JsonSerializer {ContractResolver = new JsonResolver()}); + + //user config + var u = JObject.FromObject(this, new JsonSerializer {ContractResolver = new JsonResolver()}); + + //overwrite default values with user values + b.Merge(u, new JsonMergeSettings {MergeArrayHandling = MergeArrayHandling.Replace}); + + //cast json object to config + var c = b.ToObject(); + + //re-write the location on disk to the object + c.ConfigLocation = ConfigLocation; + + return c; + } + catch (Exception ex) + { + Log.AsyncR("An error occured when updating a config: " + ex); + return this as T; + } + } + } + + public static class ConfigExtensions + { + /// + /// Initializes an instance of any class that inherits from Config. + /// This method performs the loading, saving, and merging of the config on the disk and in memory at a default state. + /// This method should not be used to re-load or to re-save a config. + /// NOTE: You MUST set your config EQUAL to the return of this method! + /// + /// + /// + /// + /// + public static T InitializeConfig(this T baseConfig, string configLocation) where T : Config + { + if (baseConfig == null) + { + baseConfig = Activator.CreateInstance(); + /* + Log.AsyncR("A config tried to initialize whilst being null."); + return null; + */ + } + + if (string.IsNullOrEmpty(configLocation)) + { + Log.AsyncR("A config tried to initialize without specifying a location on the disk."); + return null; + } + + baseConfig.ConfigLocation = configLocation; + var c = baseConfig.LoadConfig(); + + return c; + } + + /// + /// Writes a config to a json blob on the disk specified in the config's properties. + /// + public static void WriteConfig(this T baseConfig) where T : Config + { + if (string.IsNullOrEmpty(baseConfig?.ConfigLocation) || string.IsNullOrEmpty(baseConfig.ConfigDir)) + { + Log.AsyncR("A config attempted to save when it itself or it's location were null."); + return; + } + + var s = JsonConvert.SerializeObject(baseConfig, typeof(T), Formatting.Indented, new JsonSerializerSettings {ContractResolver = new JsonResolver()}); + + if (!Directory.Exists(baseConfig.ConfigDir)) + Directory.CreateDirectory(baseConfig.ConfigDir); + + if (!File.Exists(baseConfig.ConfigLocation) || !File.ReadAllText(baseConfig.ConfigLocation).SequenceEqual(s)) + File.WriteAllText(baseConfig.ConfigLocation, s); + } + + /// + /// Re-reads the json blob on the disk and merges its values with a default config. + /// NOTE: You MUST set your config EQUAL to the return of this method! + /// + public static T ReloadConfig(this T baseConfig) where T : Config + { + return baseConfig.LoadConfig(); + } + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/Constants.cs b/src/StardewModdingAPI/Constants.cs new file mode 100644 index 00000000..0dd387b3 --- /dev/null +++ b/src/StardewModdingAPI/Constants.cs @@ -0,0 +1,67 @@ +using System; +using System.IO; +using System.Reflection; +using StardewValley; + +namespace StardewModdingAPI +{ + /// + /// Static class containing readonly values. + /// + public static class Constants + { + public static readonly Version Version = new Version(0, 40, 0, "Alpha"); + + /// + /// Not quite "constant", but it makes more sense for it to be here, at least for now + /// + public static int ModsLoaded = 0; + + /// + /// Stardew Valley's roaming app data location. + /// %AppData%//StardewValley + /// + public static string DataPath => Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "StardewValley"); + + public static string SavesPath => Path.Combine(DataPath, "Saves"); + + private static string saveFolderName => PlayerNull ? string.Empty : Game1.player.name.RemoveNumerics() + "_" + Game1.uniqueIDForThisGame; + public static string SaveFolderName => CurrentSavePathExists ? saveFolderName : ""; + + private static string currentSavePath => PlayerNull ? string.Empty : Path.Combine(SavesPath, saveFolderName); + public static string CurrentSavePath => CurrentSavePathExists ? currentSavePath : ""; + + public static bool CurrentSavePathExists => Directory.Exists(currentSavePath); + + public static bool PlayerNull => !Game1.hasLoadedGame || Game1.player == null || string.IsNullOrEmpty(Game1.player.name); + + /// + /// Execution path to execute the code. + /// + public static string ExecutionPath => Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); + + /// + /// Title for the API console + /// + public static string ConsoleTitle => $"Stardew Modding API Console - Version {Version.VersionString} - Mods Loaded: {ModsLoaded}"; + + /// + /// Path for log files to be output to. + /// %LocalAppData%//StardewValley//ErrorLogs + /// + public static string LogDir => Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "StardewValley", "ErrorLogs"); + + public static string LogPath => Path.Combine(LogDir, "MODDED_ProgramLog.Log_LATEST.txt"); + + /// + /// Whether or not to enable the Render Target drawing code offered by ClxS + /// Do not mark as 'const' or else 'if' checks will complain that the expression is always true in ReSharper + /// + public static bool EnableDrawingIntoRenderTarget => true; + + /// + /// Completely overrides the base game's draw call to the one is SGame + /// + public static bool EnableCompletelyOverridingBaseCalls => true; + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/Entities/SCharacter.cs b/src/StardewModdingAPI/Entities/SCharacter.cs new file mode 100644 index 00000000..2d941d55 --- /dev/null +++ b/src/StardewModdingAPI/Entities/SCharacter.cs @@ -0,0 +1,6 @@ +namespace StardewModdingAPI.Entities +{ + internal class SCharacter + { + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/Entities/SFarm.cs b/src/StardewModdingAPI/Entities/SFarm.cs new file mode 100644 index 00000000..c6c64681 --- /dev/null +++ b/src/StardewModdingAPI/Entities/SFarm.cs @@ -0,0 +1,6 @@ +namespace StardewModdingAPI.Entities +{ + internal class SFarm + { + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/Entities/SFarmAnimal.cs b/src/StardewModdingAPI/Entities/SFarmAnimal.cs new file mode 100644 index 00000000..fb8ee267 --- /dev/null +++ b/src/StardewModdingAPI/Entities/SFarmAnimal.cs @@ -0,0 +1,6 @@ +namespace StardewModdingAPI.Entities +{ + internal class SFarmAnimal + { + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/Entities/SNpc.cs b/src/StardewModdingAPI/Entities/SNpc.cs new file mode 100644 index 00000000..727dcff7 --- /dev/null +++ b/src/StardewModdingAPI/Entities/SNpc.cs @@ -0,0 +1,6 @@ +namespace StardewModdingAPI.Entities +{ + internal class SNpc + { + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/Entities/SPlayer.cs b/src/StardewModdingAPI/Entities/SPlayer.cs new file mode 100644 index 00000000..d464cded --- /dev/null +++ b/src/StardewModdingAPI/Entities/SPlayer.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections.Generic; +using StardewValley; + +namespace StardewModdingAPI.Entities +{ + /// + /// Static class for intergrating with the player + /// + public class SPlayer + { + /// + /// Calls 'getAllFarmers' in Game1 + /// + public static List AllFarmers => Game1.getAllFarmers(); + + /// + /// Do not use. + /// + [Obsolete("Use 'Player' instead.")] + public static Farmer CurrentFarmer => Game1.player; + + /// + /// Gets the current player from Game1 + /// + public static Farmer Player => Game1.player; + + /// + /// Gets the player's current location from Game1 + /// + public static GameLocation CurrentFarmerLocation => Player.currentLocation; + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/Events/Controls.cs b/src/StardewModdingAPI/Events/Controls.cs new file mode 100644 index 00000000..6415561a --- /dev/null +++ b/src/StardewModdingAPI/Events/Controls.cs @@ -0,0 +1,58 @@ +using System; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Input; + +namespace StardewModdingAPI.Events +{ + public static class ControlEvents + { + public static event EventHandler KeyboardChanged = delegate { }; + public static event EventHandler KeyPressed = delegate { }; + public static event EventHandler KeyReleased = delegate { }; + public static event EventHandler MouseChanged = delegate { }; + public static event EventHandler ControllerButtonPressed = delegate { }; + public static event EventHandler ControllerButtonReleased = delegate { }; + public static event EventHandler ControllerTriggerPressed = delegate { }; + public static event EventHandler ControllerTriggerReleased = delegate { }; + + internal static void InvokeKeyboardChanged(KeyboardState priorState, KeyboardState newState) + { + KeyboardChanged.Invoke(null, new EventArgsKeyboardStateChanged(priorState, newState)); + } + + internal static void InvokeMouseChanged(MouseState priorState, MouseState newState) + { + MouseChanged.Invoke(null, new EventArgsMouseStateChanged(priorState, newState)); + } + + internal static void InvokeKeyPressed(Keys key) + { + KeyPressed.Invoke(null, new EventArgsKeyPressed(key)); + } + + internal static void InvokeKeyReleased(Keys key) + { + KeyReleased.Invoke(null, new EventArgsKeyPressed(key)); + } + + internal static void InvokeButtonPressed(PlayerIndex playerIndex, Buttons buttons) + { + ControllerButtonPressed.Invoke(null, new EventArgsControllerButtonPressed(playerIndex, buttons)); + } + + internal static void InvokeButtonReleased(PlayerIndex playerIndex, Buttons buttons) + { + ControllerButtonReleased.Invoke(null, new EventArgsControllerButtonReleased(playerIndex, buttons)); + } + + internal static void InvokeTriggerPressed(PlayerIndex playerIndex, Buttons buttons, float value) + { + ControllerTriggerPressed.Invoke(null, new EventArgsControllerTriggerPressed(playerIndex, buttons, value)); + } + + internal static void InvokeTriggerReleased(PlayerIndex playerIndex, Buttons buttons, float value) + { + ControllerTriggerReleased.Invoke(null, new EventArgsControllerTriggerReleased(playerIndex, buttons, value)); + } + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/Events/EventArgs.cs b/src/StardewModdingAPI/Events/EventArgs.cs new file mode 100644 index 00000000..2bce964e --- /dev/null +++ b/src/StardewModdingAPI/Events/EventArgs.cs @@ -0,0 +1,272 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Input; +using StardewModdingAPI.Inheritance; +using StardewValley; +using StardewValley.Menus; +using Object = StardewValley.Object; + +namespace StardewModdingAPI.Events +{ + public class EventArgsKeyboardStateChanged : EventArgs + { + public EventArgsKeyboardStateChanged(KeyboardState priorState, KeyboardState newState) + { + NewState = newState; + NewState = newState; + } + + public KeyboardState NewState { get; private set; } + public KeyboardState PriorState { get; private set; } + } + + public class EventArgsKeyPressed : EventArgs + { + public EventArgsKeyPressed(Keys keyPressed) + { + KeyPressed = keyPressed; + } + + public Keys KeyPressed { get; private set; } + } + + public class EventArgsControllerButtonPressed : EventArgs + { + public EventArgsControllerButtonPressed(PlayerIndex playerIndex, Buttons buttonPressed) + { + PlayerIndex = playerIndex; + ButtonPressed = buttonPressed; + } + + public PlayerIndex PlayerIndex { get; private set; } + public Buttons ButtonPressed { get; private set; } + } + + public class EventArgsControllerButtonReleased : EventArgs + { + public EventArgsControllerButtonReleased(PlayerIndex playerIndex, Buttons buttonReleased) + { + PlayerIndex = playerIndex; + ButtonReleased = buttonReleased; + } + + public PlayerIndex PlayerIndex { get; private set; } + public Buttons ButtonReleased { get; private set; } + } + + public class EventArgsControllerTriggerPressed : EventArgs + { + public EventArgsControllerTriggerPressed(PlayerIndex playerIndex, Buttons buttonPressed, float value) + { + PlayerIndex = playerIndex; + ButtonPressed = buttonPressed; + Value = value; + } + + public PlayerIndex PlayerIndex { get; private set; } + public Buttons ButtonPressed { get; private set; } + public float Value { get; private set; } + } + + public class EventArgsControllerTriggerReleased : EventArgs + { + public EventArgsControllerTriggerReleased(PlayerIndex playerIndex, Buttons buttonReleased, float value) + { + PlayerIndex = playerIndex; + ButtonReleased = buttonReleased; + Value = value; + } + + public PlayerIndex PlayerIndex { get; private set; } + public Buttons ButtonReleased { get; private set; } + public float Value { get; private set; } + } + + public class EventArgsMouseStateChanged : EventArgs + { + public EventArgsMouseStateChanged(MouseState priorState, MouseState newState) + { + NewState = newState; + NewState = newState; + } + + public MouseState NewState { get; private set; } + public MouseState PriorState { get; private set; } + } + + public class EventArgsClickableMenuChanged : EventArgs + { + public EventArgsClickableMenuChanged(IClickableMenu priorMenu, IClickableMenu newMenu) + { + NewMenu = newMenu; + PriorMenu = priorMenu; + } + + public IClickableMenu NewMenu { get; private set; } + public IClickableMenu PriorMenu { get; private set; } + } + + public class EventArgsClickableMenuClosed : EventArgs + { + public EventArgsClickableMenuClosed(IClickableMenu priorMenu) + { + PriorMenu = priorMenu; + } + + public IClickableMenu PriorMenu { get; private set; } + } + + public class EventArgsGameLocationsChanged : EventArgs + { + public EventArgsGameLocationsChanged(List newLocations) + { + NewLocations = newLocations; + } + + public List NewLocations { get; private set; } + } + + public class EventArgsMineLevelChanged : EventArgs + { + public EventArgsMineLevelChanged(int previousMineLevel, int currentMineLevel) + { + PreviousMineLevel = previousMineLevel; + CurrentMineLevel = currentMineLevel; + } + + public int PreviousMineLevel { get; private set; } + public int CurrentMineLevel { get; private set; } + } + + public class EventArgsLocationObjectsChanged : EventArgs + { + public EventArgsLocationObjectsChanged(SerializableDictionary newObjects) + { + NewObjects = newObjects; + } + + public SerializableDictionary NewObjects { get; private set; } + } + + public class EventArgsCurrentLocationChanged : EventArgs + { + public EventArgsCurrentLocationChanged(GameLocation priorLocation, GameLocation newLocation) + { + NewLocation = newLocation; + PriorLocation = priorLocation; + } + + public GameLocation NewLocation { get; private set; } + public GameLocation PriorLocation { get; private set; } + } + + public class EventArgsFarmerChanged : EventArgs + { + public EventArgsFarmerChanged(Farmer priorFarmer, Farmer newFarmer) + { + NewFarmer = NewFarmer; + PriorFarmer = PriorFarmer; + } + + public Farmer NewFarmer { get; } + public Farmer PriorFarmer { get; } + } + + public class EventArgsInventoryChanged : EventArgs + { + public EventArgsInventoryChanged(List inventory, List changedItems) + { + Inventory = inventory; + Added = changedItems.Where(n => n.ChangeType == ChangeType.Added).ToList(); + Removed = changedItems.Where(n => n.ChangeType == ChangeType.Removed).ToList(); + QuantityChanged = changedItems.Where(n => n.ChangeType == ChangeType.StackChange).ToList(); + } + + public List Inventory { get; private set; } + public List Added { get; private set; } + public List Removed { get; private set; } + public List QuantityChanged { get; private set; } + } + + public class EventArgsLevelUp : EventArgs + { + public enum LevelType + { + Combat, + Farming, + Fishing, + Foraging, + Mining, + Luck + } + + public EventArgsLevelUp(LevelType type, int newLevel) + { + Type = type; + NewLevel = newLevel; + } + + public LevelType Type { get; private set; } + public int NewLevel { get; private set; } + } + + public class EventArgsIntChanged : EventArgs + { + public EventArgsIntChanged(int priorInt, int newInt) + { + NewInt = NewInt; + PriorInt = PriorInt; + } + + public int NewInt { get; } + public int PriorInt { get; } + } + + public class EventArgsStringChanged : EventArgs + { + public EventArgsStringChanged(string priorString, string newString) + { + NewString = newString; + PriorString = priorString; + } + + public string NewString { get; private set; } + public string PriorString { get; private set; } + } + + public class EventArgsLoadedGameChanged : EventArgs + { + public EventArgsLoadedGameChanged(bool loadedGame) + { + LoadedGame = loadedGame; + } + + public bool LoadedGame { get; private set; } + } + + public class EventArgsNewDay : EventArgs + { + public EventArgsNewDay(int prevDay, int curDay, bool newDay) + { + PreviousDay = prevDay; + CurrentDay = curDay; + IsNewDay = newDay; + } + + public int PreviousDay { get; private set; } + public int CurrentDay { get; private set; } + public bool IsNewDay { get; private set; } + } + + public class EventArgsCommand : EventArgs + { + public EventArgsCommand(Command command) + { + Command = command; + } + + public Command Command { get; private set; } + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/Events/Game.cs b/src/StardewModdingAPI/Events/Game.cs new file mode 100644 index 00000000..8b8042ed --- /dev/null +++ b/src/StardewModdingAPI/Events/Game.cs @@ -0,0 +1,123 @@ +using System; + +namespace StardewModdingAPI.Events +{ + public static class GameEvents + { + public static event EventHandler GameLoaded = delegate { }; + public static event EventHandler Initialize = delegate { }; + public static event EventHandler LoadContent = delegate { }; + public static event EventHandler FirstUpdateTick = delegate { }; + + /// + /// Fires every update (1/60 of a second) + /// + public static event EventHandler UpdateTick = delegate { }; + + /// + /// Fires every other update (1/30 of a second) + /// + public static event EventHandler SecondUpdateTick = delegate { }; + + /// + /// Fires every fourth update (1/15 of a second) + /// + public static event EventHandler FourthUpdateTick = delegate { }; + + /// + /// Fires every eighth update (roughly 1/8 of a second) + /// + public static event EventHandler EighthUpdateTick = delegate { }; + + /// + /// Fires every fifthteenth update (1/4 of a second) + /// + public static event EventHandler QuarterSecondTick = delegate { }; + + /// + /// Fires every thirtieth update (1/2 of a second) + /// + public static event EventHandler HalfSecondTick = delegate { }; + + /// + /// Fires every sixtieth update (a second) + /// + public static event EventHandler OneSecondTick = delegate { }; + + internal static void InvokeGameLoaded() + { + GameLoaded.Invoke(null, EventArgs.Empty); + } + + internal static void InvokeInitialize() + { + try + { + Initialize.Invoke(null, EventArgs.Empty); + } + catch (Exception ex) + { + Log.AsyncR("An exception occured in XNA Initialize: " + ex); + } + } + + internal static void InvokeLoadContent() + { + try + { + LoadContent.Invoke(null, EventArgs.Empty); + } + catch (Exception ex) + { + Log.AsyncR("An exception occured in XNA LoadContent: " + ex); + } + } + + internal static void InvokeUpdateTick() + { + try + { + UpdateTick.Invoke(null, EventArgs.Empty); + } + catch (Exception ex) + { + Log.AsyncR("An exception occured in XNA UpdateTick: " + ex); + } + } + + internal static void InvokeSecondUpdateTick() + { + SecondUpdateTick.Invoke(null, EventArgs.Empty); + } + + internal static void InvokeFourthUpdateTick() + { + FourthUpdateTick.Invoke(null, EventArgs.Empty); + } + + internal static void InvokeEighthUpdateTick() + { + EighthUpdateTick.Invoke(null, EventArgs.Empty); + } + + internal static void InvokeQuarterSecondTick() + { + QuarterSecondTick.Invoke(null, EventArgs.Empty); + } + + internal static void InvokeHalfSecondTick() + { + HalfSecondTick.Invoke(null, EventArgs.Empty); + } + + internal static void InvokeOneSecondTick() + { + OneSecondTick.Invoke(null, EventArgs.Empty); + } + + internal static void InvokeFirstUpdateTick() + { + FirstUpdateTick.Invoke(null, EventArgs.Empty); + } + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/Events/Graphics.cs b/src/StardewModdingAPI/Events/Graphics.cs new file mode 100644 index 00000000..331d3e3a --- /dev/null +++ b/src/StardewModdingAPI/Events/Graphics.cs @@ -0,0 +1,162 @@ +using System; + +namespace StardewModdingAPI.Events +{ + /// + /// + /// + public static class GraphicsEvents + { + /// + /// Occurs when the form (game) is resized. + /// + public static event EventHandler Resize = delegate { }; + + /// + /// Occurs before anything is drawn. + /// + public static event EventHandler OnPreRenderEvent = delegate { }; + + /// + /// Occurs before the GUI is drawn. + /// + public static event EventHandler OnPreRenderGuiEvent = delegate { }; + + /// + /// Occurs after the GUI is drawn. + /// + public static event EventHandler OnPostRenderGuiEvent = delegate { }; + + /// + /// Occurs before the HUD is drawn. + /// + public static event EventHandler OnPreRenderHudEvent = delegate { }; + + /// + /// Occurs after the HUD is drawn. + /// + public static event EventHandler OnPostRenderHudEvent = delegate { }; + + /// + /// Occurs after everything is drawn. + /// + public static event EventHandler OnPostRenderEvent = delegate { }; + + /// + /// Occurs before the GUI is drawn. Does not check for conditional statements. + /// + public static event EventHandler OnPreRenderGuiEventNoCheck = delegate { }; + + /// + /// Occurs after the GUI is drawn. Does not check for conditional statements. + /// + public static event EventHandler OnPostRenderGuiEventNoCheck = delegate { }; + + /// + /// Occurs before the HUD is drawn. Does not check for conditional statements. + /// + public static event EventHandler OnPreRenderHudEventNoCheck = delegate { }; + + /// + /// Occurs after the HUD is drawn. Does not check for conditional statements. + /// + public static event EventHandler OnPostRenderHudEventNoCheck = delegate { }; + + /// + /// Draws when SGame.Debug is true. F3 toggles this. + /// Game1.spriteBatch.Begin() is pre-called. + /// Do not make end or begin calls to the spritebatch. + /// If you are only trying to add debug information, use SGame.DebugMessageQueue in your Update loop. + /// + public static event EventHandler DrawDebug = delegate { }; + + internal static void InvokeDrawDebug(object sender, EventArgs e) + { + DrawDebug.Invoke(sender, e); + } + + internal static void InvokeOnPreRenderEvent(object sender, EventArgs e) + { + OnPreRenderEvent.Invoke(sender, e); + } + + internal static void InvokeOnPreRenderGuiEvent(object sender, EventArgs e) + { + OnPreRenderGuiEvent.Invoke(sender, e); + } + + internal static void InvokeOnPostRenderGuiEvent(object sender, EventArgs e) + { + OnPostRenderGuiEvent.Invoke(sender, e); + } + + internal static void InvokeOnPreRenderHudEvent(object sender, EventArgs e) + { + OnPreRenderHudEvent.Invoke(sender, e); + } + + internal static void InvokeOnPostRenderHudEvent(object sender, EventArgs e) + { + OnPostRenderHudEvent.Invoke(sender, e); + } + + internal static void InvokeOnPostRenderEvent(object sender, EventArgs e) + { + OnPostRenderEvent.Invoke(sender, e); + } + + internal static void InvokeOnPreRenderGuiEventNoCheck(object sender, EventArgs e) + { + OnPreRenderGuiEventNoCheck.Invoke(sender, e); + } + + internal static void InvokeOnPostRenderGuiEventNoCheck(object sender, EventArgs e) + { + OnPostRenderGuiEventNoCheck.Invoke(sender, e); + } + + internal static void InvokeOnPreRenderHudEventNoCheck(object sender, EventArgs e) + { + OnPreRenderHudEventNoCheck.Invoke(sender, e); + } + + internal static void InvokeOnPostRenderHudEventNoCheck(object sender, EventArgs e) + { + OnPostRenderHudEventNoCheck.Invoke(sender, e); + } + + internal static void InvokeResize(object sender, EventArgs e) + { + Resize.Invoke(sender, e); + } + + #region To Remove + + [Obsolete("Use the other Pre/Post render events instead.")] + public static event EventHandler DrawTick = delegate { }; + + [Obsolete("Use the other Pre/Post render events instead. All of them will automatically be drawn into the render target if needed.")] + public static event EventHandler DrawInRenderTargetTick = delegate { }; + + [Obsolete("Should not be used.")] + public static void InvokeDrawTick() + { + try + { + DrawTick.Invoke(null, EventArgs.Empty); + } + catch (Exception ex) + { + Log.AsyncR("An exception occured in a Mod's DrawTick: " + ex); + } + } + + [Obsolete("Should not be used.")] + public static void InvokeDrawInRenderTargetTick() + { + DrawInRenderTargetTick.Invoke(null, EventArgs.Empty); + } + + #endregion + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/Events/Location.cs b/src/StardewModdingAPI/Events/Location.cs new file mode 100644 index 00000000..f951ab95 --- /dev/null +++ b/src/StardewModdingAPI/Events/Location.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; +using Microsoft.Xna.Framework; +using StardewValley; +using Object = StardewValley.Object; + +namespace StardewModdingAPI.Events +{ + public static class LocationEvents + { + public static event EventHandler LocationsChanged = delegate { }; + public static event EventHandler LocationObjectsChanged = delegate { }; + public static event EventHandler CurrentLocationChanged = delegate { }; + + internal static void InvokeLocationsChanged(List newLocations) + { + LocationsChanged.Invoke(null, new EventArgsGameLocationsChanged(newLocations)); + } + + internal static void InvokeCurrentLocationChanged(GameLocation priorLocation, GameLocation newLocation) + { + CurrentLocationChanged.Invoke(null, new EventArgsCurrentLocationChanged(priorLocation, newLocation)); + } + + internal static void InvokeOnNewLocationObject(SerializableDictionary newObjects) + { + LocationObjectsChanged.Invoke(null, new EventArgsLocationObjectsChanged(newObjects)); + } + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/Events/Menu.cs b/src/StardewModdingAPI/Events/Menu.cs new file mode 100644 index 00000000..0e043780 --- /dev/null +++ b/src/StardewModdingAPI/Events/Menu.cs @@ -0,0 +1,21 @@ +using System; +using StardewValley.Menus; + +namespace StardewModdingAPI.Events +{ + public static class MenuEvents + { + public static event EventHandler MenuChanged = delegate { }; + public static event EventHandler MenuClosed = delegate { }; + + internal static void InvokeMenuChanged(IClickableMenu priorMenu, IClickableMenu newMenu) + { + MenuChanged.Invoke(null, new EventArgsClickableMenuChanged(priorMenu, newMenu)); + } + + internal static void InvokeMenuClosed(IClickableMenu priorMenu) + { + MenuClosed.Invoke(null, new EventArgsClickableMenuClosed(priorMenu)); + } + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/Events/Mine.cs b/src/StardewModdingAPI/Events/Mine.cs new file mode 100644 index 00000000..55514d42 --- /dev/null +++ b/src/StardewModdingAPI/Events/Mine.cs @@ -0,0 +1,14 @@ +using System; + +namespace StardewModdingAPI.Events +{ + public static class MineEvents + { + public static event EventHandler MineLevelChanged = delegate { }; + + internal static void InvokeMineLevelChanged(int previousMinelevel, int currentMineLevel) + { + MineLevelChanged.Invoke(null, new EventArgsMineLevelChanged(previousMinelevel, currentMineLevel)); + } + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/Events/Player.cs b/src/StardewModdingAPI/Events/Player.cs new file mode 100644 index 00000000..22f572b7 --- /dev/null +++ b/src/StardewModdingAPI/Events/Player.cs @@ -0,0 +1,35 @@ +using System; +using System.Collections.Generic; +using StardewModdingAPI.Inheritance; +using StardewValley; + +namespace StardewModdingAPI.Events +{ + public static class PlayerEvents + { + public static event EventHandler FarmerChanged = delegate { }; + public static event EventHandler InventoryChanged = delegate { }; + public static event EventHandler LeveledUp = delegate { }; + public static event EventHandler LoadedGame = delegate { }; + + internal static void InvokeFarmerChanged(Farmer priorFarmer, Farmer newFarmer) + { + FarmerChanged.Invoke(null, new EventArgsFarmerChanged(priorFarmer, newFarmer)); + } + + internal static void InvokeInventoryChanged(List inventory, List changedItems) + { + InventoryChanged.Invoke(null, new EventArgsInventoryChanged(inventory, changedItems)); + } + + internal static void InvokeLeveledUp(EventArgsLevelUp.LevelType type, int newLevel) + { + LeveledUp.Invoke(null, new EventArgsLevelUp(type, newLevel)); + } + + internal static void InvokeLoadedGame(EventArgsLoadedGameChanged loaded) + { + LoadedGame.Invoke(null, loaded); + } + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/Events/Time.cs b/src/StardewModdingAPI/Events/Time.cs new file mode 100644 index 00000000..39ca642a --- /dev/null +++ b/src/StardewModdingAPI/Events/Time.cs @@ -0,0 +1,42 @@ +using System; + +namespace StardewModdingAPI.Events +{ + public static class TimeEvents + { + public static event EventHandler TimeOfDayChanged = delegate { }; + public static event EventHandler DayOfMonthChanged = delegate { }; + public static event EventHandler YearOfGameChanged = delegate { }; + public static event EventHandler SeasonOfYearChanged = delegate { }; + + /// + /// Occurs when Game1.newDay changes. True directly before saving, and False directly after. + /// + public static event EventHandler OnNewDay = delegate { }; + + internal static void InvokeTimeOfDayChanged(int priorInt, int newInt) + { + TimeOfDayChanged.Invoke(null, new EventArgsIntChanged(priorInt, newInt)); + } + + internal static void InvokeDayOfMonthChanged(int priorInt, int newInt) + { + DayOfMonthChanged.Invoke(null, new EventArgsIntChanged(priorInt, newInt)); + } + + internal static void InvokeYearOfGameChanged(int priorInt, int newInt) + { + YearOfGameChanged.Invoke(null, new EventArgsIntChanged(priorInt, newInt)); + } + + internal static void InvokeSeasonOfYearChanged(string priorString, string newString) + { + SeasonOfYearChanged.Invoke(null, new EventArgsStringChanged(priorString, newString)); + } + + internal static void InvokeOnNewDay(int priorInt, int newInt, bool newDay) + { + OnNewDay.Invoke(null, new EventArgsNewDay(priorInt, newInt, newDay)); + } + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/Extensions.cs b/src/StardewModdingAPI/Extensions.cs new file mode 100644 index 00000000..abad6ce2 --- /dev/null +++ b/src/StardewModdingAPI/Extensions.cs @@ -0,0 +1,135 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Input; + +namespace StardewModdingAPI +{ + public static class Extensions + { + public static Random Random = new Random(); + + public static bool IsKeyDown(this Keys key) + { + return Keyboard.GetState().IsKeyDown(key); + } + + public static Color RandomColour() + { + return new Color(Random.Next(0, 255), Random.Next(0, 255), Random.Next(0, 255)); + } + + [Obsolete("The usage of ToSingular has changed. Please update your call to use ToSingular")] + public static string ToSingular(this IEnumerable ienum, string split = ", ") + { + Log.AsyncR("The usage of ToSingular has changed. Please update your call to use ToSingular"); + return ""; + } + + public static string ToSingular(this IEnumerable ienum, string split = ", ") // where T : class + { + //Apparently Keys[] won't split normally :l + if (typeof(T) == typeof(Keys)) + { + return string.Join(split, ienum.ToArray()); + } + return string.Join(split, ienum); + } + + /*public static string ToSingular(this IEnumerable ienum, string split = ", ") + { + return string.Join(split, ienum); + }*/ + + public static bool IsInt32(this object o) + { + int i; + return int.TryParse(o.ToString(), out i); + } + + public static int AsInt32(this object o) + { + return int.Parse(o.ToString()); + } + + public static bool IsBool(this object o) + { + bool b; + return bool.TryParse(o.ToString(), out b); + } + + public static bool AsBool(this object o) + { + return bool.Parse(o.ToString()); + } + + public static int GetHash(this IEnumerable enumerable) + { + var hash = 0; + foreach (var v in enumerable) + { + hash ^= v.GetHashCode(); + } + return hash; + } + + public static T Cast(this object o) where T : class + { + return o as T; + } + + public static FieldInfo[] GetPrivateFields(this object o) + { + return o.GetType().GetFields(BindingFlags.Instance | BindingFlags.NonPublic); + } + + public static FieldInfo GetBaseFieldInfo(this Type t, string name) + { + return t.GetField(name, BindingFlags.Instance | BindingFlags.NonPublic); + } + + public static T GetBaseFieldValue(this Type t, object o, string name) where T : class + { + return t.GetBaseFieldInfo(name).GetValue(o) as T; + } + + public static void SetBaseFieldValue(this Type t, object o, string name, object newValue) where T : class + { + t.GetBaseFieldInfo(name).SetValue(o, newValue as T); + } + + /* + public static T GetBaseFieldValue(this object o, string name) where T : class + { + return o.GetType().GetBaseFieldInfo(name).GetValue(o) as T; + }*/ + + /* + public static object GetBaseFieldValue(this object o, string name) + { + return o.GetType().GetBaseFieldInfo(name).GetValue(o); + } + + public static void SetBaseFieldValue (this object o, string name, object newValue) + { + o.GetType().GetBaseFieldInfo(name).SetValue(o, newValue); + } + */ + + public static string RemoveNumerics(this string st) + { + var s = st; + foreach (var c in s) + { + if (!char.IsLetterOrDigit(c)) + { + s = s.Replace(c.ToString(), ""); + } + } + return s; + } + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/FodyWeavers.xml b/src/StardewModdingAPI/FodyWeavers.xml new file mode 100644 index 00000000..2e6d4a7a --- /dev/null +++ b/src/StardewModdingAPI/FodyWeavers.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/src/StardewModdingAPI/Inheritance/ItemStackChange.cs b/src/StardewModdingAPI/Inheritance/ItemStackChange.cs new file mode 100644 index 00000000..88fc002e --- /dev/null +++ b/src/StardewModdingAPI/Inheritance/ItemStackChange.cs @@ -0,0 +1,18 @@ +using StardewValley; + +namespace StardewModdingAPI.Inheritance +{ + public enum ChangeType + { + Removed, + Added, + StackChange + } + + public class ItemStackChange + { + public Item Item { get; set; } + public int StackChange { get; set; } + public ChangeType ChangeType { get; set; } + } +} \ No newline at end of file diff --git a/src/StardewModdingAPI/Inheritance/Menus/SBobberBar.cs b/src/StardewModdingAPI/Inheritance/Menus/SBobberBar.cs new file mode 100644 index 00000000..1e424f73 --- /dev/null +++ b/src/StardewModdingAPI/Inheritance/Menus/SBobberBar.cs @@ -0,0 +1,288 @@ +using System.Reflection; +using Microsoft.Xna.Framework; +using StardewValley.BellsAndWhistles; +using StardewValley.Menus; + +namespace StardewModdingAPI.Inheritance.Menus +{ + public class SBobberBar : BobberBar + { + /// + /// DO NOT CONSTRUCT THIS CLASS + /// To retrieve an instance of SBobberBar, use SBobberBar.ConstructFromBaseClass() + /// + public SBobberBar(int whichFish, float fishSize, bool treasure, int bobber) : base(whichFish, fishSize, treasure, bobber) + { + } + + public BobberBar BaseBobberBar { get; private set; } + + /// + /// The green rectangle bar that moves up and down + /// + public float bobberPosition + { + get { return (float) GetBaseFieldInfo("bobberPosition").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("bobberPosition").SetValue(BaseBobberBar, value); } + } + + /// + /// The green bar on the right. How close to catching the fish you are + /// Range: 0 - 1 | 1 = catch, 0 = fail + /// + public float distanceFromCatching + { + get { return (float) GetBaseFieldInfo("distanceFromCatching").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("distanceFromCatching").SetValue(BaseBobberBar, value); } + } + + public float difficulty + { + get { return (float) GetBaseFieldInfo("difficulty").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("difficulty").SetValue(BaseBobberBar, value); } + } + + public int motionType + { + get { return (int) GetBaseFieldInfo("motionType").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("motionType").SetValue(BaseBobberBar, value); } + } + + public int whichFish + { + get { return (int) GetBaseFieldInfo("whichFish").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("whichFish").SetValue(BaseBobberBar, value); } + } + + public float bobberSpeed + { + get { return (float) GetBaseFieldInfo("bobberSpeed").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("bobberSpeed").SetValue(BaseBobberBar, value); } + } + + public float bobberAcceleration + { + get { return (float) GetBaseFieldInfo("bobberAcceleration").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("bobberAcceleration").SetValue(BaseBobberBar, value); } + } + + public float bobberTargetPosition + { + get { return (float) GetBaseFieldInfo("bobberTargetPosition").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("bobberTargetPosition").SetValue(BaseBobberBar, value); } + } + + public float scale + { + get { return (float) GetBaseFieldInfo("scale").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("scale").SetValue(BaseBobberBar, value); } + } + + public float everythingShakeTimer + { + get { return (float) GetBaseFieldInfo("everythingShakeTimer").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("everythingShakeTimer").SetValue(BaseBobberBar, value); } + } + + public float floaterSinkerAcceleration + { + get { return (float) GetBaseFieldInfo("floaterSinkerAcceleration").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("floaterSinkerAcceleration").SetValue(BaseBobberBar, value); } + } + + public float treasurePosition + { + get { return (float) GetBaseFieldInfo("treasurePosition").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("treasurePosition").SetValue(BaseBobberBar, value); } + } + + public float treasureCatchLevel + { + get { return (float) GetBaseFieldInfo("treasureCatchLevel").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("treasureCatchLevel").SetValue(BaseBobberBar, value); } + } + + public float treasureAppearTimer + { + get { return (float) GetBaseFieldInfo("treasureAppearTimer").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("treasureAppearTimer").SetValue(BaseBobberBar, value); } + } + + public float treasureScale + { + get { return (float) GetBaseFieldInfo("treasureScale").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("treasureScale").SetValue(BaseBobberBar, value); } + } + + public bool bobberInBar + { + get { return (bool) GetBaseFieldInfo("bobberInBar").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("bobberInBar").SetValue(BaseBobberBar, value); } + } + + public bool buttonPressed + { + get { return (bool) GetBaseFieldInfo("buttonPressed").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("buttonPressed").SetValue(BaseBobberBar, value); } + } + + public bool flipBubble + { + get { return (bool) GetBaseFieldInfo("flipBubble").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("flipBubble").SetValue(BaseBobberBar, value); } + } + + public bool fadeIn + { + get { return (bool) GetBaseFieldInfo("fadeIn").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("fadeIn").SetValue(BaseBobberBar, value); } + } + + public bool fadeOut + { + get { return (bool) GetBaseFieldInfo("fadeOut").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("bobberPfadeOutosition").SetValue(BaseBobberBar, value); } + } + + /// + /// Whether or not a treasure chest appears + /// + public bool treasure + { + get { return (bool) GetBaseFieldInfo("treasure").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("treasure").SetValue(BaseBobberBar, value); } + } + + public bool treasureCaught + { + get { return (bool) GetBaseFieldInfo("treasureCaught").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("treasureCaught").SetValue(BaseBobberBar, value); } + } + + public bool perfect + { + get { return (bool) GetBaseFieldInfo("perfect").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("perfect").SetValue(BaseBobberBar, value); } + } + + public bool bossFish + { + get { return (bool) GetBaseFieldInfo("bossFish").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("bossFish").SetValue(BaseBobberBar, value); } + } + + public int bobberBarHeight + { + get { return (int) GetBaseFieldInfo("bobberBarHeight").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("bobberBarHeight").SetValue(BaseBobberBar, value); } + } + + public int fishSize + { + get { return (int) GetBaseFieldInfo("fishSize").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("fishSize").SetValue(BaseBobberBar, value); } + } + + public int fishQuality + { + get { return (int) GetBaseFieldInfo("fishQuality").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("fishQuality").SetValue(BaseBobberBar, value); } + } + + public int minFishSize + { + get { return (int) GetBaseFieldInfo("minFishSize").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("minFishSize").SetValue(BaseBobberBar, value); } + } + + public int maxFishSize + { + get { return (int) GetBaseFieldInfo("maxFishSize").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("maxFishSize").SetValue(BaseBobberBar, value); } + } + + public int fishSizeReductionTimer + { + get { return (int) GetBaseFieldInfo("fishSizeReductionTimer").GetValue(BaseBobberBar); } + set { GetBaseFieldInfo("fishSizeReductionTimer").SetValue(BaseBobberBar, value); } + } + + public int whichBobber + { + get { return (int) GetBaseFieldInfo("whichBobber").GetValue(BaseBobberB