internal static void Postfix(Tower tower, TowerModel def, string __state)
{
if (__state != null)
{
MelonMain.DoPatchMethods(mod => mod.OnTowerUpgraded(tower, __state, def));
}
}
internal static void Postfix(Tower tower, TowerModel def, string __state)
{
if (__state != null)
{
MelonMain.PerformHook(mod => mod.OnTowerUpgraded(tower, __state, def));
}
}
internal static bool Prefix(Bloon __instance)
{
bool result = true;
MelonMain.DoPatchMethods(mod => result &= mod.PreBloonLeaked(__instance));
return(result);
}
internal static void Postfix(Bloon __instance)
{
MelonMain.DoPatchMethods(mod =>
{
mod.OnBloonDestroy(__instance);
});
}
internal static void Postfix(Bloon __instance)
{
MelonMain.DoPatchMethods(mod =>
{
mod.PostBloonLeaked(__instance);
});
}
internal static bool Prefix(Bloon __instance)
{
bool result = true;
SessionData.Instance.LeakedBloons.Add(__instance);
MelonMain.PerformHook(mod => result &= mod.PreBloonLeaked(__instance));
return(result);
}
internal static void Postfix(Bloon __instance)
{
MelonMain.PerformHook(mod => { mod.OnBloonDestroy(__instance); });
if (__instance.WasBloonPopped())
{
MelonMain.PerformHook(mod => { mod.OnBloonPopped(__instance); });
}
}
internal static void Postfix(Bloon __instance, float amount, DamageType damageType,
Projectile projectile, DamageDistributionMethod distributeToChildren,
Tower damageBy, bool allowTransform)
{
MelonMain.DoPatchMethods(mod =>
{
mod.PostBloonDamaged(__instance, amount, damageType, projectile,
distributeToChildren, damageBy, allowTransform);
});
}
internal static void Postfix(InputManager __instance)
{
if (InGame.instance == null)
{
return;
}
TaskScheduler.ScheduleTask(() => { MelonMain.PerformHook(mod => mod.OnTowerGraphicsCreated(__instance.placementModel, __instance.placementGraphics)); }, waitCondition: () =>
{ return(__instance.placementGraphics?.Count > 0); });
}
internal static void Postfix(Bloon __instance)
{
SessionData.bloonTracker.TrackBloon(__instance);
__instance.CreateBloonToSim(); // Creating new BloonToSimulation will automatically start Tracking BloonSim via the Constructor
MelonMain.DoPatchMethods(mod =>
{
mod.OnBloonCreated(__instance);
});
}
internal static void Postfix(Tower __instance, Entity target, Model modelToUse)
{
if (__instance._display is null) // This is a bugfix for BTD6. Untested but may also be a bug in BATTD
{
__instance._display = __instance.entity.GetBehavior <DisplayBehavior>();
}
MelonMain.DoPatchMethods(mod => mod.OnTowerCreated(__instance, target, modelToUse));
}
internal static void Postfix(Bloon __instance, Model modelToUse)
{
// removed from update 28.0
//SessionData.Instance.bloonTracker.TrackBloon(__instance);
// Creating new BloonToSimulation will automatically start Tracking BloonSim via the Constructor
//__instance.CreateBloonToSim();
MelonMain.PerformHook(mod => mod.OnBloonCreated(__instance));
MelonMain.PerformHook(mod => mod.OnBloonModelUpdated(__instance, modelToUse));
}
internal static void Postfix(Bloon __instance, float totalAmount, Il2CppStringArray types,
Projectile projectile, bool distributeToChildren, bool overrideDistributeBlocker, bool createEffect,
Tower tower, Il2CppStringArray ignoreImmunityForBloonTypes, bool ignoreNonTargetable = false,
bool blockSpawnChildren = false, bool canDestroyProjectile = true)
{
MelonMain.DoPatchMethods(mod =>
{
mod.PostBloonDamaged(__instance, totalAmount, types, projectile, distributeToChildren,
overrideDistributeBlocker, createEffect, tower, ignoreImmunityForBloonTypes,
ignoreNonTargetable, blockSpawnChildren, canDestroyProjectile);
});
}
internal static void Postfix(Bloon __instance, float totalAmount, Projectile projectile,
bool distributeToChildren, bool overrideDistributeBlocker, bool createEffect, Tower tower,
BloonProperties immuneBloonProperties, bool canDestroyProjectile, bool ignoreNonTargetable,
bool blockSpawnChildren)
{
MelonMain.DoPatchMethods(mod =>
{
mod.PostBloonDamaged(__instance, totalAmount, projectile,
distributeToChildren, overrideDistributeBlocker, createEffect, tower,
immuneBloonProperties, canDestroyProjectile, ignoreNonTargetable,
blockSpawnChildren);
});
}
internal static void Postfix(GameModel result, List <ModModel> mods)
{
MelonMain.PerformHook(mod => mod.OnNewGameModel(result, mods));
MelonMain.PerformHook(mod => mod.OnNewGameModel(result));
foreach (var modVanillaContent in ModContent.GetContent <ModVanillaContent>()
.Where(content => !content.AffectBaseGameModel))
{
foreach (var affectedTower in modVanillaContent.GetAffectedTowers(result))
{
modVanillaContent.Apply(affectedTower);
}
}
}
internal static void Postfix(Factory __instance)
{
foreach (var unityDisplayNode in ResourceHandler.Prefabs.Values
.Where(unityDisplayNode => unityDisplayNode != null && !unityDisplayNode.isDestroyed))
{
try
{
unityDisplayNode.Destroy();
}
catch (Exception)
{
// ignored
}
}
MelonMain.PerformHook(mod => mod.OnGameObjectsReset());
ResourceHandler.Prefabs.Clear();
}
internal static void Postfix(ProfileModel __instance)
{
foreach (var modTower in ModTowerHandler.ModTowers)
{
if (__instance.unlockedTowers.Contains(modTower.Id))
{
__instance.unlockedTowers.Add(modTower.Id);
}
}
foreach (var modUpgrade in ModTowerHandler.ModUpgrades)
{
if (__instance.acquiredUpgrades.Contains(modUpgrade.Id))
{
__instance.acquiredUpgrades.Contains(modUpgrade.Id);
}
}
MelonMain.DoPatchMethods(mod => mod.OnProfileLoaded(__instance));
}
internal static void Postfix(Tower __instance, Entity target, Model modelToUse)
{
// This is a bugfix. Doing this makes the display behavior more accessible. I added extra checks for redundency
if (__instance.display is null)
{
if (__instance.entity.displayBehaviorCache is null)
{
__instance.entity.displayBehaviorCache = __instance.entity.GetBehavior <DisplayBehavior>();
}
if (__instance.entity.displayBehaviorCache != null)
{
__instance.display = __instance.entity.displayBehaviorCache;
}
}
// end of bugfix
MelonMain.DoPatchMethods(mod => mod.OnTowerCreated(__instance, target, modelToUse));
}
public ModOptionsMenu()
{
modOptionsWindow = CanvasGO.GetComponentInChildrenByName <RectTransform>("ModOptions");
#if BloonsTD6
var scene = SceneManager.GetSceneByName("SettingsUI");
#elif BloonsAT // Keep this so we can add support for BloonsAT in the future
var scene = SceneManager.GetSceneByName("UI-Settings");
#endif
var rootGameObjects = scene.GetRootGameObjects();
var mainMenuCanvas = rootGameObjects[0];
instantiatedUI = Object.Instantiate(modOptionsWindow.gameObject, mainMenuCanvas.transform);
modList = instantiatedUI.GetComponentInChildrenByName <RectTransform>("ModList Container");
optionsList = instantiatedUI.GetComponentInChildrenByName <RectTransform>("ModOptions Container");
uiElementsContainer = instantiatedUI.GetComponentInChildrenByName <RectTransform>("UI Elements");
modListItem = instantiatedUI.GetComponentInChildrenByName <RectTransform>("ModList Item");
HideOriginalAssets(instantiatedUI);
var mods = MelonHandler.Mods.OfType <BloonsMod>().Where(mod => mod.ModSettings.Any()).ToList();
for (var i = 0; i < mods.Count; i++)
{
var bloonsMod = mods.ElementAt(i);
PopulateModListItems(bloonsMod, i);
}
doneButton = instantiatedUI.GetComponentInChildrenByName <Button>("DoneButton");
doneButton.AddOnClick(() =>
{
Object.Destroy(instantiatedUI);
MelonMain.modsButton.instantiatedButton.gameObject.SetActive(true);
ModSettingsHandler.SaveModSettings(ModContent.GetInstance <MelonMain>().GetModSettingsDir());
});
MelonMain.PerformHook(mod => mod.OnModOptionsOpened());
}
internal static void Postfix(NKMultiConnection __instance)
{
var messageQueue = __instance.ReceiveQueue;
if (messageQueue == null || messageQueue.Count == 0)
{
return;
}
for (int i = 0; i < messageQueue.Count; i++)
{
var message = messageQueue.Dequeue();
bool consumed = false;
MelonMain.DoPatchMethods(mod =>
{
consumed |= mod.ActOnMessage(message);
});
if (!consumed)
{
messageQueue.Enqueue(message);
}
}
}
internal static void Postfix()
{
foreach (var mod in MelonHandler.Mods.OfType <BloonsMod>().OrderByDescending(mod => mod.Priority))
{
try
{
ResourceHandler.LoadEmbeddedTextures(mod);
ResourceHandler.LoadEmbeddedBundles(mod);
ModContent.LoadModContent(mod);
}
catch (Exception e)
{
MelonLogger.Error("Critical failure when loading resources for mod " + mod.Info.Name);
MelonLogger.Error(e);
}
}
MelonMain.PerformHook(mod => mod.OnTitleScreen());
foreach (var modParagonTower in ModContent.GetContent <ModVanillaParagon>())
{
modParagonTower.AddUpgradesToRealTowers();
}
foreach (var modelMod in Game.instance.model.mods)
{
if (modelMod.name.EndsWith("Only"))
{
var mutatorModModels = modelMod.mutatorMods.ToList();
mutatorModModels.AddRange(ModContent.GetContent <ModTowerSet>()
.Where(set => !set.AllowInRestrictedModes)
.Select(set => new LockTowerSetModModel(modelMod.name, set.Id)));
modelMod.mutatorMods = mutatorModModels.ToIl2CppReferenceArray();
}
}
}
internal static void Postfix(ProfileModel __instance)
{
foreach (var modTower in ModContent.GetContent <ModTower>()
.Where(modTower => !(modTower is ModHero) && !__instance.unlockedTowers.Contains(modTower.Id)))
{
__instance.unlockedTowers.Add(modTower.Id);
__instance.acquiredUpgrades.Add(modTower.Id);
}
foreach (var modUpgrade in ModContent.GetContent <ModUpgrade>()
.Where(modUpgrade => !__instance.acquiredUpgrades.Contains(modUpgrade.Id)))
{
__instance.acquiredUpgrades.Add(modUpgrade.Id);
}
foreach (var modHero in ModContent.GetContent <ModHero>())
{
__instance.unlockedHeroes.Add(modHero.Id);
__instance.seenUnlockedHeroes.Add(modHero.Id);
__instance.seenNewHeroNotification.Add(modHero.Id);
}
MelonMain.PerformHook(mod => mod.OnProfileLoaded(__instance));
}
internal static void Postfix()
{
MelonMain.DoPatchMethods(mod => mod.OnMatchStart());
}
internal static void Postfix(double c, Simulation.CashType from, int cashIndex, Simulation.CashSource source)
{
MelonMain.DoPatchMethods(mod => mod.OnCashRemoved(c, from, cashIndex, source));
}
internal static void Postfix(int roundNumber)
{
MelonMain.DoPatchMethods(mod => mod.OnRoundStart(roundNumber));
}
internal static void Postfix(Projectile __instance, Model modelToUse)
{
MelonMain.DoPatchMethods(mod => mod.OnProjectileModelChanged(__instance, modelToUse));
}
internal static void Postfix(Tower __instance)
{
MelonMain.DoPatchMethods(mod => mod.OnTowerDestroyed(__instance));
}
internal static void Postfix()
{
MelonMain.PerformHook(mod => mod.OnDefeat());
}
internal static void Postfix(bool value)
{
MelonMain.DoPatchMethods(mod => mod.OnFastForwardChanged(value));
}
internal static void Postfix(Tower __instance, Model modelToUse)
{
MelonMain.PerformHook(mod => mod.OnTowerModelChanged(__instance, modelToUse));
}
