AstralTransRocketries/ClassiCube
1
0
Fork 0
mirror of https://github.com/ClassiCube/ClassiCube.git synced 2025-09-14 01:55:19 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1197 from ClassiCube/BindsRewrite

Browse Source 
Support two button bind mappings
This commit is contained in:
UnknownShadow200 2024-05-25 16:32:56 +10:00 committed by GitHub
commit 02c7ae5da7
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
5 changed files with 193 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

179
src/Input.c
View File

@ -377,38 +377,56 @@ void Pointer_SetPosition(int idx, int x, int y) {
/*########################################################################################################################*
*---------------------------------------------------------Keybinds--------------------------------------------------------*
*#########################################################################################################################*/
cc_uint8 PadBind_Mappings[BIND_COUNT];
cc_uint8 KeyBind_Mappings[BIND_COUNT];
BindMapping PadBind_Mappings[BIND_COUNT];
BindMapping KeyBind_Mappings[BIND_COUNT];
const cc_uint8 PadBind_Defaults[BIND_COUNT] = {
CCPAD_UP, CCPAD_DOWN, CCPAD_LEFT, CCPAD_RIGHT, /* Movement */
CCPAD_A, 0, CCPAD_START, CCPAD_Y, /* Jump, SetSpawn, OpenChat */
CCPAD_X, 0, CCPAD_START, 0, /* Inventory, EnterChat */
0, 0, 0, 0, 0, /* Hacks */
0, 0, 0, 0, /* LAlt - F11 */
0, 0, 0, 0, /* F5 - C */
0, CCPAD_L, 0, CCPAD_R,
0, 0, 0,
0,0,0, 0,0,0,0,
0,0,0, 0,0,0, 0,0,0, /* Hotbar slots */
CCPAD_ZL, CCPAD_ZR
};
const cc_uint8 KeyBind_Defaults[BIND_COUNT] = {
'W', 'S', 'A', 'D',
CCKEY_SPACE, 'R', CCKEY_ENTER, 'T',
'B', 'F', CCKEY_ENTER, CCKEY_TAB,
CCKEY_LSHIFT, 'X', 'Z', 'Q', 'E',
CCKEY_LALT, CCKEY_F3, CCKEY_F12, CCKEY_F11,
CCKEY_F5, CCKEY_F1, CCKEY_F7, 'C',
CCKEY_LCTRL, CCMOUSE_L, CCMOUSE_M, CCMOUSE_R,
CCKEY_F6, CCKEY_LALT, CCKEY_F8,
'G', CCKEY_F10, 0,
0, 0, 0, 0,
'1','2','3', '4','5','6', '7','8','9',
0, 0
const BindMapping PadBind_Defaults[BIND_COUNT] = {
{ CCPAD_UP, 0 }, { CCPAD_DOWN, 0 }, /* BIND_FORWARD, BIND_BACK */
{ CCPAD_LEFT, 0 }, { CCPAD_RIGHT, 0 }, /* BIND_LEFT, BIND_RIGHT */
{ CCPAD_A, 0 }, { 0, 0 }, /* BIND_JUMP, BIND_RESPAWN */
{ CCPAD_START, 0 }, { CCPAD_Y, 0 }, /* BIND_SET_SPAWN, BIND_CHAT */
{ CCPAD_X, 0 }, { 0, 0 }, /* BIND_INVENTORY, BIND_FOG */
{ CCPAD_START, 0 }, { 0, 0 }, /* BIND_SEND_CHAT, BIND_TABLIST */
{ CCPAD_B, CCPAD_L},{ CCPAD_B, CCPAD_X},/* BIND_SPEED, BIND_NOCLIP */
{ CCPAD_B, CCPAD_R }, /* BIND_FLY */
{CCPAD_B,CCPAD_UP},{CCPAD_B,CCPAD_DOWN},/* BIND_FLY_UP, BIND_FLY_DOWN */
{ 0, 0 }, { 0, 0 }, /* BIND_EXT_INPUT, BIND_HIDE_FPS */
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, /* BIND_SCREENSHOT, BIND_FULLSCREEN, BIND_THIRD_PERSON, BIND_HIDE_GUI */
{ 0, 0 }, { 0, 0 }, { 0, 0 }, /* BIND_AXIS_LINES, BIND_ZOOM_SCROLL, BIND_HALF_SPEED */
{ CCPAD_L, 0 }, { 0, 0 },{ CCPAD_R, 0 },/* BIND_DELETE_BLOCK, BIND_PICK_BLOCK, BIND_PLACE_BLOCK */
{ 0, 0 }, { 0, 0 }, { 0, 0 }, /* BIND_AUTOROTATE, BIND_HOTBAR_SWITCH, BIND_SMOOTH_CAMERA */
{ 0, 0 }, { 0, 0 }, { 0, 0 }, /* BIND_DROP_BLOCK, BIND_IDOVERLAY, BIND_BREAK_LIQUIDS */
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, /* BIND_LOOK_UP, BIND_LOOK_DOWN, BIND_LOOK_RIGHT, BIND_LOOK_LEFT */
{ 0, 0 }, { 0, 0 }, { 0, 0 }, /* BIND_HOTBAR_1, BIND_HOTBAR_2, BIND_HOTBAR_3 */
{ 0, 0 }, { 0, 0 }, { 0, 0 }, /* BIND_HOTBAR_4, BIND_HOTBAR_5, BIND_HOTBAR_6 */
{ 0, 0 }, { 0, 0 }, { 0, 0 }, /* BIND_HOTBAR_7, BIND_HOTBAR_8, BIND_HOTBAR_9 */
{ CCPAD_ZL, 0 }, { CCPAD_ZR, 0 } /* BIND_HOTBAR_LEFT, BIND_HOTBAR_RIGHT */
};
static const char* const keybindNames[BIND_COUNT] = {
const BindMapping KeyBind_Defaults[BIND_COUNT] = {
{ 'W', 0 }, { 'S', 0 }, { 'A', 0 }, { 'D', 0 }, /* BIND_FORWARD - BIND_RIGHT */
{ CCKEY_SPACE, 0 }, { 'R', 0 }, /* BIND_JUMP, BIND_RESPAWN */
{ CCKEY_ENTER, 0 }, { 'T', 0 }, /* BIND_SET_SPAWN, BIND_CHAT */
{ 'B', 0 }, { 'F', 0 }, /* BIND_INVENTORY, BIND_FOG */
{ CCKEY_ENTER, 0 }, { CCKEY_TAB, 0 }, /* BIND_SEND_CHAT, BIND_TABLIST */
{ CCKEY_LSHIFT, 0 }, { 'X', 0}, { 'Z', 0 }, /* BIND_SPEED, BIND_NOCLIP, BIND_FLY */
{ 'Q', 0 }, { 'E', 0 }, /* BIND_FLY_UP, BIND_FLY_DOWN */
{ CCKEY_LALT, 0 }, { CCKEY_F3, 0 }, /* BIND_EXT_INPUT, BIND_HIDE_FPS */
{ CCKEY_F12, 0 }, { CCKEY_F11, 0 }, /* BIND_SCREENSHOT, BIND_FULLSCREEN */
{ CCKEY_F5, 0 }, { CCKEY_F1, 0 }, /* BIND_THIRD_PERSON, BIND_HIDE_GUI */
{ CCKEY_F7, 0 }, { 'C', 0 }, { CCKEY_LCTRL, 0 },/* BIND_AXIS_LINES, BIND_ZOOM_SCROLL, BIND_HALF_SPEED */
{ CCMOUSE_L, 0},{ CCMOUSE_M, 0},{ CCMOUSE_R, 0},/* BIND_DELETE_BLOCK, BIND_PICK_BLOCK, BIND_PLACE_BLOCK */
{ CCKEY_F6, 0 }, { CCKEY_LALT, 0 }, /* BIND_AUTOROTATE, BIND_HOTBAR_SWITCH */
{ CCKEY_F8, 0 }, { 'G', 0 }, /* BIND_SMOOTH_CAMERA, BIND_DROP_BLOCK */
{ CCKEY_F10, 0 }, { 0, 0 }, /* BIND_IDOVERLAY, BIND_BREAK_LIQUIDS */
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, /* BIND_LOOK_UP, BIND_LOOK_DOWN, BIND_LOOK_RIGHT, BIND_LOOK_LEFT */
{ '1', 0 }, { '2', 0 }, { '3', 0 }, /* BIND_HOTBAR_1, BIND_HOTBAR_2, BIND_HOTBAR_3 */
{ '4', 0 }, { '5', 0 }, { '6', 0 }, /* BIND_HOTBAR_4, BIND_HOTBAR_5, BIND_HOTBAR_6 */
{ '7', 0 }, { '8', 0 }, { '9', 0 }, /* BIND_HOTBAR_7, BIND_HOTBAR_8, BIND_HOTBAR_9 */
{ 0, 0 }, { 0, 0 } /* BIND_HOTBAR_LEFT, BIND_HOTBAR_RIGHT */
};
static const char* const bindNames[BIND_COUNT] = {
"Forward", "Back", "Left", "Right",
"Jump", "Respawn", "SetSpawn", "Chat", "Inventory",
"ToggleFog", "SendChat", "PlayerList",
@ -425,55 +443,120 @@ static const char* const keybindNames[BIND_COUNT] = {
"HotbarLeft", "HotbarRight"
};
#define BindMapping2_Claims(mapping, btn) (Input.Pressed[(mapping)->button1] && (mapping)->button2 == btn)
static cc_bool Mappings_DoesClaim(InputBind binding, int btn, BindMapping* mappings) {
BindMapping* bind = &mappings[binding];
int i;
if (bind->button2) return BindMapping2_Claims(bind, btn);
/* Two button mapping takes priority over one button mapping */
for (i = 0; i < BIND_COUNT; i++)
{
if (mappings[i].button2 && BindMapping2_Claims(&mappings[i], btn)) return false;
}
return bind->button1 == btn;
}
static cc_bool Mappings_IsPressed(InputBind binding, BindMapping* mappings) {
BindMapping* bind = &mappings[binding];
int btn = bind->button1;
int i;
if (!Input.Pressed[btn]) return false;
if (bind->button2) return Input.Pressed[bind->button2];
/* Two button mappings to the button takes priority one button mapping */
for (i = 0; i < BIND_COUNT; i++)
{
bind = &mappings[i];
if (!bind->button2) continue;
if (!(bind->button1 == btn || bind->button2 == btn)) continue;
if (Input.Pressed[bind->button1] && Input.Pressed[bind->button2]) return false;
}
return true;
}
cc_bool InputBind_Claims(InputBind binding, int btn) {
return KeyBind_Mappings[binding] == btn || PadBind_Mappings[binding] == btn;
return Mappings_DoesClaim(binding, btn, KeyBind_Mappings) ||
Mappings_DoesClaim(binding, btn, PadBind_Mappings);
}
cc_bool InputBind_IsPressed(InputBind binding) {
return Input.Pressed[KeyBind_Mappings[binding]] ||
Input.Pressed[PadBind_Mappings[binding]];
cc_bool InputBind_IsPressed(InputBind binding) {
return Mappings_IsPressed(binding, KeyBind_Mappings) ||
Mappings_IsPressed(binding, PadBind_Mappings);
}
static void KeyBind_Load(const char* prefix, cc_uint8* keybinds, const cc_uint8* defaults) {
static void KeyBind_Load(const char* prefix, BindMapping* keybinds, const BindMapping* defaults) {
cc_string name; char nameBuffer[STRING_SIZE + 1];
int mapping, i;
BindMapping mapping;
cc_string str, part1, part2;
int i;
String_InitArray_NT(name, nameBuffer);
for (i = 0; i < BIND_COUNT; i++)
{
name.length = 0;
String_Format1(&name, prefix, keybindNames[i]);
String_Format1(&name, prefix, bindNames[i]);
name.buffer[name.length] = '\0';
mapping = Options_GetEnum(name.buffer, defaults[i], storageNames, INPUT_COUNT);
if (mapping == CCKEY_ESCAPE) mapping = defaults[i];
if (!Options_UNSAFE_Get(name.buffer, &str)) {
keybinds[i] = defaults[i];
continue;
}
String_UNSAFE_Separate(&str, ',', &part1, &part2);
mapping.button1 = Utils_ParseEnum(&part1, defaults[i].button1, storageNames, INPUT_COUNT);
mapping.button2 = Utils_ParseEnum(&part2, defaults[i].button2, storageNames, INPUT_COUNT);
if (mapping.button1 == CCKEY_ESCAPE) mapping = defaults[i];
keybinds[i] = mapping;
}
}
static void InputBind_Set(InputBind binding, int key, cc_uint8* binds, const char* fmt) {
static void InputBind_Set(InputBind binding, int btn, BindMapping* binds, const char* fmt) {
cc_string name; char nameBuffer[STRING_SIZE];
cc_string value;
String_InitArray(name, nameBuffer);
String_Format1(&name, fmt, keybindNames[binding]);
value = String_FromReadonly(storageNames[key]);
String_Format1(&name, fmt, bindNames[binding]);
value = String_FromReadonly(storageNames[btn]);
Options_SetString(&name, &value);
binds[binding] = key;
BindMapping_Set(&binds[binding], btn, 0);
}
void KeyBind_Set(InputBind binding, int key) {
InputBind_Set(binding, key, KeyBind_Mappings, "key-%c");
void KeyBind_Set(InputBind binding, int btn) {
InputBind_Set(binding, btn, KeyBind_Mappings, "key-%c");
}
void PadBind_Set(InputBind binding, int key) {
InputBind_Set(binding, key, PadBind_Mappings, "pad-%c");
void PadBind_Set(InputBind binding, int btn) {
InputBind_Set(binding, btn, PadBind_Mappings, "pad-%c");
}
static void InputBind_ResetOption(InputBind binding, const char* fmt) {
cc_string name; char nameBuffer[STRING_SIZE];
String_InitArray(name, nameBuffer);
String_Format1(&name, fmt, bindNames[binding]);
Options_SetString(&name, &String_Empty);
}
void KeyBind_Reset(InputBind binding) {
InputBind_ResetOption(binding, "key-%c");
KeyBind_Mappings[binding] = KeyBind_Defaults[binding];
}
void PadBind_Reset(InputBind binding) {
InputBind_ResetOption(binding, "pad-%c");
PadBind_Mappings[binding] = PadBind_Defaults[binding];
}
/* Initialises and loads input bindings from options */
static void KeyBind_Init(void) {
KeyBind_Load("key-%c", KeyBind_Mappings, KeyBind_Defaults);
KeyBind_Load("key-%c", KeyBind_Mappings, KeyBind_Defaults);
KeyBind_Load("pad-%c", PadBind_Mappings, PadBind_Defaults);
}

23
src/Input.h
View File

@ -174,24 +174,31 @@ enum InputBind_ {
BIND_COUNT
};
typedef int InputBind;
typedef struct BindMapping_ { cc_uint8 button1, button2; } BindMapping;
#define BindMapping_Set(mapping, btn1, btn2) (mapping)->button1 = btn1; (mapping)->button2 = btn2;
/* The keyboard/mouse buttons that are bound to each input binding */
extern cc_uint8 KeyBind_Mappings[BIND_COUNT];
extern BindMapping KeyBind_Mappings[BIND_COUNT];
/* The gamepad buttons that are bound to each input binding */
extern cc_uint8 PadBind_Mappings[BIND_COUNT];
extern BindMapping PadBind_Mappings[BIND_COUNT];
/* Default keyboard/mouse button that each input binding is bound to */
extern const cc_uint8 KeyBind_Defaults[BIND_COUNT];
extern const BindMapping KeyBind_Defaults[BIND_COUNT];
/* Default gamepad button that each input binding is bound to */
extern const cc_uint8 PadBind_Defaults[BIND_COUNT];
extern const BindMapping PadBind_Defaults[BIND_COUNT];
/* Whether the given binding should be triggered in response to given input button being pressed */
CC_API cc_bool InputBind_Claims(InputBind binding, int btn);
/* Gets whether the given input binding is currently being triggered */
CC_API cc_bool InputBind_IsPressed(InputBind binding);
/* Sets the key/mouse button that the given input binding is bound to (Also updates options list) */
void KeyBind_Set(InputBind binding, int key);
/* Sets the gamepad button that the given input binding is bound to (Also updates options list) */
void PadBind_Set(InputBind binding, int key);
/* Sets the key/mouse button that the given input binding is bound to */
void KeyBind_Set(InputBind binding, int btn);
/* Sets the gamepad button that the given input binding is bound to */
void PadBind_Set(InputBind binding, int btn);
/* Resets the key/mouse button that the given input binding is bound to */
void KeyBind_Reset(InputBind binding);
/* Resets the gamepad button that the given input binding is bound to*/
void PadBind_Reset(InputBind binding);
/* Gamepad axes. Default behaviour is: */

45
src/Menus.c
View File

@ -1945,13 +1945,19 @@ static struct Widget* key_widgets[KEYBINDS_MAX_BTNS + 5];
static void KeyBindsScreen_Update(struct KeyBindsScreen* s, int i) {
cc_string text; char textBuffer[STRING_SIZE];
const cc_uint8* curBinds;
const BindMapping* curBinds;
BindMapping curBind;
String_InitArray(text, textBuffer);
curBinds = binds_gamepad ? PadBind_Mappings : KeyBind_Mappings;
curBind = curBinds[s->binds[i]];
String_Format2(&text, s->curI == i ? "> %c: %c <" : "%c: %c",
s->descs[i], Input_DisplayNames[curBinds[s->binds[i]]]);
String_Format4(&text, s->curI == i ? "> %c: %c%c%c <" : "%c: %c%c%c",
s->descs[i],
Input_DisplayNames[curBind.button1],
curBind.button2 ? " + " : "",
curBind.button2 ? Input_DisplayNames[curBind.button2] : "");
ButtonWidget_Set(&s->buttons[i], &text, &s->titleFont);
s->dirty = true;
}
@ -1969,22 +1975,35 @@ static void KeyBindsScreen_OnBindingClick(void* screen, void* widget) {
if (old >= 0) KeyBindsScreen_Update(s, old);
}
static int KeyBindsScreen_KeyDown(void* screen, int key) {
struct KeyBindsScreen* s = (struct KeyBindsScreen*)screen;
const cc_uint8* defaults;
InputBind bind;
int idx;
static void KeyBindsScreen_ResetBinding(InputBind bind) {
if (binds_gamepad) {
PadBind_Reset(bind);
} else {
KeyBind_Reset(bind);
}
}
if (s->curI == -1) return Menu_InputDown(s, key);
defaults = binds_gamepad ? PadBind_Defaults : KeyBind_Defaults;
bind = s->binds[s->curI];
if (Input_IsEscapeButton(key)) key = defaults[bind];
static void KeyBindsScreen_UpdateBinding(InputBind bind, int key) {
if (binds_gamepad) {
PadBind_Set(bind, key);
} else {
KeyBind_Set(bind, key);
}
}
static int KeyBindsScreen_KeyDown(void* screen, int key) {
struct KeyBindsScreen* s = (struct KeyBindsScreen*)screen;
InputBind bind;
int idx;
if (s->curI == -1) return Menu_InputDown(s, key);
bind = s->binds[s->curI];
if (Input_IsEscapeButton(key)) {
KeyBindsScreen_ResetBinding(bind);
} else {
KeyBindsScreen_UpdateBinding(bind, key);
}
idx = s->curI;
s->curI = -1;

2
src/Screens.c
View File

@ -1313,7 +1313,7 @@ static int ChatScreen_TextChanged(void* screen, const cc_string* str) {
static int ChatScreen_KeyDown(void* screen, int key) {
static const cc_string slash = String_FromConst("/");
struct ChatScreen* s = (struct ChatScreen*)screen;
int playerListKey = KeyBind_Mappings[BIND_TABLIST];
int playerListKey = KeyBind_Mappings[BIND_TABLIST].button1;
cc_bool handlesList = playerListKey != CCKEY_TAB || !Gui.TabAutocomplete || !s->grabsInput;
if (InputBind_Claims(BIND_TABLIST, key) && handlesList) {

28
src/Window_N64.c
View File

@ -37,22 +37,22 @@ void Window_Init(void) {
joypad_init();
// change defaults to make more sense for N64
cc_uint8* binds = (cc_uint8*)PadBind_Defaults;
binds[BIND_JUMP] = CCPAD_A;
binds[BIND_INVENTORY] = CCPAD_B;
binds[BIND_PLACE_BLOCK] = CCPAD_Z;
binds[BIND_HOTBAR_RIGHT] = CCPAD_L;
binds[BIND_DELETE_BLOCK] = CCPAD_R;
BindMapping* binds = (BindMapping*)PadBind_Defaults;
BindMapping_Set(&binds[BIND_JUMP], CCPAD_A, 0);
BindMapping_Set(&binds[BIND_INVENTORY], CCPAD_B, 0);
BindMapping_Set(&binds[BIND_PLACE_BLOCK], CCPAD_Z, 0);
BindMapping_Set(&binds[BIND_HOTBAR_RIGHT], CCPAD_L, 0);
BindMapping_Set(&binds[BIND_DELETE_BLOCK], CCPAD_R, 0);
binds[BIND_FORWARD] = CCPAD_CUP;
binds[BIND_BACK] = CCPAD_CDOWN;
binds[BIND_LEFT] = CCPAD_CLEFT;
binds[BIND_RIGHT] = CCPAD_CRIGHT;
BindMapping_Set(&binds[BIND_FORWARD], CCPAD_CUP, 0);
BindMapping_Set(&binds[BIND_BACK], CCPAD_CDOWN, 0);
BindMapping_Set(&binds[BIND_LEFT], CCPAD_CLEFT, 0);
BindMapping_Set(&binds[BIND_RIGHT], CCPAD_CRIGHT, 0);
binds[BIND_FLY_UP] = CCPAD_UP;
binds[BIND_FLY_DOWN] = CCPAD_DOWN;
binds[BIND_SPEED] = CCPAD_LEFT;
binds[BIND_FLY] = CCPAD_RIGHT;
BindMapping_Set(&binds[BIND_FLY_UP], CCPAD_UP, 0);
BindMapping_Set(&binds[BIND_FLY_DOWN], CCPAD_DOWN, 0);
BindMapping_Set(&binds[BIND_SPEED], CCPAD_LEFT, 0);
BindMapping_Set(&binds[BIND_FLY], CCPAD_RIGHT, 0);
}
void Window_Free(void) { }