/// <summary>
/// Constructor
/// </summary>
public MTN()
{
CustomManager = new CustomManager();
PatchManager = new PatchManager(CustomManager);
SpawnManager = new SpawnManager(CustomManager);
Template = new Templates();
}
/// <summary>
/// Constructor
/// </summary>
public MTN()
{
Harmony = HarmonyInstance.Create("MTN.SgtPickles");
CustomManager = new CustomManager();
PatchManager = new PatchManager(CustomManager);
SpawnManager = new SpawnManager(CustomManager);
Template = new Templates();
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="CustomManager">The class controlling information pertaining to the customs (and the loaded customs).</param>
public wandWarpForRealPatch(ICustomManager customManager)
{
wandWarpForRealPatch.customManager = customManager;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="CustomManager">The class controlling information pertaining to the customs (and the loaded customs).</param>
public drawPatch(ICustomManager customManager)
{
drawPatch.customManager = customManager;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="CustomManager">The class controlling information pertaining to the customs (and the loaded customs).</param>
public loadObjectsPatch(ICustomManager customManager)
{
loadObjectsPatch.customManager = customManager;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="CustomManager">The class controlling information pertaining to the customs (and the loaded customs).</param>
public updateConstructionAnimationPatch(ICustomManager customManager)
{
updateConstructionAnimationPatch.customManager = customManager;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="farmManager">The class controlling information pertaining to the customs (and the loaded customs).</param>
/// <param name="Monitor">SMAPI's IMonitor, to print out useful information to user.</param>
public loadForNewGamePatch(ICustomManager customManager, IMonitor Monitor)
{
loadForNewGamePatch.customManager = customManager;
loadForNewGamePatch.Monitor = Monitor;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="CustomManager">The class controlling information pertaining to the customs (and the loaded customs).</param>
public dayUpdatePatch(ICustomManager customManager)
{
dayUpdatePatch.customManager = customManager;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="customManager">The class controlling information pertaining to the customs (and the loaded customs).</param>
public checkActionPatch(ICustomManager customManager)
{
checkActionPatch.customManager = customManager;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="customManager">The class controlling information pertaining to the customs (and the loaded customs).</param>
public ConstructorFarmPatch(ICustomManager customManager)
{
ConstructorFarmPatch.customManager = customManager;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="customManager">The class controlling information pertaining to the custom farms (and the loaded farm).</param>
public getPorchStandingSpotPatch(ICustomManager customManager)
{
getPorchStandingSpotPatch.customManager = customManager;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="customManager">The class controlling information pertaining to the customs (and the loaded customs).</param>
public setExitLocationPatch(ICustomManager customManager)
{
setExitLocationPatch.customManager = customManager;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="CustomManager">The class controlling information pertaining to the customs (and the loaded customs).</param>
public setUpPatch(ICustomManager customManager)
{
setUpPatch.customManager = customManager;
}
public PatchManager(ICustomManager customManager)
{
this.customManager = customManager;
patches = new List <Patch>();
}
public SpawnManager(ICustomManager customManager)
{
this.customManager = customManager;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="customManager">The class controlling information pertaining to the customs (and the loaded customs).</param>
public ConstructorFarmHousePatch(ICustomManager customManager)
{
ConstructorFarmHousePatch.customManager = customManager;
SwappedID = -1;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="CustomManager">The class controlling information pertaining to the customs (and the loaded customs).</param>
public updateMapPatch(ICustomManager customManager)
{
updateMapPatch.customManager = customManager;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="CustomManager">The class controlling information pertaining to the customs (and the loaded customs).</param>
public startEventPatch(ICustomManager customManager)
{
startEventPatch.customManager = customManager;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="CustomManager">The class controlling information pertaining to the customs (and the loaded customs).</param>
public totemWarpForRealPatch(ICustomManager customManager)
{
totemWarpForRealPatch.customManager = customManager;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="customManager">The class controlling information pertaining to the customs (and the loaded customs).</param>
public resetLocalStatePatch(ICustomManager customManager)
{
resetLocalStatePatch.customManager = customManager;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="farmManager">The class controlling information pertaining to the custom farms (and the loaded farm).</param>
public leftClickPatch(ICustomManager customManager)
{
leftClickPatch.customManager = customManager;
}
public setAtFarmPositionPatch(ICustomManager customManager)
{
setAtFarmPositionPatch.customManager = customManager;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="CustomManager">The class controlling information pertaining to the customs (and the loaded customs).</param>
public performActionPatch(ICustomManager customManager)
{
performActionPatch.customManager = customManager;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="customManager">The class controlling information pertaining to the customs (and the loaded customs).</param>
public UpdateWhenCurrentLocationPatch(ICustomManager customManager)
{
UpdateWhenCurrentLocationPatch.customManager = customManager;
}
/// <summary>
/// Constructor. Awkward method of setting references needed. However, Harmony patches
/// are required to be static. Thus we must break good Object Orientated practices.
/// </summary>
/// <param name="customManager">The class controlling information pertaining to the customs (and the loaded customs).</param>
public getFrontDoorPositionForFarmerPatch(ICustomManager customManager)
{
getFrontDoorPositionForFarmerPatch.customManager = customManager;
}
