From ff3c6ed1b2390b2bb0fd243405f7c681f976f31c Mon Sep 17 00:00:00 2001 From: mend-dev Date: Sat, 22 Jul 2023 11:53:31 -0500 Subject: [PATCH] Vesrion 1.4.0 --- BTD6Rogue.cs | 171 ++++++++++++++------ BTD6Rogue.csproj | 5 +- Bosses/{ => Bloonarius}/BloonariusConfig.cs | 51 +++--- Bosses/{ => Bloonarius}/RogueBloonarius.cs | 2 +- Bosses/Dreadbloon/DreadRockConfig.cs | 37 +++++ Bosses/Dreadbloon/DreadbloonConfig.cs | 71 ++++++++ Bosses/Dreadbloon/RogueDreadRock.cs | 35 ++++ Bosses/Dreadbloon/RogueDreadbloon.cs | 35 ++++ Bosses/{ => Lych}/LychConfig.cs | 63 ++++---- Bosses/{ => Lych}/MiniLychConfig.cs | 33 ++-- Bosses/{ => Lych}/RogueLych.cs | 2 +- Bosses/{ => Lych}/RogueMiniLych.cs | 2 +- Bosses/RogueDreadbloon.cs | 90 ----------- Bosses/{ => Vortex}/RogueVortex.cs | 2 +- Bosses/{ => Vortex}/VortexConfig.cs | 48 +++--- Gamemodes/Roguemode.cs | 24 ++- ModHelperData.cs | 11 +- Modifiers/CamoInfestation.cs | 16 +- Panels/ArtifactChoicePanel.cs | 8 +- Panels/DifficultyChoicePanel.cs | 19 ++- Panels/HeroChoicePanel.cs | 5 + Panels/InitialHeroChoicePanel.cs | 7 +- Panels/InitialTowerChoicePanel.cs | 24 ++- Panels/TowerChoicePanel.cs | 17 +- Patches/RestartGamePatch.cs | 3 +- Patches/RoundEndPatch.cs | 15 +- Patches/RoundStartPatch.cs | 7 +- Patches/UpgradePathPatch.cs | 6 +- Rounds/RoundGenerator.cs | 6 +- Towers/BananaFarmer.cs | 1 - Towers/Pontoon.cs | 1 - Towers/PortableLake.cs | 1 - Towers/PowerTowers/BananaFarmer.cs | 22 +++ Towers/PowerTowers/Pontoon.cs | 22 +++ Towers/PowerTowers/PortableLake.cs | 22 +++ Util/DifficultyUtil.cs | 33 ++++ Util/HeroUtil.cs | 5 +- Util/TowerUtil.cs | 54 ++++--- 38 files changed, 660 insertions(+), 316 deletions(-) rename Bosses/{ => Bloonarius}/BloonariusConfig.cs (69%) rename Bosses/{ => Bloonarius}/RogueBloonarius.cs (99%) create mode 100644 Bosses/Dreadbloon/DreadRockConfig.cs create mode 100644 Bosses/Dreadbloon/DreadbloonConfig.cs create mode 100644 Bosses/Dreadbloon/RogueDreadRock.cs create mode 100644 Bosses/Dreadbloon/RogueDreadbloon.cs rename Bosses/{ => Lych}/LychConfig.cs (69%) rename Bosses/{ => Lych}/MiniLychConfig.cs (60%) rename Bosses/{ => Lych}/RogueLych.cs (99%) rename Bosses/{ => Lych}/RogueMiniLych.cs (98%) delete mode 100644 Bosses/RogueDreadbloon.cs rename Bosses/{ => Vortex}/RogueVortex.cs (98%) rename Bosses/{ => Vortex}/VortexConfig.cs (67%) delete mode 100644 Towers/BananaFarmer.cs delete mode 100644 Towers/Pontoon.cs delete mode 100644 Towers/PortableLake.cs create mode 100644 Towers/PowerTowers/BananaFarmer.cs create mode 100644 Towers/PowerTowers/Pontoon.cs create mode 100644 Towers/PowerTowers/PortableLake.cs create mode 100644 Util/DifficultyUtil.cs diff --git a/BTD6Rogue.cs b/BTD6Rogue.cs index c24b705..9f68449 100644 --- a/BTD6Rogue.cs +++ b/BTD6Rogue.cs @@ -5,11 +5,10 @@ using BTD_Mod_Helper.Extensions; using Il2CppAssets.Scripts.Simulation.Input; using System.Collections.Generic; -using Il2CppAssets.Scripts.Unity; using BTD_Mod_Helper.Api.ModOptions; -using Il2CppAssets.Scripts.Models.Rounds; -using Il2CppInterop.Runtime.InteropTypes.Arrays; using UnityEngine; +using Il2CppAssets.Scripts.Models.Towers; +using Il2CppAssets.Scripts.Models.TowerSets; [assembly: MelonInfo(typeof(BTD6Rogue.BTD6Rogue), ModHelperData.Name, ModHelperData.Version, ModHelperData.RepoOwner)] [assembly: MelonGame("Ninja Kiwi", "BloonsTD6")] @@ -17,12 +16,16 @@ namespace BTD6Rogue; public class RogueTower { - public int maxTopPath = 2; - public int maxMidPath = 2; - public int maxBotPath = 2; - public bool top = false; - public bool mid = false; - public bool bot = false; + public string baseId = ""; // Base ID of the Tower Model + public int[] limitPaths = new int[3] { 2, 2, 2 }; // Limited tier of each path when upgrading in game + public int[] maxPaths = new int[3] { 0, 0, 0 }; // Max tier of each path in the base Tower Model + public bool[] lockedPaths = new bool[3] { false, false, false }; // Whether or not the path is locked out of being in the panel + public bool[] hasPaths = new bool[3] { false, false, false }; // Whether or not the base Tower Model even has that path + public bool isHero = false; // Whether or not the tower is a hero + public int count = 0; // How many the player has in their inventory + public bool noPaths = true; // If the tower has no paths + public bool lockedTower = false; // If the tower is unable to show up in choices + public TowerModel baseTowerModel = null!; // Base tower model for the rogue tower } public class BTD6Rogue : BloonsTD6Mod { @@ -46,48 +49,60 @@ public class BTD6Rogue : BloonsTD6Mod { public static readonly ModSettingBool RandomRounds = new(true) { category = RoundSettings }; public static readonly ModSettingCategory TowerSettings = new("Tower Settings") { collapsed = true }; - public static readonly ModSettingInt StartingTowers = new(1) { category = TowerSettings }; // Doesn't Work - public static readonly ModSettingInt AdditionalBeginnerMapStartingTowers = new(0) { category = TowerSettings }; // Doesn't Work - public static readonly ModSettingInt AdditionalIntermediateMapStartingTowers = new(1) { category = TowerSettings }; // Doesn't Work - public static readonly ModSettingInt AdditionalAdvancedMapStartingTowers = new(2) { category = TowerSettings }; // Doesn't Work - public static readonly ModSettingInt AdditionalExpertMapStartingTowers = new(3) { category = TowerSettings }; // Doesn't Work - public static readonly ModSettingInt AdditionalPoppableStartingTowers = new(0) { category = TowerSettings }; // Doesn't Work - public static readonly ModSettingInt AdditionalEasyStartingTowers = new(0) { category = TowerSettings }; // Doesn't Work - public static readonly ModSettingInt AdditionalMediumStartingTowers = new(0) { category = TowerSettings }; // Doesn't Work - public static readonly ModSettingInt AdditionalHardStartingTowers = new(1) { category = TowerSettings }; // Doesn't Work - public static readonly ModSettingInt AdditionalImpoppableStartingTowers = new(2) { category = TowerSettings }; // Doesn't Work - public static readonly ModSettingBool RandomTowers = new(true) { category = TowerSettings }; // Doesn't Work - public static readonly ModSettingInt TowersStartAtRound = new(5) { category = TowerSettings }; // Doesn't Work - public static readonly ModSettingInt RoundsPerRandomTower = new(10) { category = TowerSettings }; // Doesn't Work - public static readonly ModSettingInt Tier1MinimumRound = new(1) { category = TowerSettings, displayName = "Tier 1 Minimum Round", description = "This is the minimum round that tier 1's appear in the Random Tower Pool (this is overwritten by Tier 2 Minimum Round)", min = 1, max = 999 }; // Doesn't Work - public static readonly ModSettingInt Tier2MinimumRound = new(1) { category = TowerSettings, displayName = "Tier 2 Minimum Round", description = "This is the minimum round that tier 2's appear in the Random Tower Pool (this is overwritten by Tier 3 Minimum Round)", min = 1, max = 999 }; // Doesn't Work - public static readonly ModSettingInt Tier3MinimumRound = new(20) { category = TowerSettings, displayName = "Tier 3 Minimum Round", description = "This is the minimum round that tier 3's appear in the Random Tower Pool (this is overwritten by Tier 4 Minimum Round)", min = 1, max = 999 }; // Doesn't Work - public static readonly ModSettingInt Tier4MinimumRound = new(40) { category = TowerSettings, displayName = "Tier 4 Minimum Round", description = "This is the minimum round that tier 4's appear in the Random Tower Pool (this is overwritten by Tier 5 Minimum Round)", min = 1, max = 999 }; // Doesn't Work + public static readonly ModSettingInt BaseStartingTowers = new(1) { category = TowerSettings }; + public static readonly ModSettingInt AdditionalBeginnerMapStartingTowers = new(0) { category = TowerSettings }; + public static readonly ModSettingInt AdditionalIntermediateMapStartingTowers = new(1) { category = TowerSettings }; + public static readonly ModSettingInt AdditionalAdvancedMapStartingTowers = new(2) { category = TowerSettings }; + public static readonly ModSettingInt AdditionalExpertMapStartingTowers = new(3) { category = TowerSettings }; + public static readonly ModSettingInt AdditionalPoppableStartingTowers = new(0) { category = TowerSettings }; + public static readonly ModSettingInt AdditionalEasyStartingTowers = new(0) { category = TowerSettings }; + public static readonly ModSettingInt AdditionalMediumStartingTowers = new(1) { category = TowerSettings }; + public static readonly ModSettingInt AdditionalHardStartingTowers = new(2) { category = TowerSettings }; + public static readonly ModSettingInt AdditionalImpoppableStartingTowers = new(3) { category = TowerSettings }; + public static readonly ModSettingBool RandomTowers = new(true) { category = TowerSettings }; + public static readonly ModSettingBool LimitAllTowersOnChoice = new(true) { category = TowerSettings }; // No work + public static readonly ModSettingInt TowerChoices = new(3) { category = TowerSettings }; // Doesn't Work + public static readonly ModSettingInt TowersStartAtRound = new(5) { category = TowerSettings }; + public static readonly ModSettingInt RoundsPerRandomTower = new(10) { category = TowerSettings }; + public static readonly ModSettingInt Tier1MinimumRound = new(1) { category = TowerSettings, displayName = "Tier 1 Minimum Round", description = "This is the minimum round that tier 1's appear in the Random Tower Pool (this is overwritten by Tier 2 Minimum Round)", min = 1, max = 999 }; + public static readonly ModSettingInt Tier2MinimumRound = new(1) { category = TowerSettings, displayName = "Tier 2 Minimum Round", description = "This is the minimum round that tier 2's appear in the Random Tower Pool (this is overwritten by Tier 3 Minimum Round)", min = 1, max = 999 }; + public static readonly ModSettingInt Tier3MinimumRound = new(20) { category = TowerSettings, displayName = "Tier 3 Minimum Round", description = "This is the minimum round that tier 3's appear in the Random Tower Pool (this is overwritten by Tier 4 Minimum Round)", min = 1, max = 999 }; + public static readonly ModSettingInt Tier4MinimumRound = new(40) { category = TowerSettings, displayName = "Tier 4 Minimum Round", description = "This is the minimum round that tier 4's appear in the Random Tower Pool (this is overwritten by Tier 5 Minimum Round)", min = 1, max = 999 }; public static readonly ModSettingInt Tier5MinimumRound = new(60) { category = TowerSettings, displayName = "Tier 5 Minimum Round", description = "This is the minimum round that tier 5's appear in the Random Tower Pool (this overwrites the Tier 4 pool, but doesn't get overwritten by Paragons)", min = 1, max = 999 }; // Doesn't Work public static readonly ModSettingInt ParagonMinimumRound = new(80) { category = TowerSettings, displayName = "Paragon Minimum Round", description = "This is the minimum round that paragons appear in the Random Tower Pool (this doesn't overwrite Tier 5's appearing)", min = 1, max = 999 }; // Doesn't Work + public static readonly ModSettingBool ModTowers = new(false) { category = TowerSettings }; // Doesn't Work + // Banana Farmer + // Pontoon + // Inflatable Pool public static readonly ModSettingBool LimitUpgrades = new(true); // Doesn't Work public static readonly ModSettingCategory HeroSettings = new("Hero Settings") { collapsed = true }; public static readonly ModSettingBool MultipleHeroes = new(true) { category = HeroSettings }; // Doesn't Work + public static readonly ModSettingBool HeroXpSplit = new(false) { category = HeroSettings }; // Doesn't Work public static readonly ModSettingInt StartingHeroes = new(1) { category = HeroSettings }; // Doesn't Work - public static readonly ModSettingInt HeroesStartAtRound = new(0) { category = HeroSettings }; // Doesn't Work + public static readonly ModSettingInt HeroesStartAtRound = new(40) { category = HeroSettings }; // Doesn't Work public static readonly ModSettingInt RoundsPerRandomHero = new(40) { category = HeroSettings }; // Doesn't Work public static readonly ModSettingCategory ArtifactSettings = new("Artifact Settings") { collapsed = true }; public static readonly ModSettingBool Artifacts = new(true) { category = ArtifactSettings }; // Doesn't Work - public static readonly ModSettingInt ArtifactsStartAtRound = new(0) { category = ArtifactSettings }; // Doesn't Work - public static readonly ModSettingInt RoundsPerArtifact = new(10) { category = ArtifactSettings }; // Doesn't Work + public static readonly ModSettingInt ArtifactsStartAtRound = new(25) { category = ArtifactSettings }; // Doesn't Work + public static readonly ModSettingInt RoundsPerArtifact = new(25) { category = ArtifactSettings }; // Doesn't Work public static readonly ModSettingCategory ModifierSettings = new("Modifier Settings") { collapsed = true }; public static readonly ModSettingBool Modifiers = new(true) { category = ModifierSettings }; // Doesn't Work - public static readonly ModSettingInt ModifiersStartAtRound = new(0) { category = ModifierSettings }; // Doesn't Work - public static readonly ModSettingInt RoundsPerModifier = new(50) { category = ModifierSettings }; // Doesn't Work + public static readonly ModSettingInt ModifiersStartAtRound = new(20) { category = ModifierSettings }; // Doesn't Work + public static readonly ModSettingInt RoundsPerModifier = new(20) { category = ModifierSettings }; // Doesn't Work public static readonly ModSettingCategory BossSettings = new("Boss Settings") { collapsed = true }; public static readonly ModSettingBool Bosses = new(true) { category = BossSettings }; // Doesn't Work - public static readonly ModSettingInt BossesStartAtRound = new(0) { category = BossSettings }; // Doesn't Work - public static readonly ModSettingInt RoundsPerBoss = new(50) { category = BossSettings }; // Doesn't Work + public static readonly ModSettingInt BossesStartAtRound = new(20) { category = BossSettings }; // Doesn't Work + public static readonly ModSettingInt RoundsPerBoss = new(20) { category = BossSettings }; // Doesn't Work + public static readonly ModSettingBool BloonariusBoss = new(true) { category = BossSettings }; // Doesn't Work + public static readonly ModSettingBool VortexBoss = new(true) { category = BossSettings }; // Doesn't Work + public static readonly ModSettingBool LychBoss = new(true) { category = BossSettings }; // Doesn't Work + public static readonly ModSettingBool DreadbloonBoss = new(true) { category = BossSettings }; // Doesn't Work + public static readonly ModSettingBool ModBosses = new(false) { category = BossSettings }; // Doesn't Work #endregion public override void OnApplicationStart() { @@ -101,30 +116,90 @@ public class BTD6Rogue : BloonsTD6Mod { public override void OnUpdate() { base.OnUpdate(); - //if (Input.GetKeyDown(KeyCode.Keypad0)) { - // overrideBoss = "RogueBloonarius"; - //} else if (Input.GetKeyDown(KeyCode.Keypad1)) { - // overrideBoss = "RogueDreadbloon"; - //} else if (Input.GetKeyDown(KeyCode.Keypad2)) { - // overrideBoss = "RogueLych"; - //} else if (Input.GetKeyDown(KeyCode.Keypad3)) { - // overrideBoss = "RogueVortex"; - //} + if (Input.GetKeyDown(KeyCode.Keypad0)) { + overrideBoss = "RogueBloonarius"; + } else if (Input.GetKeyDown(KeyCode.Keypad1)) { + overrideBoss = "RogueDreadbloon"; + } else if (Input.GetKeyDown(KeyCode.Keypad2)) { + overrideBoss = "RogueLych"; + } else if (Input.GetKeyDown(KeyCode.Keypad3)) { + overrideBoss = "RogueVortex"; + } } public void StartRogueGame(InGame __instance) { + + // Get rid of all ui panels if they exist + DifficultyChoicePanel.uiPanel?.Destroy(); + HeroChoicePanel.uiPanel?.Destroy(); + InitialHeroChoicePanel.uiPanel?.Destroy(); + InitialTowerChoicePanel.uiPanel?.Destroy(); + TowerChoicePanel.uiPanel?.Destroy(); + + // Check if the user is in the right gamemode + if (__instance.GetGameModel().gameMode != "BTD6Rogue-Roguemode") { return; } + + // Clear all the previous information stored for the game rogueTowers.Clear(); selectedHeroes.Clear(); modifiers.Clear(); - TowerInventory towerInventory = __instance.GetTowerInventory(); - Il2CppSystem.Collections.Generic.Dictionary towerMaxes = towerInventory.GetTowerInventoryMaxes(); - foreach (string towerName in TowerUtil.towerNames) { towerMaxes[towerName] = 0; rogueTowers.Add(towerName, new RogueTower()); } - foreach (string heroName in TowerUtil.heroNames) { towerMaxes[Game.instance.model.GetTower(heroName).GetBaseId()] = 0; rogueTowers.Add(heroName, new RogueTower()); } - towerInventory.towerMaxes = towerMaxes; - __instance.bridge.OnTowerInventoryChangedSim(true); + + if (RandomTowers) { + // Get the Tower Inventory + TowerInventory towerInventory = __instance.GetTowerInventory(); + Il2CppSystem.Collections.Generic.Dictionary towerMaxes = towerInventory.GetTowerInventoryMaxes(); + + foreach (TowerModel towerModel in __instance.GetGameModel().towers) { + string baseId = towerModel.baseId; + if (!towerModel.IsStandardTower() && towerModel.towerSet != TowerSet.Hero) { continue; } + if (towerModel.GetTowerId() == "TransformedMonkey" || towerModel.GetTowerId() == "TransformedBaseMonkey") { continue; } + if (towerModel.towerSet == TowerSet.Hero && towerModel.upgrades.Length == 0) { continue; } + if ((towerModel.towerSet != TowerSet.Hero && towerModel.tier != 0) || (towerModel.towerSet == TowerSet.Hero && towerModel.tier != 1)) { continue; } + if (towerModel.towerSet == TowerSet.None) { continue; } + if (towerModel.towerSet == TowerSet.Paragon) { continue; } + if (towerModel.towerSet == TowerSet.Items) { continue; } + + if (towerMaxes.ContainsKey(baseId)) { + towerMaxes[baseId] = 0; + } else { + towerMaxes.Add(baseId, 0); + } + + if (rogueTowers.ContainsKey(baseId)) { + rogueTowers[baseId] = new RogueTower(); + } else { + rogueTowers.Add(baseId, new RogueTower()); + } + + rogueTowers[baseId].baseTowerModel = towerModel; + + rogueTowers[baseId].baseId = baseId; + + if (towerModel.towerSet == TowerSet.Hero) { + rogueTowers[baseId].isHero = true; + continue; + } + + for (int i = 0; i < 3; i++) { + for (int j = 1; j < 6; j++) { + if (towerModel.GetUpgrade(i, j) != null) { + rogueTowers[baseId].noPaths = false; + rogueTowers[baseId].hasPaths[i] = true; + rogueTowers[baseId].maxPaths[i] = j; + } + } + } + } + + towerInventory.towerMaxes = towerMaxes; + __instance.bridge.OnTowerInventoryChangedSim(true); + } + towerCount = 0; + __instance.bridge.SetEndRound(119); __instance.bridge.SetRound(0); + DifficultyChoicePanel.Create(__instance.uiRect, __instance); } } \ No newline at end of file diff --git a/BTD6Rogue.csproj b/BTD6Rogue.csproj index 12472bf..724294e 100644 --- a/BTD6Rogue.csproj +++ b/BTD6Rogue.csproj @@ -10,7 +10,10 @@ embedded - + + + + diff --git a/Bosses/BloonariusConfig.cs b/Bosses/Bloonarius/BloonariusConfig.cs similarity index 69% rename from Bosses/BloonariusConfig.cs rename to Bosses/Bloonarius/BloonariusConfig.cs index 83e002d..5bfbfa5 100644 --- a/Bosses/BloonariusConfig.cs +++ b/Bosses/Bloonarius/BloonariusConfig.cs @@ -5,19 +5,21 @@ using BTD_Mod_Helper.Api.Enums; using UnityEngine; -namespace BTD6Rogue; +namespace BTD6Rogue.Bosses.Bloonarius; -public static class BloonariusConfig { +public static class BloonariusConfig +{ // General Stats - public static readonly float baseMaxHealth = 7500f; - public static readonly float levelMaxHealthMultiplier = 3f; + public static readonly float baseMaxHealth = 6000f; + public static readonly float levelMaxHealthMultiplier = 1.5f; public static readonly float baseSpeed = 1.2f; public static readonly float levelSpeedAddition = 0.1f; // Difficulty Multiplier - public static readonly Dictionary difficultyMultipliers = new Dictionary() { + public static readonly Dictionary difficultyMultipliers = new Dictionary() + { ["Poppable"] = 0.7f, ["Easy"] = 0.85f, ["Medium"] = 1f, @@ -71,31 +73,38 @@ public static class BloonariusConfig { BloonType.Ceramic }; - public static void ApplyBloonariusSettings(BloonModel bloonModel, string difficulty, int level) { + public static void ApplyBloonariusSettings(BloonModel bloonModel, string difficulty, int level) + { float multiplier = difficultyMultipliers[difficulty]; - bloonModel.maxHealth = baseMaxHealth * level * multiplier; + bloonModel.maxHealth = baseMaxHealth * (levelMaxHealthMultiplier * level) * multiplier; if (level == 0) { bloonModel.maxHealth = baseMaxHealth * multiplier; } bloonModel.leakDamage = 99999f; - bloonModel.speed = (baseSpeed + (levelSpeedAddition * level)) * multiplier; - bloonModel.Speed = (baseSpeed + (levelSpeedAddition * level)) * multiplier; + bloonModel.speed = (baseSpeed + levelSpeedAddition * level) * multiplier; + bloonModel.Speed = (baseSpeed + levelSpeedAddition * level) * multiplier; - foreach (SpawnBloonsActionModel model in bloonModel.GetBehaviors()) { - if (model.actionId == "StrongSpawn") { + foreach (SpawnBloonsActionModel model in bloonModel.GetBehaviors()) + { + if (model.actionId == "StrongSpawn") + { model.bloonType = strongSpawnBloons[level]; - model.spawnCount = Mathf.FloorToInt((baseStrongSpawnCount + (levelStrongSpawnCountAddition * level)) * multiplier); - model.spawnDistAhead = (baseStrongSpawnDistAhead + (levelStrongSpawnDistAheadAddition * level)) * multiplier; - } else if (model.actionId == "WeakSpawn") { + model.spawnCount = Mathf.FloorToInt((baseStrongSpawnCount + levelStrongSpawnCountAddition * level) * multiplier); + model.spawnDistAhead = (baseStrongSpawnDistAhead + levelStrongSpawnDistAheadAddition * level) * multiplier; + } + else if (model.actionId == "WeakSpawn") + { model.bloonType = weakSpawnBloons[level]; - model.spawnCount = Mathf.FloorToInt((baseWeakSpawnCount + (levelWeakSpawnCountAddition * level)) * multiplier); - model.spawnTrackMax = (baseWeakSpawnTrackMax + (levelWeakSpawnTrackMaxAddition * level)) * multiplier; - model.spawnTrackMin = (baseWeakSpawnTrackMin + (levelWeakSpawnTrackMinAddition * level)) * multiplier; - } else if (model.actionId == "WeakerSpawn") { + model.spawnCount = Mathf.FloorToInt((baseWeakSpawnCount + levelWeakSpawnCountAddition * level) * multiplier); + model.spawnTrackMax = (baseWeakSpawnTrackMax + levelWeakSpawnTrackMaxAddition * level) * multiplier; + model.spawnTrackMin = (baseWeakSpawnTrackMin + levelWeakSpawnTrackMinAddition * level) * multiplier; + } + else if (model.actionId == "WeakerSpawn") + { model.bloonType = bleedSpawnBloons[level]; - model.spawnCount = Mathf.FloorToInt((baseBleedSpawnCount + (levelBleedSpawnCountAddition * level)) * multiplier); - model.spawnTrackMax = (baseBleedSpawnTrackMax + (levelBleedSpawnTrackMaxAddition * level)) * multiplier; - model.spawnTrackMin = (baseBLeedSpawnTrackMin + (levelBleedSpawnTrackMinAddition * level)) * multiplier; + model.spawnCount = Mathf.FloorToInt((baseBleedSpawnCount + levelBleedSpawnCountAddition * level) * multiplier); + model.spawnTrackMax = (baseBleedSpawnTrackMax + levelBleedSpawnTrackMaxAddition * level) * multiplier; + model.spawnTrackMin = (baseBLeedSpawnTrackMin + levelBleedSpawnTrackMinAddition * level) * multiplier; } } diff --git a/Bosses/RogueBloonarius.cs b/Bosses/Bloonarius/RogueBloonarius.cs similarity index 99% rename from Bosses/RogueBloonarius.cs rename to Bosses/Bloonarius/RogueBloonarius.cs index f15ff39..62cafc8 100644 --- a/Bosses/RogueBloonarius.cs +++ b/Bosses/Bloonarius/RogueBloonarius.cs @@ -1,7 +1,7 @@ using BTD_Mod_Helper.Api.Bloons; using Il2CppAssets.Scripts.Models.Bloons; -namespace BTD6Rogue; +namespace BTD6Rogue.Bosses.Bloonarius; public class PoppableRogueBloonarius1 : ModBloon { public override string BaseBloon => "Bloonarius1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { BloonariusConfig.ApplyBloonariusSettings(bloonModel, "Poppable", 0); } } public class PoppableRogueBloonarius2 : ModBloon { public override string BaseBloon => "Bloonarius1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { BloonariusConfig.ApplyBloonariusSettings(bloonModel, "Poppable", 1); } } diff --git a/Bosses/Dreadbloon/DreadRockConfig.cs b/Bosses/Dreadbloon/DreadRockConfig.cs new file mode 100644 index 0000000..badb13a --- /dev/null +++ b/Bosses/Dreadbloon/DreadRockConfig.cs @@ -0,0 +1,37 @@ +using Il2CppAssets.Scripts.Models.Bloons; +using System.Collections.Generic; + +namespace BTD6Rogue; + +public static class DreadRockConfig { + + // General Stats + public static readonly float baseMaxHealth = 10f; + public static readonly float levelMaxHealthMultiplier = 1.5f; + + public static readonly float baseSpeed = 0.5f; + public static readonly float levelSpeedAddition = 0.25f; + + public static readonly float baseLeakDamage = 25; + public static readonly float levelLeakDamageAddition = 0; + + // Difficulty Multiplier + public static readonly Dictionary difficultyMultipliers = new Dictionary() { + ["Poppable"] = 0.7f, + ["Easy"] = 0.85f, + ["Medium"] = 1f, + ["Hard"] = 1.15f, + ["Impoppable"] = 1.3f + }; + + public static void ApplyDreadRockSettings(BloonModel bloonModel, string difficulty, int level) { + float multiplier = difficultyMultipliers[difficulty]; + + bloonModel.maxHealth = baseMaxHealth * (levelMaxHealthMultiplier * level) * multiplier; + if (level == 0) { bloonModel.maxHealth = baseMaxHealth * multiplier; } + + bloonModel.leakDamage = (baseLeakDamage + levelLeakDamageAddition * level) * multiplier; ; + bloonModel.speed = (baseSpeed + levelSpeedAddition * level) * multiplier; + bloonModel.Speed = (baseSpeed + levelSpeedAddition * level) * multiplier; + } +} \ No newline at end of file diff --git a/Bosses/Dreadbloon/DreadbloonConfig.cs b/Bosses/Dreadbloon/DreadbloonConfig.cs new file mode 100644 index 0000000..ba83ead --- /dev/null +++ b/Bosses/Dreadbloon/DreadbloonConfig.cs @@ -0,0 +1,71 @@ +using BTD_Mod_Helper.Extensions; +using Il2CppAssets.Scripts.Models.Bloons; +using Il2CppAssets.Scripts.Models.Bloons.Behaviors.Actions; +using Il2CppAssets.Scripts.Models.Bloons.Behaviors; +using System.Collections.Generic; +using UnityEngine; + +namespace BTD6Rogue; + +public static class DreadbloonConfig { + + // General Stats + public static readonly float baseMaxHealth = 250f; + public static readonly float levelMaxHealthMultiplier = 1.5f; + + public static readonly float baseSpeed = 1; + public static readonly float levelSpeedAddition = 0.1f; + + // Difficulty Multiplier + public static readonly Dictionary difficultyMultipliers = new Dictionary() { + ["Poppable"] = 0.7f, + ["Easy"] = 0.85f, + ["Medium"] = 1f, + ["Hard"] = 1.15f, + ["Impoppable"] = 1.3f + }; + + // + public static readonly float baseDamageReduction = 0.5f; + public static readonly float levelDamageReductionAddition = 0; + + // + public static readonly float baseArmorAmount = 250; + public static readonly float levelArmorAmountAddition = 0; + public static readonly float baseSpeedMultiplier = 1f; + public static readonly float levelSpeedMultiplierAddition = 0; + + // + public static readonly float baseInitialSpawnSize = 5; + public static readonly float levelInitialSpawnSizeAddition = 0; + public static readonly float baseTimeBetweenSpawns = 10; + public static readonly float levelTimeBetweenSpawnsAddition = 0; + + public static void ApplyDreadbloonSettings(BloonModel bloonModel, string difficulty, int level) { + float multiplier = difficultyMultipliers[difficulty]; + + bloonModel.maxHealth = baseMaxHealth * (levelMaxHealthMultiplier * level) * multiplier; + if (level == 0) { bloonModel.maxHealth = baseMaxHealth * multiplier; } + + bloonModel.leakDamage = 99999f; + bloonModel.speed = (baseSpeed + levelSpeedAddition * level) * multiplier; + bloonModel.Speed = (baseSpeed + levelSpeedAddition * level) * multiplier; + + foreach (DamageReductionModel model in bloonModel.GetBehaviors()) { + model.amount = 0.5f; + } + + foreach (GenerateArmourActionModel model in bloonModel.GetBehaviors()) { + model.amount = (baseArmorAmount + levelArmorAmountAddition * level) * multiplier; + model.speedMultiplier = (levelArmorAmountAddition + levelSpeedMultiplierAddition * level) * multiplier; + } + + foreach (SpawnBloonsUntilArmourBreaksActionModel model in bloonModel.GetBehaviors()) { + model.bloonType = "BTD6Rogue-" + difficulty + "RogueDreadRock" + (level + 1); + model.initialSpawnPackSize = Mathf.FloorToInt((baseInitialSpawnSize + levelInitialSpawnSizeAddition * level) * multiplier); + model.timeBetweenSpawns = (baseTimeBetweenSpawns + levelTimeBetweenSpawnsAddition * level) * multiplier; + } + + bloonModel.RemoveTag("Rock"); + } +} \ No newline at end of file diff --git a/Bosses/Dreadbloon/RogueDreadRock.cs b/Bosses/Dreadbloon/RogueDreadRock.cs new file mode 100644 index 0000000..3482e99 --- /dev/null +++ b/Bosses/Dreadbloon/RogueDreadRock.cs @@ -0,0 +1,35 @@ +using BTD_Mod_Helper.Api.Bloons; +using Il2CppAssets.Scripts.Models.Bloons; + +namespace BTD6Rogue.Bosses.Dreadbloon; + +public class PoppableRogueDreadRock1 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Poppable", 0); } } +public class PoppableRogueDreadRock2 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Poppable", 1); } } +public class PoppableRogueDreadRock3 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard2"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Poppable", 2); } } +public class PoppableRogueDreadRock4 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard3"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Poppable", 3); } } +public class PoppableRogueDreadRock5 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard4"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Poppable", 4); } } +public class PoppableRogueDreadRock6 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard5"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Poppable", 5); } } +public class EasyRogueDreadRock1 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Easy", 0); } } +public class EasyRogueDreadRock2 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Easy", 1); } } +public class EasyRogueDreadRock3 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard2"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Easy", 2); } } +public class EasyRogueDreadRock4 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard3"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Easy", 3); } } +public class EasyRogueDreadRock5 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard4"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Easy", 4); } } +public class EasyRogueDreadRock6 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard5"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Easy", 5); } } +public class MediumRogueDreadRock1 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Medium", 0); } } +public class MediumRogueDreadRock2 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Medium", 1); } } +public class MediumRogueDreadRock3 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard2"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Medium", 2); } } +public class MediumRogueDreadRock4 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard3"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Medium", 3); } } +public class MediumRogueDreadRock5 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard4"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Medium", 4); } } +public class MediumRogueDreadRock6 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard5"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Medium", 5); } } +public class HardRogueDreadRock1 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Hard", 0); } } +public class HardRogueDreadRock2 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Hard", 1); } } +public class HardRogueDreadRock3 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard2"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Hard", 2); } } +public class HardRogueDreadRock4 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard3"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Hard", 3); } } +public class HardRogueDreadRock5 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard4"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Hard", 4); } } +public class HardRogueDreadRock6 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard5"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Hard", 5); } } +public class ImpoppableRogueDreadRock1 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Impoppable", 0); } } +public class ImpoppableRogueDreadRock2 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Impoppable", 1); } } +public class ImpoppableRogueDreadRock3 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard2"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Impoppable", 2); } } +public class ImpoppableRogueDreadRock4 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard3"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Impoppable", 3); } } +public class ImpoppableRogueDreadRock5 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard4"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Impoppable", 4); } } +public class ImpoppableRogueDreadRock6 : ModBloon { public override string BaseBloon => "DreadRockBloonStandard5"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadRockConfig.ApplyDreadRockSettings(bloonModel, "Impoppable", 5); } } \ No newline at end of file diff --git a/Bosses/Dreadbloon/RogueDreadbloon.cs b/Bosses/Dreadbloon/RogueDreadbloon.cs new file mode 100644 index 0000000..43f3561 --- /dev/null +++ b/Bosses/Dreadbloon/RogueDreadbloon.cs @@ -0,0 +1,35 @@ +using BTD_Mod_Helper.Api.Bloons; +using Il2CppAssets.Scripts.Models.Bloons; + +namespace BTD6Rogue.Bosses.Dreadbloon; + +public class PoppableRogueDreadbloon1 : ModBloon { public override string BaseBloon => "Dreadbloon1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Poppable", 0); } } +public class PoppableRogueDreadbloon2 : ModBloon { public override string BaseBloon => "Dreadbloon1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Poppable", 1); } } +public class PoppableRogueDreadbloon3 : ModBloon { public override string BaseBloon => "Dreadbloon2"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Poppable", 2); } } +public class PoppableRogueDreadbloon4 : ModBloon { public override string BaseBloon => "Dreadbloon3"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Poppable", 3); } } +public class PoppableRogueDreadbloon5 : ModBloon { public override string BaseBloon => "Dreadbloon4"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Poppable", 4); } } +public class PoppableRogueDreadbloon6 : ModBloon { public override string BaseBloon => "Dreadbloon5"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Poppable", 5); } } +public class EasyRogueDreadbloon1 : ModBloon { public override string BaseBloon => "Dreadbloon1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Easy", 0); } } +public class EasyRogueDreadbloon2 : ModBloon { public override string BaseBloon => "Dreadbloon1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Easy", 1); } } +public class EasyRogueDreadbloon3 : ModBloon { public override string BaseBloon => "Dreadbloon2"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Easy", 2); } } +public class EasyRogueDreadbloon4 : ModBloon { public override string BaseBloon => "Dreadbloon3"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Easy", 3); } } +public class EasyRogueDreadbloon5 : ModBloon { public override string BaseBloon => "Dreadbloon4"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Easy", 4); } } +public class EasyRogueDreadbloon6 : ModBloon { public override string BaseBloon => "Dreadbloon5"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Easy", 5); } } +public class MediumRogueDreadbloon1 : ModBloon { public override string BaseBloon => "Dreadbloon1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Medium", 0); } } +public class MediumRogueDreadbloon2 : ModBloon { public override string BaseBloon => "Dreadbloon1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Medium", 1); } } +public class MediumRogueDreadbloon3 : ModBloon { public override string BaseBloon => "Dreadbloon2"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Medium", 2); } } +public class MediumRogueDreadbloon4 : ModBloon { public override string BaseBloon => "Dreadbloon3"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Medium", 3); } } +public class MediumRogueDreadbloon5 : ModBloon { public override string BaseBloon => "Dreadbloon4"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Medium", 4); } } +public class MediumRogueDreadbloon6 : ModBloon { public override string BaseBloon => "Dreadbloon5"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Medium", 5); } } +public class HardRogueDreadbloon1 : ModBloon { public override string BaseBloon => "Dreadbloon1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Hard", 0); } } +public class HardRogueDreadbloon2 : ModBloon { public override string BaseBloon => "Dreadbloon1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Hard", 1); } } +public class HardRogueDreadbloon3 : ModBloon { public override string BaseBloon => "Dreadbloon2"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Hard", 2); } } +public class HardRogueDreadbloon4 : ModBloon { public override string BaseBloon => "Dreadbloon3"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Hard", 3); } } +public class HardRogueDreadbloon5 : ModBloon { public override string BaseBloon => "Dreadbloon4"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Hard", 4); } } +public class HardRogueDreadbloon6 : ModBloon { public override string BaseBloon => "Dreadbloon5"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Hard", 5); } } +public class ImpoppableRogueDreadbloon1 : ModBloon { public override string BaseBloon => "Dreadbloon1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Impoppable", 0); } } +public class ImpoppableRogueDreadbloon2 : ModBloon { public override string BaseBloon => "Dreadbloon1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Impoppable", 1); } } +public class ImpoppableRogueDreadbloon3 : ModBloon { public override string BaseBloon => "Dreadbloon2"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Impoppable", 2); } } +public class ImpoppableRogueDreadbloon4 : ModBloon { public override string BaseBloon => "Dreadbloon3"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Impoppable", 3); } } +public class ImpoppableRogueDreadbloon5 : ModBloon { public override string BaseBloon => "Dreadbloon4"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Impoppable", 4); } } +public class ImpoppableRogueDreadbloon6 : ModBloon { public override string BaseBloon => "Dreadbloon5"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { DreadbloonConfig.ApplyDreadbloonSettings(bloonModel, "Impoppable", 5); } } \ No newline at end of file diff --git a/Bosses/LychConfig.cs b/Bosses/Lych/LychConfig.cs similarity index 69% rename from Bosses/LychConfig.cs rename to Bosses/Lych/LychConfig.cs index 3e27abc..fa44179 100644 --- a/Bosses/LychConfig.cs +++ b/Bosses/Lych/LychConfig.cs @@ -4,19 +4,21 @@ using System.Collections.Generic; using UnityEngine; -namespace BTD6Rogue; +namespace BTD6Rogue.Bosses.Lych; -public static class LychConfig { +public static class LychConfig +{ // General Stats public static readonly float baseMaxHealth = 5000f; - public static readonly float levelMaxHealthMultiplier = 2f; + public static readonly float levelMaxHealthMultiplier = 1.5f; public static readonly float baseSpeed = 1.2f; public static readonly float levelSpeedAddition = 0.1f; // Difficulty Multiplier - public static readonly Dictionary difficultyMultipliers = new Dictionary() { + public static readonly Dictionary difficultyMultipliers = new Dictionary() + { ["Poppable"] = 0.7f, ["Easy"] = 0.85f, ["Medium"] = 1f, @@ -60,44 +62,51 @@ public static class LychConfig { public static readonly float baseSpeedDownPercent = 0.5f; public static readonly float levelSpeedDownPercentAddition = 0; - public static void ApplyLychSettings(BloonModel bloonModel, string difficulty, int level) { + public static void ApplyLychSettings(BloonModel bloonModel, string difficulty, int level) + { float multiplier = difficultyMultipliers[difficulty]; - bloonModel.maxHealth = baseMaxHealth * level * multiplier; + bloonModel.maxHealth = baseMaxHealth * (levelMaxHealthMultiplier * level) * multiplier; if (level == 0) { bloonModel.maxHealth = baseMaxHealth * multiplier; } bloonModel.leakDamage = 99999f; - bloonModel.speed = (baseSpeed + (levelSpeedAddition * level)) * multiplier; - bloonModel.Speed = (baseSpeed + (levelSpeedAddition * level)) * multiplier; + bloonModel.speed = (baseSpeed + levelSpeedAddition * level) * multiplier; + bloonModel.Speed = (baseSpeed + levelSpeedAddition * level) * multiplier; - foreach (TimeTriggerModel model in bloonModel.GetBehaviors()) { - model.interval = (baseTimeInterval + (levelTimeIntervalAddition * level)) * multiplier; + foreach (TimeTriggerModel model in bloonModel.GetBehaviors()) + { + model.interval = (baseTimeInterval + levelTimeIntervalAddition * level) * multiplier; } - foreach (AbsorbTowerBuffsActionModel model in bloonModel.GetBehaviors()) { - model.healPerBuff = Mathf.FloorToInt((baseHealPerBuff + (levelHealPerBuff * level)) * multiplier); - model.healPercentPerBuff = (baseHealPercentPerBuff + (levelHealPercentPerBuff * level)) * multiplier; - model.radius = (baseAbsorbBuffRadius + (levelAbsorbBuffRadius * level)) * multiplier; - model.towerFreezeDuration = (baseTowerFreezeDuration + (levelTowerFreezeDuration * level)) * multiplier; + foreach (AbsorbTowerBuffsActionModel model in bloonModel.GetBehaviors()) + { + model.healPerBuff = Mathf.FloorToInt((baseHealPerBuff + levelHealPerBuff * level) * multiplier); + model.healPercentPerBuff = (baseHealPercentPerBuff + levelHealPercentPerBuff * level) * multiplier; + model.radius = (baseAbsorbBuffRadius + levelAbsorbBuffRadius * level) * multiplier; + model.towerFreezeDuration = (baseTowerFreezeDuration + levelTowerFreezeDuration * level) * multiplier; } - foreach (HealOnTowerSellActionModel model in bloonModel.GetBehaviors()) { - model.healAmount = Mathf.FloorToInt((baseHealAmount + (levelHealAmount * level)) * multiplier); - model.healPercentForHighestTier = (baseHealPercentTier + (levelHealPercentTier * level)) * multiplier; + foreach (HealOnTowerSellActionModel model in bloonModel.GetBehaviors()) + { + model.healAmount = Mathf.FloorToInt((baseHealAmount + levelHealAmount * level) * multiplier); + model.healPercentForHighestTier = (baseHealPercentTier + levelHealPercentTier * level) * multiplier; } - foreach (ReanimateMoabsActionModel model in bloonModel.GetBehaviors()) { - model.maxRbe = Mathf.FloorToInt((baseMaxRbe + (levelMaxRbe * level)) * multiplier); - model.pauseMovementDuration = (basePauseMovementDuration + (levelPauseMovementDuration * level)) * multiplier; - model.speedMultiplier = (baseReanimatedSpeedMultiplier + (levelReanimatedSpeedMutliplier * level)) * multiplier; - model.healthMultiplier = (baseReanimatedHealthMultiplier + (levelReanimatedHealthMultiplier * level)) * multiplier; + foreach (ReanimateMoabsActionModel model in bloonModel.GetBehaviors()) + { + model.maxRbe = Mathf.FloorToInt((baseMaxRbe + levelMaxRbe * level) * multiplier); + model.pauseMovementDuration = (basePauseMovementDuration + levelPauseMovementDuration * level) * multiplier; + model.speedMultiplier = (baseReanimatedSpeedMultiplier + levelReanimatedSpeedMutliplier * level) * multiplier; + model.healthMultiplier = (baseReanimatedHealthMultiplier + levelReanimatedHealthMultiplier * level) * multiplier; model.miniMeModelId = "BTD6Rogue-" + difficulty + "RogueMiniLych" + (level + 1); - model.timeUntilBloonsMove = (baseTimeUntilBloonsMove + (levelTimeUntilBloonsMove * level)) * multiplier; + model.timeUntilBloonsMove = (baseTimeUntilBloonsMove + levelTimeUntilBloonsMove * level) * multiplier; } - foreach (SetSpeedPercentActionModel model in bloonModel.GetBehaviors()) { - if (model.actionId == "SpeedDown") { - model.percent = (baseSpeedDownPercent + (levelSpeedDownPercentAddition * level)) * multiplier; + foreach (SetSpeedPercentActionModel model in bloonModel.GetBehaviors()) + { + if (model.actionId == "SpeedDown") + { + model.percent = (baseSpeedDownPercent + levelSpeedDownPercentAddition * level) * multiplier; } } } diff --git a/Bosses/MiniLychConfig.cs b/Bosses/Lych/MiniLychConfig.cs similarity index 60% rename from Bosses/MiniLychConfig.cs rename to Bosses/Lych/MiniLychConfig.cs index 5434ba7..8f609f2 100644 --- a/Bosses/MiniLychConfig.cs +++ b/Bosses/Lych/MiniLychConfig.cs @@ -4,19 +4,21 @@ using BTD_Mod_Helper.Extensions; using UnityEngine; -namespace BTD6Rogue; +namespace BTD6Rogue.Bosses.Lych; -public static class MiniLychConfig { +public static class MiniLychConfig +{ // General Stats - public static readonly float baseMaxHealth = 400; - public static readonly float levelMaxHealthMultiplier = 2f; + public static readonly float baseMaxHealth = 300; + public static readonly float levelMaxHealthMultiplier = 1.5f; - public static readonly float baseSpeed = 10; + public static readonly float baseSpeed = 5; public static readonly float levelSpeedAddition = 0f; // Difficulty Multiplier - public static readonly Dictionary difficultyMultipliers = new Dictionary() { + public static readonly Dictionary difficultyMultipliers = new Dictionary() + { ["Poppable"] = 0.7f, ["Easy"] = 0.85f, ["Medium"] = 1f, @@ -32,22 +34,25 @@ public static class MiniLychConfig { public static readonly float baseDrainLives = 1; public static readonly float levelDrainLives = 0; - public static void ApplyMiniLychSettings(BloonModel bloonModel, string difficulty, int level) { + public static void ApplyMiniLychSettings(BloonModel bloonModel, string difficulty, int level) + { float multiplier = difficultyMultipliers[difficulty]; - bloonModel.maxHealth = baseMaxHealth * level * multiplier; + bloonModel.maxHealth = baseMaxHealth * (levelMaxHealthMultiplier * level) * multiplier; if (level == 0) { bloonModel.maxHealth = baseMaxHealth * multiplier; } bloonModel.leakDamage = 99999f; - bloonModel.speed = (baseSpeed + (levelSpeedAddition * level)) * multiplier; - bloonModel.Speed = (baseSpeed + (levelSpeedAddition * level)) * multiplier; + bloonModel.speed = (baseSpeed + levelSpeedAddition * level) * multiplier; + bloonModel.Speed = (baseSpeed + levelSpeedAddition * level) * multiplier; - foreach (TimeTriggerModel model in bloonModel.GetBehaviors()) { - model.interval = (baseTimeInterval + (levelTimeIntervalAddition * level)) * multiplier; + foreach (TimeTriggerModel model in bloonModel.GetBehaviors()) + { + model.interval = (baseTimeInterval + levelTimeIntervalAddition * level) * multiplier; } - foreach (DrainLivesActionModel model in bloonModel.GetBehaviors()) { - model.livesDrained = Mathf.FloorToInt((baseDrainLives + (levelDrainLives * level)) * multiplier); + foreach (DrainLivesActionModel model in bloonModel.GetBehaviors()) + { + model.livesDrained = Mathf.FloorToInt((baseDrainLives + levelDrainLives * level) * multiplier); } } } diff --git a/Bosses/RogueLych.cs b/Bosses/Lych/RogueLych.cs similarity index 99% rename from Bosses/RogueLych.cs rename to Bosses/Lych/RogueLych.cs index a672051..e85f4ca 100644 --- a/Bosses/RogueLych.cs +++ b/Bosses/Lych/RogueLych.cs @@ -1,7 +1,7 @@ using BTD_Mod_Helper.Api.Bloons; using Il2CppAssets.Scripts.Models.Bloons; -namespace BTD6Rogue; +namespace BTD6Rogue.Bosses.Lych; public class PoppableRogueLych1 : ModBloon { public override string BaseBloon => "Lych1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { LychConfig.ApplyLychSettings(bloonModel, "Poppable", 0); } } public class PoppableRogueLych2 : ModBloon { public override string BaseBloon => "Lych1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { LychConfig.ApplyLychSettings(bloonModel, "Poppable", 1); } } diff --git a/Bosses/RogueMiniLych.cs b/Bosses/Lych/RogueMiniLych.cs similarity index 98% rename from Bosses/RogueMiniLych.cs rename to Bosses/Lych/RogueMiniLych.cs index 51adfe6..1748b99 100644 --- a/Bosses/RogueMiniLych.cs +++ b/Bosses/Lych/RogueMiniLych.cs @@ -1,7 +1,7 @@ using BTD_Mod_Helper.Api.Bloons; using Il2CppAssets.Scripts.Models.Bloons; -namespace BTD6Rogue; +namespace BTD6Rogue.Bosses.Lych; public class PoppableRogueMiniLych1 : ModBloon { public override string BaseBloon => "MiniLych1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { MiniLychConfig.ApplyMiniLychSettings(bloonModel, "Poppable", 0); } } public class PoppableRogueMiniLych2 : ModBloon { public override string BaseBloon => "MiniLych1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { MiniLychConfig.ApplyMiniLychSettings(bloonModel, "Poppable", 1); } } diff --git a/Bosses/RogueDreadbloon.cs b/Bosses/RogueDreadbloon.cs deleted file mode 100644 index 1028a22..0000000 --- a/Bosses/RogueDreadbloon.cs +++ /dev/null @@ -1,90 +0,0 @@ -using BTD_Mod_Helper.Api.Bloons; -using BTD_Mod_Helper.Extensions; -using Il2CppAssets.Scripts.Models.Bloons; -using Il2CppAssets.Scripts.Models.Bloons.Behaviors; -using Il2CppAssets.Scripts.Models.Bloons.Behaviors.Actions; - -namespace BTD6Rogue; - -public class RogueDreadbloon1 : ModBloon { - public override string BaseBloon => "Dreadbloon1"; - - public override void ModifyBaseBloonModel(BloonModel bloonModel) { - bloonModel.maxHealth = 500; - foreach (GenerateArmourActionModel gaam in bloonModel.GetBehaviors()) { - gaam.amount = 500; - } - - foreach (DamageReductionModel drm in bloonModel.GetBehaviors()) { - drm.amount = 0.5f; - } - - foreach (SpawnBloonsUntilArmourBreaksActionModel sbuabam in bloonModel.GetBehaviors()) { - sbuabam.bloonType = "BTD6Rogue-RogueRockBloon1"; - //sbuabam.initialSpawnPackSize = 5; - //sbuabam.timeBetweenSpawns = 10; - } - } -} - -public class RogueDreadbloon2 : ModBloon { - public override string BaseBloon => "Dreadbloon1"; - - public override void ModifyBaseBloonModel(BloonModel bloonModel) { - bloonModel.maxHealth = 1000; - foreach (GenerateArmourActionModel gaam in bloonModel.GetBehaviors()) { - gaam.amount = 1000; - } - } -} - -public class RogueDreadbloon3 : ModBloon { - public override string BaseBloon => "Dreadbloon2"; - - public override void ModifyBaseBloonModel(BloonModel bloonModel) { - bloonModel.maxHealth = 2000; - foreach (GenerateArmourActionModel gaam in bloonModel.GetBehaviors()) { - gaam.amount = 2000; - } - } -} - -public class RogueDreadbloon4 : ModBloon { - public override string BaseBloon => "Dreadbloon3"; - - public override void ModifyBaseBloonModel(BloonModel bloonModel) { - bloonModel.maxHealth = 4000; - foreach (GenerateArmourActionModel gaam in bloonModel.GetBehaviors()) { - gaam.amount = 4000; - } - } -} - -public class RogueDreadbloon5 : ModBloon { - public override string BaseBloon => "Dreadbloon4"; - - public override void ModifyBaseBloonModel(BloonModel bloonModel) { - bloonModel.maxHealth = 8000; - foreach (GenerateArmourActionModel gaam in bloonModel.GetBehaviors()) { - gaam.amount = 8000; - } - } -} - -public class RogueDreadbloon6 : ModBloon { - public override string BaseBloon => "Dreadbloon5"; - - public override void ModifyBaseBloonModel(BloonModel bloonModel) { - bloonModel.maxHealth = 16000; - foreach (GenerateArmourActionModel gaam in bloonModel.GetBehaviors()) { - gaam.amount = 16000; - } - } -} - -public class RogueRockBloon1 : ModBloon { - public override string BaseBloon => "DreadRockBloonStandard1"; - public override void ModifyBaseBloonModel(BloonModel bloonModel) { - bloonModel.maxHealth = 30; - } -} \ No newline at end of file diff --git a/Bosses/RogueVortex.cs b/Bosses/Vortex/RogueVortex.cs similarity index 98% rename from Bosses/RogueVortex.cs rename to Bosses/Vortex/RogueVortex.cs index 522f878..8d123aa 100644 --- a/Bosses/RogueVortex.cs +++ b/Bosses/Vortex/RogueVortex.cs @@ -1,7 +1,7 @@ using BTD_Mod_Helper.Api.Bloons; using Il2CppAssets.Scripts.Models.Bloons; -namespace BTD6Rogue; +namespace BTD6Rogue.Bosses.Vortex; public class PoppableRogueVortex1 : ModBloon { public override string BaseBloon => "Vortex1"; public override void ModifyBaseBloonModel(BloonModel bloonModel) { VortexConfig.ApplyVortexSettings(bloonModel, "Poppable", 0); } } diff --git a/Bosses/VortexConfig.cs b/Bosses/Vortex/VortexConfig.cs similarity index 67% rename from Bosses/VortexConfig.cs rename to Bosses/Vortex/VortexConfig.cs index b4fea81..48cca46 100644 --- a/Bosses/VortexConfig.cs +++ b/Bosses/Vortex/VortexConfig.cs @@ -9,8 +9,8 @@ namespace BTD6Rogue; public static class VortexConfig { // General Stats - public static readonly float baseMaxHealth = 6000f; - public static readonly float levelMaxHealthMultiplier = 3f; + public static readonly float baseMaxHealth = 5000f; + public static readonly float levelMaxHealthMultiplier = 1.5f; public static readonly float baseSpeed = 2.75f; public static readonly float levelSpeedAddition = 0.25f; @@ -59,39 +59,45 @@ public static class VortexConfig { public static void ApplyVortexSettings(BloonModel bloonModel, string difficulty, int level) { float multiplier = difficultyMultipliers[difficulty]; - bloonModel.maxHealth = baseMaxHealth * level * multiplier; + bloonModel.maxHealth = baseMaxHealth * (levelMaxHealthMultiplier * level) * multiplier; if (level == 0) { bloonModel.maxHealth = baseMaxHealth * multiplier; } bloonModel.leakDamage = 99999f; - bloonModel.speed = (baseSpeed + (levelSpeedAddition * level)) * multiplier; - bloonModel.Speed = (baseSpeed + (levelSpeedAddition * level)) * multiplier; + bloonModel.speed = (baseSpeed + levelSpeedAddition * level) * multiplier; + bloonModel.Speed = (baseSpeed + levelSpeedAddition * level) * multiplier; - foreach (StunTowersInRadiusActionModel model in bloonModel.GetBehaviors()) { - model.radius = (baseStunRadius + (levelStunRadiusAddition * level)) * multiplier; - model.stunDuration = (baseStunDuration + (levelStunDurationAddition * level)) * multiplier; + foreach (StunTowersInRadiusActionModel model in bloonModel.GetBehaviors()) + { + model.radius = (baseStunRadius + levelStunRadiusAddition * level) * multiplier; + model.stunDuration = (baseStunDuration + levelStunDurationAddition * level) * multiplier; } - foreach (SetSpeedPercentActionModel model in bloonModel.GetBehaviors()) { - model.distance = (baseBackupDistance + (levelBackupDistanceAddition * level)) * multiplier; + foreach (SetSpeedPercentActionModel model in bloonModel.GetBehaviors()) + { + model.distance = (baseBackupDistance + levelBackupDistanceAddition * level) * multiplier; } - foreach (DestroyProjectilesInRadiusActionModel model in bloonModel.GetBehaviors()) { - model.radius = (baseDestroyProjectileRadius + (levelDestroyProjectileRadiusAddition * level)) * multiplier; + foreach (DestroyProjectilesInRadiusActionModel model in bloonModel.GetBehaviors()) + { + model.radius = (baseDestroyProjectileRadius + levelDestroyProjectileRadiusAddition * level) * multiplier; } - foreach (ReflectProjectilesInRadiusActionModel model in bloonModel.GetBehaviors()) { - model.lifespan = (baseReflectProjectileLifespan + (levelRelfectProjectileLifespanAddition * level)) * multiplier; - model.innerRadius = (baseReflectProjectileInnerRadius + (levelReflectProjectileInnerRadiusAddition * level)) * multiplier; - model.outerRadius = (baseReflectProjectileOuterRadius + (levelReflectProjectileOuterRadiusAddition * level)) * multiplier; + foreach (ReflectProjectilesInRadiusActionModel model in bloonModel.GetBehaviors()) + { + model.lifespan = (baseReflectProjectileLifespan + levelRelfectProjectileLifespanAddition * level) * multiplier; + model.innerRadius = (baseReflectProjectileInnerRadius + levelReflectProjectileInnerRadiusAddition * level) * multiplier; + model.outerRadius = (baseReflectProjectileOuterRadius + levelReflectProjectileOuterRadiusAddition * level) * multiplier; } - foreach (TimeTriggerModel model in bloonModel.GetBehaviors()) { - model.interval = (baseTimeInterval + (levelTimeIntervalAddition * level)) * multiplier; + foreach (TimeTriggerModel model in bloonModel.GetBehaviors()) + { + model.interval = (baseTimeInterval + levelTimeIntervalAddition * level) * multiplier; } - foreach (BuffBloonSpeedModel model in bloonModel.GetBehaviors()) { - model.speedBoost = (baseSpeedBoost + (levelSpeedBoostAddition * level)) * multiplier; - model.debuffInRadius = (baseDebuffRadius + (levelDebuffRadiusAddition * level)) * multiplier; + foreach (BuffBloonSpeedModel model in bloonModel.GetBehaviors()) + { + model.speedBoost = (baseSpeedBoost + levelSpeedBoostAddition * level) * multiplier; + model.debuffInRadius = (baseDebuffRadius + levelDebuffRadiusAddition * level) * multiplier; } } } \ No newline at end of file diff --git a/Gamemodes/Roguemode.cs b/Gamemodes/Roguemode.cs index cc38c3c..f896e33 100644 --- a/Gamemodes/Roguemode.cs +++ b/Gamemodes/Roguemode.cs @@ -1,7 +1,19 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; +using BTD_Mod_Helper.Api.Enums; +using BTD_Mod_Helper.Api.Scenarios; +using Il2CppAssets.Scripts.Models.Difficulty; +using Il2CppAssets.Scripts.Models; -namespace BTD6Rogue.Gamemodes; \ No newline at end of file +namespace BTD6Rogue; + +public class Roguemode : ModGameMode { + public override string Difficulty => DifficultyType.Hard; + + public override string BaseGameMode => GameModeType.Hard; + + public override string DisplayName => "BTD6 Rogue"; + + public override string Icon => VanillaSprites.BossEliteT5Icon; + + public override void ModifyBaseGameModeModel(ModModel gameModeModel) { + } +} \ No newline at end of file diff --git a/ModHelperData.cs b/ModHelperData.cs index e7a6d7f..614a692 100644 --- a/ModHelperData.cs +++ b/ModHelperData.cs @@ -2,10 +2,17 @@ namespace BTD6Rogue; public static class ModHelperData { public const string WorksOnVersion = "37.0"; - public const string Version = "1.3.0"; + public const string Version = "1.4.0"; public const string Name = "BTD6Rogue"; - public const string Description = "Turns BTD6 into a Roguelike"; + public const string Description = + "BTD6 Rogue! The mod that turns bloons into a Roguelike, or BTD7 apparently\n" + + "\n" + + "If you're making content of this mod please credit me as the creator, (menddev, https://www.youtube.com/@menddev)\n" + + "\n" + + "Oh by the way, a ton of the mod settings don't work\n" + + "\n" + + "Anyway join my discord and yell at me if it's unbalancd, because it is lmao"; public const string RepoOwner = "mend-dev"; public const string RepoName = "BTD6Rogue"; diff --git a/Modifiers/CamoInfestation.cs b/Modifiers/CamoInfestation.cs index 8fdea16..5f28270 100644 --- a/Modifiers/CamoInfestation.cs +++ b/Modifiers/CamoInfestation.cs @@ -1,15 +1 @@ -using HarmonyLib; -using BTD_Mod_Helper; -using Il2CppAssets.Scripts.Models.Rounds; -using Il2CppInterop.Runtime.InteropTypes.Arrays; -using Il2CppAssets.Scripts.Unity.Bridge; - -namespace BTD6Rogue; - -[HarmonyPatch(typeof(UnityToSimulation), nameof(UnityToSimulation.SpawnBloons))] -static class CamoInfestationPatch { - [HarmonyPrefix] - private static void Prefix(UnityToSimulation __instance, Il2CppReferenceArray emissions, int roundNumber, int emissionIndexOffset) { - ModHelper.Msg("spawning bloms!"); - } -} + \ No newline at end of file diff --git a/Panels/ArtifactChoicePanel.cs b/Panels/ArtifactChoicePanel.cs index a588e5a..24223e6 100644 --- a/Panels/ArtifactChoicePanel.cs +++ b/Panels/ArtifactChoicePanel.cs @@ -2,12 +2,10 @@ using BTD_Mod_Helper.Api.Components; using BTD_Mod_Helper.Api.Enums; using BTD_Mod_Helper.Extensions; -using Il2CppAssets.Scripts.Models.Towers; using Il2CppAssets.Scripts.Simulation.Input; using Il2CppAssets.Scripts.Unity.UI_New.InGame; using MelonLoader; using UnityEngine; -using System.Collections.Generic; namespace BTD6Rogue; @@ -19,11 +17,7 @@ public class ArtifactChoicePanel : MonoBehaviour { public ArtifactChoicePanel(IntPtr ptr) : base(ptr) { } - public void ChooseTower(string hero) { - BTD6Rogue.mod.selectedHeroes.Add(hero); - TowerInventory towerInventory = __instance.GetTowerInventory(); - towerInventory.towerMaxes[hero]++; - __instance.bridge.OnTowerInventoryChangedSim(true); + public void ChooseArtifact(string artifact) { __instance.bridge.SetAutoPlay(true); Destroy(gameObject); } diff --git a/Panels/DifficultyChoicePanel.cs b/Panels/DifficultyChoicePanel.cs index a5e3274..5bb8e44 100644 --- a/Panels/DifficultyChoicePanel.cs +++ b/Panels/DifficultyChoicePanel.cs @@ -1,10 +1,13 @@ using System; using System.Collections.Generic; +using BTD_Mod_Helper; using BTD_Mod_Helper.Api.Components; using BTD_Mod_Helper.Api.Enums; using BTD_Mod_Helper.Extensions; +using Il2CppAssets.Scripts.Models; +using Il2CppAssets.Scripts.Models.Gameplay.Mods; +using Il2CppAssets.Scripts.Models.Rounds; using Il2CppAssets.Scripts.Unity.UI_New.InGame; -using Il2CppAssets.Scripts.Unity.UI_New.InGame.RightMenu.Powers; using MelonLoader; using UnityEngine; @@ -14,33 +17,43 @@ namespace BTD6Rogue; public class DifficultyChoicePanel : MonoBehaviour { public InGame __instance = null!; + public static DifficultyChoicePanel uiPanel = null!; public DifficultyChoicePanel(IntPtr ptr) : base(ptr) { } public void ChooseDifficulty(string difficulty) { InitialHeroChoicePanel.Create(__instance.uiRect, __instance); + if (difficulty == "Poppable") { BTD6Rogue.mod.difficulty = new PoppableDifficulty(); + //__instance.GetGameModel().GetModModel("BTD6Rogue-Roguemode").GetMutator().multiplier = 0.7f; } else if (difficulty == "Easy") { BTD6Rogue.mod.difficulty = new EasyDifficulty(); + //__instance.GetGameModel().GetModModel("BTD6Rogue-Roguemode").GetMutator().multiplier = 0.85f; } else if (difficulty == "Medium") { BTD6Rogue.mod.difficulty = new MediumDifficulty(); + //__instance.GetGameModel().GetModModel("BTD6Rogue-Roguemode").GetMutator().multiplier = 1f; } else if (difficulty == "Hard") { BTD6Rogue.mod.difficulty = new HardDifficulty(); + //__instance.GetGameModel().GetModModel("BTD6Rogue-Roguemode").GetMutator().multiplier = 1.15f; } else if (difficulty == "Impoppable") { BTD6Rogue.mod.difficulty = new ImpoppableDifficulty(); + //__instance.GetGameModel().GetModModel("BTD6Rogue-Roguemode").GetMutator().multiplier = 1.3f; } + uiPanel = null!; __instance.GetGameModel().roundSet.rounds[0] = BTD6Rogue.mod.roundGenerator.GetRandomRoundModel(__instance.GetGameModel().roundSet.rounds[0], 0); Destroy(gameObject); } public static DifficultyChoicePanel Create(RectTransform menu, InGame __instance) { + BTD6Rogue.mod.uiOpen = true; ModHelperPanel panel = menu.gameObject.AddModHelperPanel(new Info("ReforgePanel", 0, 0, 2400, 1000), VanillaSprites.BrownInsertPanel); DifficultyChoicePanel difficultyChoicePanel = panel.AddComponent(); difficultyChoicePanel.__instance = __instance; + uiPanel = difficultyChoicePanel!; ModHelperPanel inset = panel.AddPanel(new Info("InnerPanel") { AnchorMin = new Vector2(0, 0), AnchorMax = new Vector2(1, 1), Size = -50 }, VanillaSprites.BrownInsertPanelDark); @@ -59,8 +72,8 @@ public class DifficultyChoicePanel : MonoBehaviour { VanillaSprites.Red, VanillaSprites.Pink, VanillaSprites.Rainbow, - VanillaSprites.Moab, - VanillaSprites.Bad, + VanillaSprites.MOABIcon, + VanillaSprites.BADIcon, }; ModHelperText infoText = inset.AddText(new Info("Title", 0, 400, 500, 500), "Difficulty", 96); diff --git a/Panels/HeroChoicePanel.cs b/Panels/HeroChoicePanel.cs index 634371b..9900b63 100644 --- a/Panels/HeroChoicePanel.cs +++ b/Panels/HeroChoicePanel.cs @@ -15,6 +15,7 @@ namespace BTD6Rogue; public class HeroChoicePanel : MonoBehaviour { public InGame __instance = null!; + public static HeroChoicePanel uiPanel = null!; public string[] heroChoices = new string[3]; public HeroChoicePanel(IntPtr ptr) : base(ptr) { } @@ -25,14 +26,18 @@ public class HeroChoicePanel : MonoBehaviour { towerInventory.towerMaxes[hero]++; __instance.bridge.OnTowerInventoryChangedSim(true); __instance.bridge.SetAutoPlay(true); + BTD6Rogue.mod.uiOpen = false; + uiPanel = null!; Destroy(gameObject); } public static HeroChoicePanel Create(RectTransform menu, InGame __instance) { + BTD6Rogue.mod.uiOpen = true; var panel = menu.gameObject.AddModHelperPanel(new Info("HeroChoicePanel", 0, 0, 2400, 800), VanillaSprites.BrownInsertPanel); HeroChoicePanel heroChoicePanel = panel.AddComponent(); heroChoicePanel.__instance = __instance; + uiPanel = heroChoicePanel!; var inset = panel.AddPanel(new Info("InnerPanel") { AnchorMin = new Vector2(0, 0), AnchorMax = new Vector2(1, 1), Size = -50 }, VanillaSprites.BrownInsertPanelDark); diff --git a/Panels/InitialHeroChoicePanel.cs b/Panels/InitialHeroChoicePanel.cs index dcebb77..5177b52 100644 --- a/Panels/InitialHeroChoicePanel.cs +++ b/Panels/InitialHeroChoicePanel.cs @@ -16,6 +16,7 @@ namespace BTD6Rogue; public class InitialHeroChoicePanel : MonoBehaviour { public InGame __instance = null!; + public static InitialHeroChoicePanel uiPanel = null!; public RectTransform menu = null!; public InitialHeroChoicePanel(IntPtr ptr) : base(ptr) { } @@ -25,7 +26,10 @@ public class InitialHeroChoicePanel : MonoBehaviour { TowerInventory towerInventory = __instance.GetTowerInventory(); towerInventory.towerMaxes[hero] = 1; __instance.bridge.OnTowerInventoryChangedSim(true); - InitialTowerChoicePanel.Create(__instance.uiRect, __instance); + if (BTD6Rogue.RandomTowers) { + InitialTowerChoicePanel.Create(__instance.uiRect, __instance); + uiPanel = null!; + } Destroy(gameObject); } @@ -34,6 +38,7 @@ public class InitialHeroChoicePanel : MonoBehaviour { var initialHeroChoicePanel = panel.AddComponent(); initialHeroChoicePanel.menu = menu; initialHeroChoicePanel.__instance = __instance; + uiPanel = initialHeroChoicePanel!; var inset = panel.AddPanel(new Info("InnerPanel") { AnchorMin = new Vector2(0, 0), AnchorMax = new Vector2(1, 1), Size = -50 }, VanillaSprites.BrownInsertPanelDark); diff --git a/Panels/InitialTowerChoicePanel.cs b/Panels/InitialTowerChoicePanel.cs index 348818f..dfd8e02 100644 --- a/Panels/InitialTowerChoicePanel.cs +++ b/Panels/InitialTowerChoicePanel.cs @@ -17,6 +17,7 @@ namespace BTD6Rogue; public class InitialTowerChoicePanel : MonoBehaviour { public InGame __instance = null!; + public static InitialTowerChoicePanel uiPanel = null!; public RectTransform menu = null!; public InitialTowerChoicePanel(IntPtr ptr) : base(ptr) { } @@ -27,26 +28,31 @@ public class InitialTowerChoicePanel : MonoBehaviour { towerInventory.towerMaxes[hero]++; __instance.bridge.OnTowerInventoryChangedSim(true); - if (__instance.GetMap().mapModel.mapDifficulty == 0 && BTD6Rogue.mod.towerCount < 1) { Create(__instance.uiRect, __instance); - } else if (__instance.GetMap().mapModel.mapDifficulty == 1 && BTD6Rogue.mod.towerCount < 2) { Create(__instance.uiRect, __instance); - } else if (__instance.GetMap().mapModel.mapDifficulty == 2 && BTD6Rogue.mod.towerCount < 3) { Create(__instance.uiRect, __instance); - } else if (__instance.GetMap().mapModel.mapDifficulty == 3 && BTD6Rogue.mod.towerCount < 4) { Create(__instance.uiRect, __instance); } + List mapDifficulties = new List() { "Beginner", "Intermediate", "Advanced", "Expert" }; + string difficulty = mapDifficulties[__instance.GetMap().mapModel.mapDifficulty]; + if (BTD6Rogue.mod.towerCount < DifficultyUtil.GetStartingTowerCount(difficulty, BTD6Rogue.mod.difficulty.DifficultyName)) { + Create(__instance.uiRect, __instance); + } + BTD6Rogue.mod.uiOpen = false; + uiPanel = null!; Destroy(gameObject); } public static InitialTowerChoicePanel Create(RectTransform menu, InGame __instance) { + BTD6Rogue.mod.uiOpen = true; var panel = menu.gameObject.AddModHelperPanel(new Info("ReforgePanel", 0, 0, 1600, 1080), VanillaSprites.BrownInsertPanel); var reforgePanel = panel.AddComponent(); reforgePanel.menu = menu; reforgePanel.__instance = __instance; + uiPanel = reforgePanel!; var inset = panel.AddPanel(new Info("InnerPanel") { AnchorMin = new Vector2(0, 0), AnchorMax = new Vector2(1, 1), Size = -50 }, VanillaSprites.BrownInsertPanelDark); - string[] heroes = TowerUtil.towerNames.ToArray(); + string[] heroes = TowerUtil.GetAllTowerIds(); // 0 1 2 3 4 5 // 6 7 8 9 10 11 @@ -65,13 +71,15 @@ public class InitialTowerChoicePanel : MonoBehaviour { 125, 125, 125, 125, 125, 125, -125, -125, -125, -125, -125, -125, -350, -350, -350, -350, -350, -350 - }; + }; for (int i = 0; i < heroes.Length; i++) { + float column = (i % 6); + float row = Mathf.FloorToInt(i / 6); TowerModel hero = Game.instance.model.GetTower(heroes[i]); - ModHelperButton button = inset.AddButton(new Info("TowerButton3", xPos[i], yPos[i], 200), VanillaSprites.YellowBtn, new Action(() => reforgePanel.ChooseTower(hero.GetBaseId()))); + ModHelperButton button = inset.AddButton(new Info("Tower Button", column * 250 - 625, row * -250 + 375, 200), VanillaSprites.YellowBtn, new Action(() => reforgePanel.ChooseTower(hero.GetBaseId()))); button.AddImage(new Info("Image") { AnchorMin = new Vector2(0, 0), AnchorMax = new Vector2(1, 1), Size = 50 }, hero.portrait.GetGUID()); } return reforgePanel; } -} \ No newline at end of file +} diff --git a/Panels/TowerChoicePanel.cs b/Panels/TowerChoicePanel.cs index 11fb3aa..cb8b907 100644 --- a/Panels/TowerChoicePanel.cs +++ b/Panels/TowerChoicePanel.cs @@ -20,6 +20,7 @@ namespace BTD6Rogue; public class TowerChoicePanel : MonoBehaviour { public InGame __instance = null!; + public static TowerChoicePanel uiPanel = null!; public string[] towerChoices = new string[3]; public string[] towerPaths = new string[3]; @@ -34,25 +35,29 @@ public class TowerChoicePanel : MonoBehaviour { towerInventory.towerMaxes[towerStr] += towerAmounts[tower]; if (towerPaths[tower] == "top") { - BTD6Rogue.mod.rogueTowers[towerStr].maxTopPath = TowerUtil.GetMaxPath(__instance.currentRoundId + 1); + BTD6Rogue.mod.rogueTowers[towerStr].limitPaths[0] = TowerUtil.GetMaxPath(__instance.currentRoundId + 1); //BTD6Rogue.mod.rogueTowers[towerStr].top = true; } else if (towerPaths[tower] == "mid") { - BTD6Rogue.mod.rogueTowers[towerStr].maxMidPath = TowerUtil.GetMaxPath(__instance.currentRoundId + 1); + BTD6Rogue.mod.rogueTowers[towerStr].limitPaths[1] = TowerUtil.GetMaxPath(__instance.currentRoundId + 1); //BTD6Rogue.mod.rogueTowers[towerStr].mid = true; } else if (towerPaths[tower] == "bot") { - BTD6Rogue.mod.rogueTowers[towerStr].maxBotPath = TowerUtil.GetMaxPath(__instance.currentRoundId + 1); + BTD6Rogue.mod.rogueTowers[towerStr].limitPaths[2] = TowerUtil.GetMaxPath(__instance.currentRoundId + 1); //BTD6Rogue.mod.rogueTowers[towerStr].bot = true; } __instance.bridge.OnTowerInventoryChangedSim(true); __instance.bridge.SetAutoPlay(true); + BTD6Rogue.mod.uiOpen = false; + uiPanel = null!; Destroy(gameObject); } public static TowerChoicePanel Create(RectTransform menu, InGame __instance) { + BTD6Rogue.mod.uiOpen = true; ModHelperPanel panel = menu.gameObject.AddModHelperPanel(new Info("ReforgePanel", 0, 0, 2400, 1000), VanillaSprites.BrownInsertPanel); TowerChoicePanel towerChoicePanel = panel.AddComponent(); towerChoicePanel.__instance = __instance; + uiPanel = towerChoicePanel!; var inset = panel.AddPanel(new Info("InnerPanel") { AnchorMin = new Vector2(0, 0), AnchorMax = new Vector2(1, 1), Size = -50 }, VanillaSprites.BrownInsertPanelDark); @@ -64,9 +69,9 @@ public class TowerChoicePanel : MonoBehaviour { for (int i = 0; i < towerModels.Length; i++) { TowerModel tower = towerModels[i]; towerChoicePanel.towerChoices[i] = tower.GetTowerId(); - if (tower.GetUpgradeLevel(0) >= 1) { towerChoicePanel.towerPaths[i] = "top"; BTD6Rogue.mod.rogueTowers[tower.baseId].top = true; } - if (tower.GetUpgradeLevel(1) >= 1) { towerChoicePanel.towerPaths[i] = "mid"; BTD6Rogue.mod.rogueTowers[tower.baseId].mid = true; } - if (tower.GetUpgradeLevel(2) >= 1) { towerChoicePanel.towerPaths[i] = "bot"; BTD6Rogue.mod.rogueTowers[tower.baseId].bot = true; } + if (tower.GetUpgradeLevel(0) >= 1) { towerChoicePanel.towerPaths[i] = "top"; BTD6Rogue.mod.rogueTowers[tower.baseId].lockedPaths[0] = true; } + if (tower.GetUpgradeLevel(1) >= 1) { towerChoicePanel.towerPaths[i] = "mid"; BTD6Rogue.mod.rogueTowers[tower.baseId].lockedPaths[1] = true; } + if (tower.GetUpgradeLevel(2) >= 1) { towerChoicePanel.towerPaths[i] = "bot"; BTD6Rogue.mod.rogueTowers[tower.baseId].lockedPaths[2] = true; } towerChoicePanel.towerAmounts[i] = TowerUtil.GetTowerCount(tower); ModHelperButton towerButton = inset.AddButton(new Info("Tower Button", xPos[i], -100, 650), VanillaSprites.GreenBtn, new Action(() => towerChoicePanel.ChooseTower(tower.GetTowerId()))); diff --git a/Patches/RestartGamePatch.cs b/Patches/RestartGamePatch.cs index cbbcdaa..a56d384 100644 --- a/Patches/RestartGamePatch.cs +++ b/Patches/RestartGamePatch.cs @@ -1,6 +1,7 @@ using Il2CppAssets.Scripts.Simulation.Input; using Il2CppAssets.Scripts.Unity.UI_New.InGame; using HarmonyLib; +using BTD_Mod_Helper.Extensions; namespace BTD6Rogue; @@ -9,8 +10,6 @@ static class RestartGamePatch { [HarmonyPostfix] private static void Postfix(InGame __instance) { if (BTD6Rogue.DisablePatchesInSandbox && __instance.bridge.IsSandboxMode()) { return; } - BTD6Rogue.mod.rogueTowers.Clear(); - foreach (string towerName in TowerUtil.towerNames) { BTD6Rogue.mod.rogueTowers.Add(towerName, new RogueTower()); } BTD6Rogue.mod.StartRogueGame(__instance); } } \ No newline at end of file diff --git a/Patches/RoundEndPatch.cs b/Patches/RoundEndPatch.cs index 00f86bf..67f615c 100644 --- a/Patches/RoundEndPatch.cs +++ b/Patches/RoundEndPatch.cs @@ -23,7 +23,7 @@ static class RoundEndPatch { } // Tower choice every 10 rounds (starting at 5) - if ((completedRound + 1) % 10 == 5) { + if ((completedRound + 1) % BTD6Rogue.RoundsPerRandomTower == BTD6Rogue.TowersStartAtRound && BTD6Rogue.RandomTowers) { __instance.bridge.SetAutoPlay(false); TowerChoicePanel.Create(__instance.uiRect, __instance); } @@ -34,13 +34,14 @@ static class RoundEndPatch { HeroChoicePanel.Create(__instance.uiRect, __instance); } - /* - // Artifact choice every 20 rounds (starting at 10) - if ((completedRound + 1) % 20 == 10) { - __instance.bridge.SetAutoPlay(false); - ArtifactChoicePanel.Create(__instance.uiRect, __instance); - } + + // Artifact choice every 15 rounds + //if ((completedRound + 1) % 15 == 0) { + // __instance.bridge.SetAutoPlay(false); + // ArtifactChoicePanel.Create(__instance.uiRect, __instance); + //} + /* foreach (string key in BTD6Rogue.mod.modifiers.Keys) { BTD6Rogue.mod.modifiers[key]--; if (BTD6Rogue.mod.modifiers[key] < 1) { BTD6Rogue.mod.modifiers.Remove(key); } diff --git a/Patches/RoundStartPatch.cs b/Patches/RoundStartPatch.cs index be4bdd3..4b5da3c 100644 --- a/Patches/RoundStartPatch.cs +++ b/Patches/RoundStartPatch.cs @@ -1,13 +1,14 @@ using Il2CppAssets.Scripts.Unity.UI_New.InGame; using HarmonyLib; +using Il2CppAssets.Scripts.Unity.Bridge; namespace BTD6Rogue; -[HarmonyPatch(typeof(InGame), nameof(InGame.RoundStart))] +[HarmonyPatch(typeof(UnityToSimulation), nameof(UnityToSimulation.StartRound))] static class RoundStartPatch { [HarmonyPrefix] - private static bool Prefix(InGame __instance) { - if (BTD6Rogue.DisablePatchesInSandbox && __instance.bridge.IsSandboxMode()) { return true; } + private static bool Prefix(UnityToSimulation __instance) { + if (BTD6Rogue.DisablePatchesInSandbox && __instance.IsSandboxMode()) { return true; } return !BTD6Rogue.mod.uiOpen; } } diff --git a/Patches/UpgradePathPatch.cs b/Patches/UpgradePathPatch.cs index f9a9169..a7af7fd 100644 --- a/Patches/UpgradePathPatch.cs +++ b/Patches/UpgradePathPatch.cs @@ -16,11 +16,11 @@ static class UpgradePathPatch { if (tower.towerModel.IsHero()) { return; } if (path == 0) { - if (tower.GetUpgrade(path) != null && tower.GetUpgrade(path).tier >= BTD6Rogue.mod.rogueTowers[tower.towerModel.baseId].maxTopPath) { __result = true; } else if (tower.GetUpgrade(path) != null) { __result = false; } + if (tower.GetUpgrade(path) != null && tower.GetUpgrade(path).tier >= BTD6Rogue.mod.rogueTowers[tower.towerModel.baseId].limitPaths[0]) { __result = true; } else if (tower.GetUpgrade(path) != null) { __result = false; } } else if (path == 1) { - if (tower.GetUpgrade(path) != null && tower.GetUpgrade(path).tier >= BTD6Rogue.mod.rogueTowers[tower.towerModel.baseId].maxMidPath) { __result = true; } else if (tower.GetUpgrade(path) != null) { __result = false; } + if (tower.GetUpgrade(path) != null && tower.GetUpgrade(path).tier >= BTD6Rogue.mod.rogueTowers[tower.towerModel.baseId].limitPaths[1]) { __result = true; } else if (tower.GetUpgrade(path) != null) { __result = false; } } else if (path == 2) { - if (tower.GetUpgrade(path) != null && tower.GetUpgrade(path).tier >= BTD6Rogue.mod.rogueTowers[tower.towerModel.baseId].maxBotPath) { __result = true; } else if (tower.GetUpgrade(path) != null) { __result = false; } + if (tower.GetUpgrade(path) != null && tower.GetUpgrade(path).tier >= BTD6Rogue.mod.rogueTowers[tower.towerModel.baseId].limitPaths[2]) { __result = true; } else if (tower.GetUpgrade(path) != null) { __result = false; } } } } \ No newline at end of file diff --git a/Rounds/RoundGenerator.cs b/Rounds/RoundGenerator.cs index 2d10b98..4c1cc91 100644 --- a/Rounds/RoundGenerator.cs +++ b/Rounds/RoundGenerator.cs @@ -22,9 +22,9 @@ public class RoundGenerator { int mincrease = 0; int bossInt = new Random().Next(3); - string bossId = BTD6Rogue.mod.overrideBoss; - if (bossInt == 0) { bossId = "RogueBloonarius"; } else if (bossInt == 1) { bossId = "RogueVortex"; } else if (bossInt == 2) { bossId = "RogueLych"; } - //if (bossInt == 1) { bossId = "RogueDreadbloon"; } else if (bossInt == 2) { bossId = "RogueLych"; } else if (bossInt == 3) { bossId = "RogueVortex"; } + //string bossId = BTD6Rogue.mod.overrideBoss; + string bossId = "RogueBloonarius"; + if (bossInt == 0) { bossId = "RogueBloonarius"; } else if (bossInt == 1) { bossId = "RogueDreadbloon"; } else if (bossInt == 2) { bossId = "RogueLych"; } else if (bossInt == 3) { bossId = "RogueVortex"; } if (round + 1 == 20) { roundModel.AddBloonGroup("BTD6Rogue-" + BTD6Rogue.mod.difficulty.DifficultyName + bossId + "1", 1, 0, 0); diff --git a/Towers/BananaFarmer.cs b/Towers/BananaFarmer.cs deleted file mode 100644 index 5f28270..0000000 --- a/Towers/BananaFarmer.cs +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/Towers/Pontoon.cs b/Towers/Pontoon.cs deleted file mode 100644 index 5f28270..0000000 --- a/Towers/Pontoon.cs +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/Towers/PortableLake.cs b/Towers/PortableLake.cs deleted file mode 100644 index 5f28270..0000000 --- a/Towers/PortableLake.cs +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/Towers/PowerTowers/BananaFarmer.cs b/Towers/PowerTowers/BananaFarmer.cs new file mode 100644 index 0000000..df6d080 --- /dev/null +++ b/Towers/PowerTowers/BananaFarmer.cs @@ -0,0 +1,22 @@ +using BTD_Mod_Helper.Api.Towers; +using Il2CppAssets.Scripts.Models.Towers; +using Il2CppAssets.Scripts.Models.TowerSets; + +namespace BTD6Rogue.Towers.PowerTowers; +/* +public class BananaFarmer : ModTower { + public override TowerSet TowerSet => TowerSet.Support; + + public override string BaseTower => TowerType.BananaFarmer; + + public override int Cost => 500; + + public override int TopPathUpgrades => 0; + + public override int MiddlePathUpgrades => 0; + + public override int BottomPathUpgrades => 0; + + public override void ModifyBaseTowerModel(TowerModel towerModel) { + } +}*/ diff --git a/Towers/PowerTowers/Pontoon.cs b/Towers/PowerTowers/Pontoon.cs new file mode 100644 index 0000000..04ca01e --- /dev/null +++ b/Towers/PowerTowers/Pontoon.cs @@ -0,0 +1,22 @@ +using BTD_Mod_Helper.Api.Towers; +using Il2CppAssets.Scripts.Models.Towers; +using Il2CppAssets.Scripts.Models.TowerSets; + +namespace BTD6Rogue.Towers.PowerTowers; +/* +public class Pontoon : ModTower { + public override TowerSet TowerSet => TowerSet.Support; + + public override string BaseTower => TowerType.Pontoon; + + public override int Cost => 500; + + public override int TopPathUpgrades => 0; + + public override int MiddlePathUpgrades => 0; + + public override int BottomPathUpgrades => 0; + + public override void ModifyBaseTowerModel(TowerModel towerModel) { + } +}*/ \ No newline at end of file diff --git a/Towers/PowerTowers/PortableLake.cs b/Towers/PowerTowers/PortableLake.cs new file mode 100644 index 0000000..4045070 --- /dev/null +++ b/Towers/PowerTowers/PortableLake.cs @@ -0,0 +1,22 @@ +using BTD_Mod_Helper.Api.Towers; +using Il2CppAssets.Scripts.Models.Towers; +using Il2CppAssets.Scripts.Models.TowerSets; + +namespace BTD6Rogue.Towers.PowerTowers; +/* +public class PortableLake : ModTower { + public override TowerSet TowerSet => TowerSet.Support; + + public override string BaseTower => TowerType.PortableLake; + + public override int Cost => 500; + + public override int TopPathUpgrades => 0; + + public override int MiddlePathUpgrades => 0; + + public override int BottomPathUpgrades => 0; + + public override void ModifyBaseTowerModel(TowerModel towerModel) { + } +}*/ \ No newline at end of file diff --git a/Util/DifficultyUtil.cs b/Util/DifficultyUtil.cs new file mode 100644 index 0000000..ee66516 --- /dev/null +++ b/Util/DifficultyUtil.cs @@ -0,0 +1,33 @@ +namespace BTD6Rogue; + +public static class DifficultyUtil { + + + public static int GetStartingTowerCount(string mapDifficulty, string gameDifficulty) { + int startingTowers = BTD6Rogue.BaseStartingTowers; + + if (mapDifficulty == "Beginner") { + startingTowers += BTD6Rogue.AdditionalBeginnerMapStartingTowers; + } else if (mapDifficulty == "Intermediate") { + startingTowers += BTD6Rogue.AdditionalIntermediateMapStartingTowers; + } else if (mapDifficulty == "Advanced") { + startingTowers += BTD6Rogue.AdditionalAdvancedMapStartingTowers; + } else if (mapDifficulty == "Expert") { + startingTowers += BTD6Rogue.AdditionalExpertMapStartingTowers; + } + + if (gameDifficulty == "Poppable") { + startingTowers += BTD6Rogue.AdditionalPoppableStartingTowers; + } else if (gameDifficulty == "Easy") { + startingTowers += BTD6Rogue.AdditionalEasyStartingTowers; + } else if (gameDifficulty == "Medium") { + startingTowers += BTD6Rogue.AdditionalMediumStartingTowers; + } else if (gameDifficulty == "Hard") { + startingTowers += BTD6Rogue.AdditionalHardStartingTowers; + } else if (gameDifficulty == "Impoppable") { + startingTowers += BTD6Rogue.AdditionalImpoppableStartingTowers; + } + + return startingTowers; + } +} diff --git a/Util/HeroUtil.cs b/Util/HeroUtil.cs index 5f28270..da51fb5 100644 --- a/Util/HeroUtil.cs +++ b/Util/HeroUtil.cs @@ -1 +1,4 @@ - \ No newline at end of file +namespace BTD6Rogue; + +public static class HeroUtil { +} diff --git a/Util/TowerUtil.cs b/Util/TowerUtil.cs index ef86a8a..d936246 100644 --- a/Util/TowerUtil.cs +++ b/Util/TowerUtil.cs @@ -10,16 +10,16 @@ namespace BTD6Rogue; public static class TowerUtil { public static int GetMaxPath(int round) { - if (round >= 0 && round <= 19) { - return 2; - } else if (round >= 20 && round <= 39) { - return 3; - } else if (round >= 40 && round <= 59) { - return 4; - } else if (round >= 60) { + if (round + 1 >= BTD6Rogue.Tier5MinimumRound) { return 5; - } else { + } else if (round + 1 >= BTD6Rogue.Tier4MinimumRound) { + return 4; + } else if (round + 1 >= BTD6Rogue.Tier3MinimumRound) { + return 3; + } else if (round + 1 >= BTD6Rogue.Tier2MinimumRound) { return 2; + } else { + return 1; } } @@ -28,7 +28,7 @@ public static class TowerUtil { for (int i = 0; i < 3; i++) { TowerModel newTower = GetTower(maxPath, waterMap); - while (towerModels.Contains(newTower) || DuplicatePath(newTower)) { + while (towerModels.Contains(newTower) || DuplicatePath(newTower)/* || newTower == null*/) { newTower = GetTower(maxPath, waterMap); } towerModels.Add(newTower); @@ -38,9 +38,9 @@ public static class TowerUtil { } public static bool DuplicatePath(TowerModel tower) { - if (tower.GetUpgradeLevel(0) >= 1 && BTD6Rogue.mod.rogueTowers[tower.baseId].top) { return true; } - if (tower.GetUpgradeLevel(1) >= 1 && BTD6Rogue.mod.rogueTowers[tower.baseId].mid) { return true; } - if (tower.GetUpgradeLevel(2) >= 1 && BTD6Rogue.mod.rogueTowers[tower.baseId].bot) { return true; } + if (tower.GetUpgradeLevel(0) >= 1 && BTD6Rogue.mod.rogueTowers[tower.baseId].lockedPaths[0]) { return true; } + if (tower.GetUpgradeLevel(1) >= 1 && BTD6Rogue.mod.rogueTowers[tower.baseId].lockedPaths[1]) { return true; } + if (tower.GetUpgradeLevel(2) >= 1 && BTD6Rogue.mod.rogueTowers[tower.baseId].lockedPaths[2]) { return true; } return false; } @@ -50,26 +50,29 @@ public static class TowerUtil { string towerId = GetRandomTowerId(waterMap); - TowerModel towerModel = Game.instance.model.GetTower(towerId); + TowerModel towerModel = Game.instance.model.GetTowerModel(towerId); if (path == 0) { - towerModel = Game.instance.model.GetTower(towerId, maxPath, 0, 0); + towerModel = Game.instance.model.GetTowerModel(towerId, maxPath, 0, 0); } else if (path == 1) { - towerModel = Game.instance.model.GetTower(towerId, 0, maxPath, 0); + towerModel = Game.instance.model.GetTowerModel(towerId, 0, maxPath, 0); } else if (path == 2) { - towerModel = Game.instance.model.GetTower(towerId, 0, 0, maxPath); + towerModel = Game.instance.model.GetTowerModel(towerId, 0, 0, maxPath); } return towerModel; } public static string GetRandomTowerId(bool waterMap) { + string[] towerIds = GetAllTowerIds(); if (waterMap) { - return towerNames[new Random().Next(towerNames.Count)]; + return towerIds[new Random().Next(towerIds.Length)]; } else { - string towerName = towerNames[new Random().Next(towerNames.Count)]; - while (towerName == "MonkeyBuccaneer" || towerName == "MonkeySub") { - towerName = towerNames[new Random().Next(towerNames.Count)]; + string towerName = towerIds[new Random().Next(towerIds.Length)]; + TowerModel towerModel = Game.instance.model.GetTowerModel(towerName); + while (towerModel.IsWaterBased()) { + towerName = towerIds[new Random().Next(towerIds.Length)]; + towerModel = Game.instance.model.GetTowerModel(towerName); } return towerName; } @@ -154,6 +157,17 @@ public static class TowerUtil { return 3 + baseCount; } + public static string[] GetAllTowerIds() { + List towerIds = new List(); + + foreach (RogueTower rogueTower in BTD6Rogue.mod.rogueTowers.GetValues()) { + if (rogueTower.baseTowerModel.IsHero()) { continue; } + towerIds.Add(rogueTower.baseId); + } + + return towerIds.ToArray(); + } + public static readonly Dictionary mapLengths = new Dictionary { ["Tutorial"] = 32.75f, // Monkey Meadow ["TreeStump"] = 44.27f,