AccessEnabled/AccessEnabled.cpp at main · mgavin/AccessEnabled · 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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
/*
* Access Enabled Bakkesmod Plugin for Rocket League
*
* This plugin's purpose is to enable access to different menu items that are
* normally inaccessible to the player in certain game states.
*
* Most notably, when you're in training mode (or freeplay), you can's access the
* [Tournaments] playlist card, nor can you access [Create Private Match],
* [Create Lan Match], [Exhibition], or [Season]. This plugin removes the "Access
* Disabled" status from them.
*
* Honestly, if it does more than that, then there's an issue.
* It shouldn's. Please report it.
*
*/

#include "AccessEnabled.hpp"

#include "imgui/imgui.h"
#include "imgui/imgui_internal.h"

#include "HookedEvents.hpp"
#include "Logger.hpp"

namespace {
namespace log = LOGGER;
}

BAKKESMOD_PLUGIN(AccessEnabled, "AccessEnabled", "1.2.1", NULL);

/**
* @brief Things that happen when the plugin is loaded.
*/
void AccessEnabled::onLoad() {
      // initialize things
      HookedEvents::gameWrapper = gameWrapper;

      // set up logging necessities
      log::set_cvarmanager(cvarManager);
      log::set_loglevel(log::LOGLEVEL::OFF);

      CVarManager::instance().set_cvar_prefix("ae_");
      CVarManager::instance().set_cvarmanager(cvarManager);

      cvar_storage = std::make_unique<PersistentManagedCVarStorage>(this, "accessenabled_cvars", true, true);

      init_cvars();
      init_hooked_events();
}

/**
* @brief group together the initialization of cvars
*/
void AccessEnabled::init_cvars() {
      CVarManager::instance().register_cvars();
      CVarManager::instance().get_cvar_enabled().addOnValueChanged([this](std::string oldValue, CVarWrapper newValue) {
            if (plugin_enabled && newValue.getBoolValue()) { return; }
            plugin_enabled = newValue.getBoolValue();
            plugin_enabled ? enable_plugin() : disable_plugin();
      });
#define X(name, ...) cvar_storage->AddCVar(CVarManager::instance().get_cvar_prefix() + #name);
      LIST_OF_PLUGIN_CVARS
#undef X
}

/**
* @brief Group together the initialization of hooked events
*              that will exist over the lifetime of the plugin.
*/
void AccessEnabled::init_hooked_events() {
}

/**
* @brief Things that need to be set to be activated/run when the plugin is turned "on".
*/
void AccessEnabled::enable_plugin() {
      static uint32_t c;
      HookedEvents::AddHookedEventWithCaller<ActorWrapper>(
            "Function TAGame.MenuTreeNodeEnabledChecker_TA.UpdateGFxNodeEnabled",
            [this](ActorWrapper unused, void * params, std::string eventName) {
                  struct parms {
                        uintptr_t n;
                        _ *       s;
                  } * p   = reinterpret_cast<parms *>(params);
                  c       = p->s->r;
                  p->s->r = 0;
            });

      HookedEvents::AddHookedEventWithCaller<ActorWrapper>(
            "Function TAGame.MenuTreeNodeEnabledChecker_TA.UpdateGFxNodeEnabled",
            [this](ActorWrapper unused, void * params, std::string eventName) {
                  struct parms {
                        uintptr_t n;
                        _ *       s;
                  } * p   = reinterpret_cast<parms *>(params);
                  p->s->r = c;
            },
            true);
}

/**
* @brief Things that need to be deactivated when the plugin is turned "off".
*/
void AccessEnabled::disable_plugin() {
      HookedEvents::RemoveHook("Function TAGame.MenuTreeNodeEnabledChecker_TA.UpdateGFxNodeEnabled");
      HookedEvents::RemoveHook("Function TAGame.MenuTreeNodeEnabledChecker_TA.UpdateGFxNodeEnabled", true);
}

/**
* @brief Things that happen when the plugin is unloaded.
*/
void AccessEnabled::onUnload() {
      HookedEvents::RemoveAllHooks();
}

/**
* @brief Menu code that gets called when BM renders plugin settings.
*/
void AccessEnabled::RenderSettings() {
      ImGui::TextWrapped(
            "%s",
            R"""(
*
* This plugin's purpose is to enable access to different menu items that are
* normally inaccessible to the player in certain game states.
*
* Most notably, when you're in training mode (or freeplay), you can's access the
* [Tournaments] playlist card, nor can you access [Create Private Match],
* [Create Lan Match], [Exhibition], or [Season]. This plugin removes the "Access
* Disabled" status from them.
*
* Honestly, if it does more than that, then there's an issue.
* It shouldn't. Please report it.
*

          )""");
      static bool pe = CVarManager::instance().get_cvar_enabled().getBoolValue();
      if (ImGui::Checkbox("Enable the plugin?", &pe)) { CVarManager::instance().get_cvar_enabled().setValue(pe); }
}

/**
* @brief Get the name of the plugin for bakkesmod's plugin menu.
*/
std::string AccessEnabled::GetPluginName() {
      return "Access Enabled";
}

/**
* @brief Set the current ImGui context (for bakkesmod's purpose).
*/
void AccessEnabled::SetImGuiContext(uintptr_t ctx) {
      ImGui::SetCurrentContext(reinterpret_cast<ImGuiContext *>(ctx));
}