MegaKnowledge/MegaKnowledgeMod.cs at main · doombubbles/MegaKnowledge · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
using System;
using System.Collections.Generic;
using System.Linq;
using BTD_Mod_Helper;
using BTD_Mod_Helper.Api;
using BTD_Mod_Helper.Api.Enums;
using BTD_Mod_Helper.Api.ModOptions;
using BTD_Mod_Helper.Extensions;
using Il2CppAssets.Scripts.Models;
using Il2CppAssets.Scripts.Models.Gameplay.Mods;
using Il2CppAssets.Scripts.Models.Towers.Behaviors.Attack;
using Il2CppAssets.Scripts.Models.Towers.Behaviors.Attack.Behaviors;
using Il2CppAssets.Scripts.Models.Towers.Weapons.Behaviors;
using Il2CppAssets.Scripts.Unity;
using Il2CppAssets.Scripts.Unity.UI_New.InGame;
using MegaKnowledge;
using MelonLoader;
[assembly: MelonInfo(typeof(MegaKnowledgeMod), ModHelperData.Name, ModHelperData.Version, ModHelperData.RepoOwner)]
[assembly: MelonGame("Ninja Kiwi", "BloonsTD6")]
[assembly: MelonGame("Ninja Kiwi", "BloonsTD6-Epic")]

namespace MegaKnowledge;

public class MegaKnowledgeMod : BloonsTD6Mod
{
    public static MelonPreferences_Category MegaKnowledgeCategory;

    public static readonly ModSettingBool OpKnowledge = new(false)
    {
        description = "Re-enables the old OP behavior of many MegaKnowledges before they were rebalanced",
        icon = VanillaSprites.MaxPowersIcon,
        displayName = "OP Knowledge"
    };

#if DEBUG
    public static readonly ModSettingButton CreateMds = new(GenerateReadme.Generate);
#endif

    public override void OnMainMenu()
    {
        MegaKnowledgeCategory.SaveToFile(false);
    }

    public override void OnUpdate()
    {
        if (InGame.instance == null || InGame.instance.bridge == null) return;

        foreach (var megaKnowledge in ModContent.GetContent<MegaKnowledge>().Where(mk => mk.Enabled))
        {
            megaKnowledge.OnUpdate();
        }
    }

    public override void OnNewGameModel(GameModel result, IReadOnlyList<ModModel> mods)
    {
        var knowledgeDisabled = Game.instance.GetPlayerProfile().knowledgeDisabled ||
                                mods.ToList().Any(model =>
                                    model.mutatorMods.Any(mod => mod.Is<DisableMonkeyKnowledgeModModel>()));

        if (knowledgeDisabled) return;

        MegaKnowledge.currentGameModel = result;

        var megaKnowledges = ModContent.GetContent<MegaKnowledge>().Where(megaKnowledge => megaKnowledge.Enabled);

        foreach (var megaKnowledge in megaKnowledges)
        {
            foreach (var towerModel in result.GetTowersWithBaseId(megaKnowledge.TowerId).AsIEnumerable())
            {
                if (towerModel.isParagon) continue;

                try
                {
                    megaKnowledge.Apply(towerModel);
                }
                catch (Exception e)
                {
                    ModHelper.Warning<MegaKnowledgeMod>($"Failed to apply {megaKnowledge.Id}");
                    ModHelper.Warning<MegaKnowledgeMod>(e);
                }
            }
        }
    }


    public static void AddAllTargets(AttackModel attackModel)
    {
        var prevTargets = attackModel.GetBehaviors<TargetSupplierModel>().ToList();

        attackModel.AddBehavior(TargetFirstModel.Create(new() { isSelectable = true }));
        attackModel.AddBehavior(TargetLastModel.Create(new() { isSelectable = true }));
        attackModel.AddBehavior(TargetCloseModel.Create(new() { isSelectable = true }));
        attackModel.AddBehavior(TargetStrongModel.Create(new() { isSelectable = true }));

        foreach (var target in prevTargets)
        {
            attackModel.RemoveBehavior(target);
            attackModel.AddBehavior(target);
        }
    }

    public static void UpdatePointer(AttackModel attackModel)
    {
        var pointer = attackModel.GetBehavior<RotateToPointerModel>();
        attackModel.AddBehavior(RotateToTargetModel.Create(new()
        {
            rotateOnlyOnThrow = pointer.rotateOnlyOnEmit,
            rotateTower = pointer.rotateTower
        }));

        if (attackModel.HasDescendant(out LineEffectModel lineEffectModel))
        {
            lineEffectModel.useRotateToPointer = false;
        }
    }
}