/*********
** Public methods
*********/
public static void Init(IModEvents events, IInputHelper inputHelper, IModRegistry modRegistry, Func <long> getNewId)
{
Magic.InputHelper = inputHelper;
Magic.LoadAssets();
SpellManager.Init(getNewId);
events.GameLoop.UpdateTicked += Magic.OnUpdateTicked;
events.Input.ButtonPressed += Magic.OnButtonPressed;
events.Input.ButtonReleased += Magic.OnButtonReleased;
events.GameLoop.TimeChanged += Magic.OnTimeChanged;
events.Player.Warped += Magic.OnWarped;
SpaceEvents.OnItemEaten += Magic.OnItemEaten;
SpaceEvents.ActionActivated += Magic.ActionTriggered;
Networking.RegisterMessageHandler(Magic.MsgCast, Magic.OnNetworkCast);
events.Display.RenderingHud += Magic.OnRenderingHud;
events.Display.RenderedHud += Magic.OnRenderedHud;
Magic.OnAnalyzeCast += (sender, e) => Mod.Instance.Api.InvokeOnAnalyzeCast(sender as Farmer);
SpaceCore.Skills.RegisterSkill(Magic.Skill = new Skill());
}
/// <summary>
/// Applies late patches.
/// </summary>
/// <param name="harmony">Harmony instance.</param>
/// <param name="registry">Mod registry.</param>
internal static void ApplyPatches(Harmony harmony, IModRegistry registry)
{
if (registry.Get("spacechase0.DynamicGameAssets") is null)
{
return;
}
try
{
if (AccessTools.TypeByName("DynamicGameAssets.Game.CustomFruitTree") is Type dgaTree)
{
ModEntry.ModMonitor.Log("Transpiling DGA to remove damage to fruit trees from hoes", LogLevel.Info);
harmony.Patch(
original: dgaTree.InstanceMethodNamed("performToolAction"),
transpiler: new HarmonyMethod(typeof(FruitTreesAvoidHoe), nameof(FruitTreesAvoidHoe.Transpiler)));
}
else
{
ModEntry.ModMonitor.Log("Cannot find dga fruit trees; they will still be affected by hoes.", LogLevel.Info);
}
}
catch (Exception ex)
{
ModEntry.ModMonitor.Log($"Ran into issue transpiling DGA fruit trees to remove damage from hoes\n\n{ex}.", LogLevel.Error);
}
}
/**********
** Public methods
*********/
/// <summary>The mod entry point, called after the mod is first loaded.</summary>
/// <param name="helper">Provides simplified APIs for writing mods.</param>
public override void Entry(IModHelper helper)
{
// init
LogMonitor = Monitor;
ModPath = helper.DirectoryPath;
ModRegistry = helper.ModRegistry;
PerSaveOptionsDirectory = Path.Combine(ModPath, "psconfigs/");
Config = helper.ReadConfig <ModConfig>();
// disable mod if All Professions is installed
if (this.Helper.ModRegistry.IsLoaded("community.AllProfessions"))
{
Logger.LogCriticalWarning("Conflict Detected. This mod cannot work with AllProfessions. Skill Prestige disabled.");
Logger.LogDisplay("Skill Prestige Mod: If you wish to use this mod in place of AllProfessions, remove the AllProfessions mod and run the player_resetallprofessions command.");
return;
}
// hook events
helper.Events.Input.ButtonPressed += this.OnButtonPressed;
helper.Events.Input.CursorMoved += this.OnCursorMoved;
helper.Events.Display.RenderedActiveMenu += this.OnRenderedActiveMenu;
helper.Events.GameLoop.GameLaunched += this.OnGameLaunched;
helper.Events.GameLoop.UpdateTicked += this.OnUpdateTicked;
helper.Events.GameLoop.DayStarted += this.OnDayStarted;
helper.Events.GameLoop.SaveLoaded += this.OnSaveLoaded;
helper.Events.GameLoop.ReturnedToTitle += this.OnReturnedToTitle;
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="modName">The friendly mod name.</param>
/// <param name="modDirectory">The mod directory path.</param>
/// <param name="jsonHelper">Encapsulate SMAPI's JSON parsing.</param>
/// <param name="modRegistry">Metadata about loaded mods.</param>
/// <param name="commandManager">Manages console commands.</param>
/// <exception cref="ArgumentNullException">An argument is null or empty.</exception>
/// <exception cref="InvalidOperationException">The <paramref name="modDirectory"/> path does not exist on disk.</exception>
public ModHelper(string modName, string modDirectory, JsonHelper jsonHelper, IModRegistry modRegistry, CommandManager commandManager)
{
// validate
if (string.IsNullOrWhiteSpace(modDirectory))
{
throw new ArgumentNullException(nameof(modDirectory));
}
if (jsonHelper == null)
{
throw new ArgumentNullException(nameof(jsonHelper));
}
if (modRegistry == null)
{
throw new ArgumentNullException(nameof(modRegistry));
}
if (!Directory.Exists(modDirectory))
{
throw new InvalidOperationException("The specified mod directory does not exist.");
}
// initialise
this.JsonHelper = jsonHelper;
this.DirectoryPath = modDirectory;
this.ModRegistry = modRegistry;
this.ConsoleCommands = new CommandHelper(modName, commandManager);
}
public bool MatchesForAutomatic(IModRegistry registry)
{
if (UnsupportedMods != null)
{
foreach (string mod in UnsupportedMods)
{
if (!string.IsNullOrEmpty(mod) && registry.IsLoaded(mod))
{
return(false);
}
}
}
if (SupportedMods != null)
{
foreach (string mod in SupportedMods)
{
if (!string.IsNullOrEmpty(mod) && registry.IsLoaded(mod))
{
return(true);
}
}
}
return(false);
}
/// <inheritdoc cref="IModRegistry.GetApi{T}"/>
/// <param name="modRegistry">The mod registry to extend.</param>
/// <param name="uniqueId">The mod's unique ID.</param>
/// <param name="label">A human-readable name for the mod.</param>
/// <param name="minVersion">The minimum supported version of the API.</param>
/// <param name="monitor">The monitor with which to log errors.</param>
public static TInterface GetApi <TInterface>(this IModRegistry modRegistry, string uniqueId, string label, string minVersion, IMonitor monitor) where TInterface : class
{
// fetch info
IManifest manifest = modRegistry.Get(uniqueId)?.Manifest;
if (manifest == null)
{
return(null);
}
// check version
if (manifest.Version.IsOlderThan(minVersion))
{
monitor.Log($"Detected {label} {manifest.Version}, but need {minVersion} or later. Disabled integration with this mod.", LogLevel.Warn);
return(null);
}
// fetch API
TInterface api = modRegistry.GetApi <TInterface>(uniqueId);
if (api == null)
{
monitor.Log($"Detected {label}, but couldn't fetch its API. Disabled integration with this mod.", LogLevel.Warn);
return(null);
}
return(api);
}
public static void Setup(IModRegistry registry)
{
if (Instance == null)
{
Instance = new TPMC(registry);
}
}
internal static void LoadAugmentableMachineData()
{
IModRegistry ModRegistry = MachineAugmentorsMod.ModInstance.Helper.ModRegistry;
IEnumerable <MachineInfo> CustomMachines = MachineAugmentorsMod.MachineConfig.Machines.Where(x => !string.IsNullOrEmpty(x.RequiredModUniqueId) && ModRegistry.IsLoaded(x.RequiredModUniqueId)).Select(x => x.ToMachineInfo());
RegisteredMachines = new ReadOnlyCollection <MachineInfo>(BuiltInMachines.Union(CustomMachines).ToList());
}
/// <summary>Called when the mod registry is ready.</summary>
/// <param name="registry">The mod registry.</param>
public void ModRegistryReady(IModRegistry registry)
{
if (registry.IsLoaded("stokastic.PrismaticTools"))
{
this.prismaticToolsAPI = registry.GetApi<IPrismaticToolsAPI>("stokastic.PrismaticTools");
}
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="modRegistry">An API for fetching metadata about loaded mods.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
/// <param name="consumerManifest">The manifest for the mod consuming the API.</param>
/// <param name="getConfig">Get the current config model.</param>
/// <param name="reset">Reset the mod's config to its default values.</param>
/// <param name="saveAndApply">Save the mod's current config to the <c>config.json</c> file.</param>
public GenericModConfigMenuIntegration(IModRegistry modRegistry, IMonitor monitor, IManifest consumerManifest, Func <TConfig> getConfig, Action reset, Action saveAndApply)
: base("Generic Mod Config Menu", "spacechase0.GenericModConfigMenu", "1.6.0", modRegistry, monitor)
{
this.ConsumerManifest = consumerManifest;
this.GetConfig = getConfig;
this.Reset = reset;
this.SaveAndApply = saveAndApply;
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="modRegistry">An API for fetching metadata about loaded mods.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
public BetterJunimosIntegration(IModRegistry modRegistry, IMonitor monitor)
: base("Better Junimos", "hawkfalcon.BetterJunimos", "0.5.0", modRegistry, monitor)
{
if (base.IsLoaded)
{
this.MaxRadius = this.ModApi.GetJunimoHutMaxRadius();
}
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="modRegistry">An API for fetching metadata about loaded mods.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
public LineSprinklersIntegration(IModRegistry modRegistry, IMonitor monitor)
: base("Line Sprinklers", "hootless.LineSprinklers", "1.1.0", modRegistry, monitor)
{
if (base.IsLoaded)
{
this.MaxRadius = this.ModApi.GetMaxGridSize();
}
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="modRegistry">An API for fetching metadata about loaded mods.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
/// <param name="manifest">The mod manifest.</param>
/// <param name="modData">The mod's hardcoded data.</param>
/// <param name="getConfig">Get the current config model.</param>
/// <param name="reset">Reset the config model to the default values.</param>
/// <param name="saveAndApply">Save and apply the current config model.</param>
public GenericModConfigMenuIntegrationForSmallBeachFarm(IModRegistry modRegistry, IMonitor monitor, IManifest manifest, ModData modData, Func <ModConfig> getConfig, Action reset, Action saveAndApply)
{
this.ConfigMenu = new GenericModConfigMenuIntegration <ModConfig>(modRegistry, monitor, manifest, getConfig, reset, saveAndApply);
foreach (ModFarmMapData farm in modData.FarmMaps)
{
this.FarmChoices[farm.ID] = farm.Name ?? farm.Map;
}
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="modRegistry">An API for fetching metadata about loaded mods.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
public BetterSprinklersIntegration(IModRegistry modRegistry, IMonitor monitor)
: base("Better Sprinklers", "Speeder.BetterSprinklers", "2.3.1-unofficial.6-pathoschild", modRegistry, monitor)
{
if (base.IsLoaded)
{
this.MaxRadius = this.ModApi.GetMaxGridSize();
}
}
/*********
** Protected methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="modRegistry">Fetches metadata about loaded mods.</param>
/// <param name="reflection">Simplifies access to private code.</param>
/// <param name="rateLimit">The minimum number of ticks between each update.</param>
protected BaseAttachment(IModRegistry modRegistry, IReflectionHelper reflection, int rateLimit = 0)
{
this.ModRegistry = modRegistry;
this.Reflection = reflection;
this.RateLimit = rateLimit;
this.HasFarmTypeManager = modRegistry.IsLoaded("Esca.FarmTypeManager");
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
/// <param name="modRegistry">An API for fetching metadata about loaded mods.</param>
/// <param name="reflection">An API for accessing private code.</param>
public ModIntegrations(IMonitor monitor, IModRegistry modRegistry, IReflectionHelper reflection)
{
this.BetterJunimos = new BetterJunimosIntegration(modRegistry, monitor);
this.BetterSprinklers = new BetterSprinklersIntegration(modRegistry, monitor);
this.Cobalt = new CobaltIntegration(modRegistry, monitor);
this.PelicanFiber = new PelicanFiberIntegration(modRegistry, reflection, monitor);
this.PrismaticTools = new PrismaticToolsIntegration(modRegistry, monitor);
this.SimpleSprinkler = new SimpleSprinklerIntegration(modRegistry, monitor);
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
/// <param name="modRegistry">An API for fetching metadata about loaded mods.</param>
/// <param name="reflection">An API for accessing private code.</param>
public ModIntegrations(IMonitor monitor, IModRegistry modRegistry, IReflectionHelper reflection)
{
this.Automate = new AutomateIntegration(modRegistry, monitor);
this.BetterJunimos = new BetterJunimosIntegration(modRegistry, monitor);
this.BetterSprinklers = new BetterSprinklersIntegration(modRegistry, monitor);
this.LineSprinklers = new LineSprinklersIntegration(modRegistry, monitor);
this.MultiFertilizer = new MultiFertilizerIntegration(modRegistry, monitor);
this.PelicanFiber = new PelicanFiberIntegration(modRegistry, reflection, monitor);
this.SimpleSprinkler = new SimpleSprinklerIntegration(modRegistry, monitor);
}
/// <summary>Get Generic Mod Config Menu's API if it's installed and valid.</summary>
/// <param name="modRegistry">An API for fetching metadata about loaded mods.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
/// <returns>Returns the API interface if valid, else null.</returns>
public static IGenericModConfigMenuApi GetGenericModConfigMenu(IModRegistry modRegistry, IMonitor monitor)
{
return(IntegrationHelper.GetValidatedApi <IGenericModConfigMenuApi>(
label: "Generic Mod Config Menu",
modId: "spacechase0.GenericModConfigMenu",
minVersion: "1.6.0",
modRegistry: modRegistry,
monitor: monitor
));
}
/*********
** Public methods
*********/
/// <summary>The mod entry point, called after the mod is first loaded.</summary>
/// <param name="helper">Provides simplified APIs for writing mods.</param>
public override void Entry(IModHelper helper)
{
// read config
this.Config = helper.ReadConfig <ModConfig>();
this.Keys = this.Config.Controls.ParseControls(helper.Input, this.Monitor);
// init tractor logic
{
IModRegistry modRegistry = this.Helper.ModRegistry;
IReflectionHelper reflection = this.Helper.Reflection;
StandardAttachmentsConfig toolConfig = this.Config.StandardAttachments;
this.TractorManager = new TractorManager(this.Config, this.Keys, this.Helper.Translation, this.Helper.Reflection, attachments: new IAttachment[]
{
new CustomAttachment(this.Config.CustomAttachments, modRegistry, reflection), // should be first so it can override default attachments
new AxeAttachment(toolConfig.Axe, modRegistry, reflection),
new FertilizerAttachment(toolConfig.Fertilizer, modRegistry, reflection),
new GrassStarterAttachment(toolConfig.GrassStarter, modRegistry, reflection),
new HoeAttachment(toolConfig.Hoe, modRegistry, reflection),
new MeleeWeaponAttachment(toolConfig.MeleeWeapon, modRegistry, reflection),
new MilkPailAttachment(toolConfig.MilkPail, modRegistry, reflection),
new PickaxeAttachment(toolConfig.PickAxe, modRegistry, reflection),
new ScytheAttachment(toolConfig.Scythe, modRegistry, reflection),
new SeedAttachment(toolConfig.Seeds, modRegistry, reflection),
new SeedBagAttachment(toolConfig.SeedBagMod, modRegistry, reflection),
new ShearsAttachment(toolConfig.Shears, modRegistry, reflection),
new SlingshotAttachment(toolConfig.Slingshot, modRegistry, reflection),
new WateringCanAttachment(toolConfig.WateringCan, modRegistry, reflection)
});
}
// hook events
IModEvents events = helper.Events;
events.GameLoop.GameLaunched += this.OnGameLaunched;
events.GameLoop.SaveLoaded += this.OnSaveLoaded;
events.GameLoop.DayStarted += this.OnDayStarted;
events.GameLoop.DayEnding += this.OnDayEnding;
events.GameLoop.Saving += this.OnSaving;
if (this.Config.HighlightRadius)
{
events.Display.Rendered += this.OnRendered;
}
events.Display.MenuChanged += this.OnMenuChanged;
events.Input.ButtonPressed += this.OnButtonPressed;
events.World.NpcListChanged += this.OnNpcListChanged;
events.World.LocationListChanged += this.OnLocationListChanged;
events.GameLoop.UpdateTicked += this.OnUpdateTicked;
events.Multiplayer.ModMessageReceived += this.OnModMessageReceived;
// validate translations
if (!helper.Translation.GetTranslations().Any())
{
this.Monitor.Log("The translation files in this mod's i18n folder seem to be missing. The mod will still work, but you'll see 'missing translation' messages. Try reinstalling the mod to fix this.", LogLevel.Warn);
}
}
public CustomKissingModProxy(IModRegistry registry, IMonitor monitor)
{
IModInfo modInfo = registry.Get("Digus.CustomKissingMod");
if (modInfo != null && modInfo.Manifest.Version.IsOlderThan(MINIMUM_VERSION))
{
monitor.Log($"Couldn't work correctly with Custom Kissing Mod version {modInfo.Manifest.Version} (requires >= {MINIMUM_VERSION}). Don't worry, this issue doesn't affect stability, but update is recommended :)", LogLevel.Warn);
}
this.api = registry.GetApi <ICustomKissingModApi>("Digus.CustomKissingMod");
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="modRegistry">An API for fetching metadata about loaded mods.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
public PrismaticToolsIntegration(IModRegistry modRegistry, IMonitor monitor)
: base("Prismatic Tools", "stokastic.PrismaticTools", "1.3.0", modRegistry, monitor)
{
if (!this.IsLoaded)
{
return;
}
// get mod API
this.ModApi = this.GetValidatedApi <IPrismaticToolsApi>();
this.IsLoaded = this.ModApi != null;
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="modRegistry">An API for fetching metadata about loaded mods.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
public JsonAssetsIntegration(IModRegistry modRegistry, IMonitor monitor)
: base("Json Assets", "spacechase0.JsonAssets", "1.3.8", modRegistry, monitor)
{
if (!this.IsLoaded)
{
return;
}
// get mod API
this.ModApi = this.GetValidatedApi <IJsonAssetsApi>();
this.IsLoaded = this.ModApi != null;
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="modRegistry">An API for fetching metadata about loaded mods.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
public CustomFarmingReduxIntegration(IModRegistry modRegistry, IMonitor monitor)
: base("Custom Farming", "Platonymous.CustomFarming", "2.3.6", modRegistry, monitor)
{
if (!this.IsLoaded)
{
return;
}
// get mod API
this.ModApi = this.GetValidatedApi <ICustomFarmingApi>();
this.IsLoaded = this.ModApi != null;
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="modRegistry">An API for fetching metadata about loaded mods.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
public CobaltIntegration(IModRegistry modRegistry, IMonitor monitor)
: base("Cobalt", "spacechase0.Cobalt", "1.1", modRegistry, monitor)
{
if (!this.IsLoaded)
{
return;
}
// get mod API
this.ModApi = this.GetValidatedApi <ICobaltApi>();
this.IsLoaded = this.ModApi != null;
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="modRegistry">An API for fetching metadata about loaded mods.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
public PushNPCsIntegration(IModRegistry modRegistry, IMonitor monitor)
: base("Push NPCs", "SlyryD.PushNPCs", "1.0.0", modRegistry, monitor)
{
if (!this.IsLoaded)
{
return;
}
// get mod API
this.ModApi = this.GetValidatedApi <IPushNPCsApi>();
this.IsLoaded = this.ModApi != null;
}
public void ModRegistryReady(IModRegistry registry)
{
if (registry.IsLoaded("tZed.SimpleSprinkler"))
{
this.simpleSprinklersAPI = registry.GetApi <ISimpleSprinklersAPI>("tZed.SimpleSprinkler");
}
if (registry.IsLoaded("Speeder.BetterSprinklers"))
{
this.betterSprinklersAPI = registry.GetApi <IBetterSprinklersAPI>("Speeder.BetterSprinklers");
}
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="modRegistry">An API for fetching metadata about loaded mods.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
public FarmExpansionIntegration(IModRegistry modRegistry, IMonitor monitor)
: base("Farm Expansion", "Advize.FarmExpansion", "3.3", modRegistry, monitor)
{
if (!this.IsLoaded)
{
return;
}
// get mod API
this.ModApi = this.GetValidatedApi <IFarmExpansionApi>();
this.IsLoaded = this.ModApi != null;
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="modRegistry">An API for fetching metadata about loaded mods.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
public ProducerFrameworkModIntegration(IModRegistry modRegistry, IMonitor monitor)
: base("Producer Framework Mod", "Digus.ProducerFrameworkMod", "1.3.0", modRegistry, monitor)
{
if (!this.IsLoaded)
{
return;
}
// get mod API
this.ModApi = this.GetValidatedApi <IProducerFrameworkModApi>();
this.IsLoaded = this.ModApi != null;
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="modRegistry">An API for fetching metadata about loaded mods.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
public AutomateIntegration(IModRegistry modRegistry, IMonitor monitor)
: base("Automate", "Pathoschild.Automate", "1.11.0", modRegistry, monitor)
{
if (!this.IsLoaded)
{
return;
}
// get mod API
this.ModApi = this.GetValidatedApi <IAutomateApi>();
this.IsLoaded = this.ModApi != null;
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="modRegistry">An API for fetching metadata about loaded mods.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
public SimpleSprinklerIntegration(IModRegistry modRegistry, IMonitor monitor)
: base("Simple Sprinklers", "tZed.SimpleSprinkler", "1.6.0", modRegistry, monitor)
{
if (!this.IsLoaded)
{
return;
}
// get mod API
this.ModApi = this.GetValidatedApi <ISimplerSprinklerApi>();
this.IsLoaded = this.ModApi != null;
}
