fork/GramFirmware

git clone https://git.julia.blue/fork/GramFirmware

CarVacrebase to configurator818d962

gram
4.7 KiB140 linesraw
1#include "core/mode_selection.hpp"
2
3#include "core/state.hpp"
4#include "modes/CustomControllerMode.hpp"
5#include "modes/CustomKeyboardMode.hpp"
6#include "modes/FgcMode.hpp"
7#include "modes/Melee20Button.hpp"
8#include "modes/ProjectM.hpp"
9#include "modes/RivalsOfAether.hpp"
10#include "modes/Ultimate.hpp"
11#include "util/state_util.hpp"
12
13#include <config.pb.h>
14
15Melee20Button melee_mode;
16ProjectM projectm_mode;
17Ultimate ultimate_mode;
18FgcMode fgc_mode;
19RivalsOfAether rivals_mode;
20CustomKeyboardMode keyboard_mode;
21CustomControllerMode custom_mode;
22
23uint64_t mode_activation_masks[10];
24
25size_t current_mode_index = SIZE_MAX;
26
27void set_mode(CommunicationBackend *backend, ControllerMode *mode) {
28    // Delete keyboard mode in case one is set, so we don't end up getting both controller and
29    // keyboard inputs.
30    current_kb_mode = nullptr;
31
32    // Set new controller mode.
33    backend->SetGameMode(mode);
34}
35
36void set_mode(CommunicationBackend *backend, KeyboardMode *mode) {
37    // Only DInputBackend supports keyboard modes.
38    if (backend->BackendId() != COMMS_BACKEND_DINPUT) {
39        return;
40    }
41
42    // Delete and reassign current keyboard mode.
43    current_kb_mode = mode;
44
45    // Unset the current controller mode so backend only gives neutral inputs.
46    backend->SetGameMode(mode);
47}
48
49void set_mode(CommunicationBackend *backend, GameModeConfig &mode_config, Config &config) {
50    switch (mode_config.mode_id) {
51        case MODE_MELEE:
52            melee_mode.SetConfig(mode_config, config.melee_options);
53            set_mode(backend, &melee_mode);
54            break;
55        case MODE_PROJECT_M:
56            projectm_mode.SetConfig(mode_config, config.project_m_options);
57            set_mode(backend, &projectm_mode);
58            break;
59        case MODE_ULTIMATE:
60            ultimate_mode.SetConfig(mode_config);
61            set_mode(backend, &ultimate_mode);
62            break;
63        case MODE_FGC:
64            fgc_mode.SetConfig(mode_config);
65            set_mode(backend, &fgc_mode);
66            break;
67        case MODE_RIVALS_OF_AETHER:
68            rivals_mode.SetConfig(mode_config);
69            set_mode(backend, &rivals_mode);
70            break;
71        case MODE_KEYBOARD:
72            if (backend->BackendId() != COMMS_BACKEND_DINPUT ||
73                mode_config.keyboard_mode_config < 1 ||
74                mode_config.keyboard_mode_config > config.keyboard_modes_count) {
75                break;
76            }
77            keyboard_mode.SetConfig(
78                mode_config,
79                config.keyboard_modes[mode_config.keyboard_mode_config - 1]
80            );
81            set_mode(backend, &keyboard_mode);
82            break;
83        case MODE_CUSTOM:
84            if (mode_config.custom_mode_config < 1 ||
85                mode_config.custom_mode_config > config.custom_modes_count) {
86                break;
87            }
88            custom_mode.SetConfig(
89                mode_config,
90                config.custom_modes[mode_config.custom_mode_config - 1]
91            );
92            set_mode(backend, &custom_mode);
93            break;
94        case MODE_UNSPECIFIED:
95        default:
96            break;
97    }
98}
99
100// TODO: Maybe remove this overload in favour of looking up the gamemode outside of here using a
101// config_utils function.
102void set_mode(CommunicationBackend *backend, GameModeId mode_id, Config &config) {
103    // In this overload we only know the mode id so we need to find a mode config that matches this
104    // ID.
105    for (size_t i = 0; i < config.game_mode_configs_count; i++) {
106        GameModeConfig &mode = config.game_mode_configs[i];
107        if (mode.mode_id == mode_id) {
108            set_mode(backend, mode, config);
109            return;
110        }
111    }
112}
113
114void select_mode(CommunicationBackend **backends, size_t backends_count, Config &config) {
115    // TODO: Use a counter variable to only run the contents of this function every x iterations
116    // rather than on every single poll.
117
118    InputState &inputs = backends[0]->GetInputs();
119
120    for (size_t i = 0; i < config.game_mode_configs_count; i++) {
121        GameModeConfig &mode_config = config.game_mode_configs[i];
122        if (all_buttons_held(inputs.buttons, mode_activation_masks[i]) && i != current_mode_index) {
123            current_mode_index = i;
124            for (size_t i = 0; i < backends_count; i++) {
125                set_mode(backends[i], mode_config, config);
126            }
127            return;
128        }
129    }
130}
131
132void setup_mode_activation_bindings(const GameModeConfig *mode_configs, size_t mode_configs_count) {
133    // Build bit masks for checking for matching button holds.
134    for (size_t i = 0; i < mode_configs_count; i++) {
135        mode_activation_masks[i] = make_button_mask(
136            mode_configs[i].activation_binding,
137            mode_configs[i].activation_binding_count
138        );
139    }
140}