ddnet/src/game/client/components/binds.cpp

490 lines
13 KiB
C++
Raw Normal View History

2010-11-20 10:37:14 +00:00
/* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
/* If you are missing that file, acquire a complete release at teeworlds.com. */
#include "binds.h"
2010-05-29 07:25:38 +00:00
#include <engine/config.h>
#include <engine/shared/config.h>
2010-05-29 07:25:38 +00:00
bool CBinds::CBindsSpecial::OnInput(IInput::CEvent Event)
{
2019-04-28 13:32:14 +00:00
// only handle F and composed F binds
if((Event.m_Key >= KEY_F1 && Event.m_Key <= KEY_F12) || (Event.m_Key >= KEY_F13 && Event.m_Key <= KEY_F24))
{
int Mask = m_pBinds->GetModifierMask(Input());
2019-04-28 13:32:14 +00:00
bool ret = false;
2020-09-04 20:48:39 +00:00
for(int Mod = 0; Mod < MODIFIER_COMBINATION_COUNT; Mod++)
2019-04-28 13:32:14 +00:00
{
if(Mask & (1 << Mod) && m_pBinds->m_aapKeyBindings[Mod][Event.m_Key])
m_pBinds->GetConsole()->ExecuteLineStroked(Event.m_Flags & IInput::FLAG_PRESS, m_pBinds->m_aapKeyBindings[Mod][Event.m_Key]);
2019-04-28 13:32:14 +00:00
ret = true;
}
return ret;
}
return false;
}
2010-05-29 07:25:38 +00:00
CBinds::CBinds()
{
2019-04-28 13:32:14 +00:00
mem_zero(m_aapKeyBindings, sizeof(m_aapKeyBindings));
2010-05-29 07:25:38 +00:00
m_SpecialBinds.m_pBinds = this;
}
2017-04-11 23:36:48 +00:00
CBinds::~CBinds()
{
for(int i = 0; i < KEY_LAST; i++)
2020-10-26 14:14:07 +00:00
for(auto &apKeyBinding : m_aapKeyBindings)
if(apKeyBinding[i])
free(apKeyBinding[i]);
2017-04-11 23:36:48 +00:00
}
2019-04-28 13:32:14 +00:00
void CBinds::Bind(int KeyID, const char *pStr, bool FreeOnly, int Modifier)
{
if(KeyID < 0 || KeyID >= KEY_LAST)
return;
2019-04-28 13:32:14 +00:00
if(FreeOnly && Get(KeyID, Modifier)[0])
2017-07-21 17:32:32 +00:00
return;
2019-04-28 13:32:14 +00:00
if(m_aapKeyBindings[Modifier][KeyID])
2017-04-12 23:47:17 +00:00
{
2019-04-28 13:32:14 +00:00
free(m_aapKeyBindings[Modifier][KeyID]);
m_aapKeyBindings[Modifier][KeyID] = 0;
2017-04-12 23:47:17 +00:00
}
2017-04-11 23:36:48 +00:00
2019-04-28 13:41:32 +00:00
// skip modifiers for +xxx binds
if(pStr[0] == '+')
Modifier = 0;
2019-04-28 13:41:32 +00:00
char aBuf[256];
2017-04-11 23:36:48 +00:00
if(!pStr[0])
{
2020-09-28 00:38:50 +00:00
str_format(aBuf, sizeof(aBuf), "unbound %s%s (%d)", GetKeyBindModifiersName(Modifier), Input()->KeyName(KeyID), KeyID);
2017-04-11 23:36:48 +00:00
}
else
2017-04-11 23:36:48 +00:00
{
int Size = str_length(pStr) + 1;
2019-04-28 13:32:14 +00:00
m_aapKeyBindings[Modifier][KeyID] = (char *)malloc(Size);
str_copy(m_aapKeyBindings[Modifier][KeyID], pStr, Size);
2020-09-04 20:48:39 +00:00
str_format(aBuf, sizeof(aBuf), "bound %s%s (%d) = %s", GetKeyBindModifiersName(Modifier), Input()->KeyName(KeyID), KeyID, m_aapKeyBindings[Modifier][KeyID]);
2017-04-11 23:36:48 +00:00
}
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "binds", aBuf);
}
2019-04-28 13:32:14 +00:00
int CBinds::GetModifierMask(IInput *i)
{
int Mask = 0;
Mask |= i->KeyIsPressed(KEY_LSHIFT) << CBinds::MODIFIER_SHIFT;
Mask |= i->KeyIsPressed(KEY_RSHIFT) << CBinds::MODIFIER_SHIFT;
Mask |= i->KeyIsPressed(KEY_LCTRL) << CBinds::MODIFIER_CTRL;
Mask |= i->KeyIsPressed(KEY_RCTRL) << CBinds::MODIFIER_CTRL;
Mask |= i->KeyIsPressed(KEY_LALT) << CBinds::MODIFIER_ALT;
if(!Mask)
return 1 << CBinds::MODIFIER_NONE;
return Mask;
}
int CBinds::GetModifierMaskOfKey(int Key)
{
switch(Key)
{
case KEY_LSHIFT:
case KEY_RSHIFT:
return 1 << CBinds::MODIFIER_SHIFT;
case KEY_LCTRL:
case KEY_RCTRL:
return 1 << CBinds::MODIFIER_CTRL;
case KEY_LALT:
return 1 << CBinds::MODIFIER_ALT;
default:
return 0;
}
}
bool CBinds::ModifierMatchesKey(int Modifier, int Key)
{
switch(Modifier)
{
case MODIFIER_SHIFT:
return Key == KEY_LSHIFT || Key == KEY_RSHIFT;
case MODIFIER_CTRL:
return Key == KEY_LCTRL || Key == KEY_RCTRL;
case MODIFIER_ALT:
return Key == KEY_LALT;
case MODIFIER_NONE:
default:
return false;
}
}
2010-05-29 07:25:38 +00:00
bool CBinds::OnInput(IInput::CEvent e)
{
2019-04-28 13:32:14 +00:00
// don't handle invalid events
if(e.m_Key <= 0 || e.m_Key >= KEY_LAST)
return false;
2019-04-28 13:32:14 +00:00
int Mask = GetModifierMask(Input());
int KeyModifierMask = GetModifierMaskOfKey(e.m_Key);
Mask &= ~KeyModifierMask;
if(!Mask)
Mask = 1 << MODIFIER_NONE;
bool ret = false;
2020-09-04 20:48:39 +00:00
for(int Mod = 1; Mod < MODIFIER_COMBINATION_COUNT; Mod++)
2019-04-28 13:32:14 +00:00
{
2020-08-30 00:01:56 +00:00
if(m_aapKeyBindings[Mod][e.m_Key] && (Mask == Mod))
2019-04-28 13:32:14 +00:00
{
if(e.m_Flags & IInput::FLAG_PRESS)
2019-04-28 13:32:14 +00:00
Console()->ExecuteLineStroked(1, m_aapKeyBindings[Mod][e.m_Key]);
if(e.m_Flags & IInput::FLAG_RELEASE)
2019-04-28 13:32:14 +00:00
Console()->ExecuteLineStroked(0, m_aapKeyBindings[Mod][e.m_Key]);
ret = true;
2019-04-28 13:32:14 +00:00
}
}
if(m_aapKeyBindings[0][e.m_Key] && !ret)
{
// When ctrl+shift are pressed (ctrl+shift binds and also the hard-coded ctrl+shift+d, ctrl+shift+g, ctrl+shift+e), ignore other +xxx binds
if(e.m_Flags & IInput::FLAG_PRESS && Mask != ((1 << MODIFIER_CTRL) | (1 << MODIFIER_SHIFT)))
Console()->ExecuteLineStroked(1, m_aapKeyBindings[0][e.m_Key]);
if(e.m_Flags & IInput::FLAG_RELEASE)
Console()->ExecuteLineStroked(0, m_aapKeyBindings[0][e.m_Key]);
ret = true;
}
return ret;
}
2010-05-29 07:25:38 +00:00
void CBinds::UnbindAll()
{
2020-10-26 14:14:07 +00:00
for(auto &apKeyBinding : m_aapKeyBindings)
2017-04-11 23:36:48 +00:00
{
2020-10-26 14:14:07 +00:00
for(auto &pKeyBinding : apKeyBinding)
2019-04-28 13:32:14 +00:00
{
2020-10-26 14:14:07 +00:00
if(pKeyBinding)
free(pKeyBinding);
pKeyBinding = 0;
2019-04-28 13:32:14 +00:00
}
2017-04-11 23:36:48 +00:00
}
}
2019-04-28 13:32:14 +00:00
const char *CBinds::Get(int KeyID, int Modifier)
{
2019-04-28 13:32:14 +00:00
if(KeyID > 0 && KeyID < KEY_LAST && m_aapKeyBindings[Modifier][KeyID])
return m_aapKeyBindings[Modifier][KeyID];
return "";
}
2019-04-28 13:32:14 +00:00
void CBinds::GetKey(const char *pBindStr, char *aBuf, unsigned BufSize)
{
2019-04-28 13:32:14 +00:00
aBuf[0] = 0;
2020-09-04 20:48:39 +00:00
for(int Mod = 0; Mod < MODIFIER_COMBINATION_COUNT; Mod++)
{
2019-04-28 13:32:14 +00:00
for(int KeyId = 0; KeyId < KEY_LAST; KeyId++)
{
const char *pBind = Get(KeyId, Mod);
if(!pBind[0])
continue;
2020-09-04 20:48:39 +00:00
if(str_comp(pBind, pBindStr) == 0)
{
2019-04-28 13:32:14 +00:00
if(Mod)
str_format(aBuf, BufSize, "%s+%s", GetModifierName(Mod), Input()->KeyName(KeyId));
else
str_format(aBuf, BufSize, "%s", Input()->KeyName(KeyId));
return;
}
}
}
}
2010-05-29 07:25:38 +00:00
void CBinds::SetDefaults()
{
// set default key bindings
2010-05-29 07:25:38 +00:00
UnbindAll();
Bind(KEY_F1, "toggle_local_console");
Bind(KEY_F2, "toggle_remote_console");
Bind(KEY_TAB, "+scoreboard");
Bind(KEY_EQUALS, "+statboard");
2010-05-29 07:25:38 +00:00
Bind(KEY_F10, "screenshot");
2017-07-21 17:32:32 +00:00
Bind(KEY_A, "+left");
Bind(KEY_D, "+right");
2010-05-29 07:25:38 +00:00
Bind(KEY_SPACE, "+jump");
Bind(KEY_MOUSE_1, "+fire");
Bind(KEY_MOUSE_2, "+hook");
Bind(KEY_LSHIFT, "+emote");
Bind(KEY_RETURN, "+show_chat; chat all");
Bind(KEY_RIGHT, "spectate_next");
Bind(KEY_LEFT, "spectate_previous");
2014-06-16 12:44:00 +00:00
Bind(KEY_RSHIFT, "+spectate");
2010-05-29 07:25:38 +00:00
2017-07-21 17:32:32 +00:00
Bind(KEY_1, "+weapon1");
Bind(KEY_2, "+weapon2");
Bind(KEY_3, "+weapon3");
Bind(KEY_4, "+weapon4");
Bind(KEY_5, "+weapon5");
2010-05-29 07:25:38 +00:00
Bind(KEY_MOUSE_WHEEL_UP, "+prevweapon");
Bind(KEY_MOUSE_WHEEL_DOWN, "+nextweapon");
2017-07-21 17:32:32 +00:00
Bind(KEY_T, "+show_chat; chat all");
Bind(KEY_Y, "+show_chat; chat team");
Bind(KEY_U, "+show_chat");
Bind(KEY_I, "+show_chat; chat all /c ");
2010-05-29 07:25:38 +00:00
Bind(KEY_F3, "vote yes");
Bind(KEY_F4, "vote no");
2017-07-21 17:32:32 +00:00
Bind(KEY_K, "kill");
Bind(KEY_Q, "say /pause");
Bind(KEY_P, "say /pause");
2013-08-18 01:33:55 +00:00
// DDRace
g_Config.m_ClDDRaceBindsSet = 0;
SetDDRaceBinds(false);
}
2010-05-29 07:25:38 +00:00
void CBinds::OnConsoleInit()
{
// bindings
IConfigManager *pConfigManager = Kernel()->RequestInterface<IConfigManager>();
if(pConfigManager)
pConfigManager->RegisterCallback(ConfigSaveCallback, this);
Console()->Register("bind", "s[key] r[command]", CFGFLAG_CLIENT, ConBind, this, "Bind key to execute the command");
2017-03-06 17:06:55 +00:00
Console()->Register("dump_binds", "?s[key]", CFGFLAG_CLIENT, ConDumpBinds, this, "Print command executed by this keybindind or all binds");
Console()->Register("unbind", "s[key]", CFGFLAG_CLIENT, ConUnbind, this, "Unbind key");
Console()->Register("unbindall", "", CFGFLAG_CLIENT, ConUnbindAll, this, "Unbind all keys");
// default bindings
2010-05-29 07:25:38 +00:00
SetDefaults();
}
void CBinds::ConBind(IConsole::IResult *pResult, void *pUserData)
{
2010-05-29 07:25:38 +00:00
CBinds *pBinds = (CBinds *)pUserData;
2019-04-28 13:32:14 +00:00
const char *pBindStr = pResult->GetString(0);
int Modifier;
int KeyID = pBinds->GetBindSlot(pBindStr, &Modifier);
2019-04-28 13:32:14 +00:00
if(!KeyID)
{
char aBuf[256];
2019-04-28 13:32:14 +00:00
str_format(aBuf, sizeof(aBuf), "key %s not found", pBindStr);
pBinds->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "binds", aBuf);
return;
}
2019-04-28 13:32:14 +00:00
pBinds->Bind(KeyID, pResult->GetString(1), false, Modifier);
}
2017-03-06 17:06:55 +00:00
void CBinds::ConDumpBinds(IConsole::IResult *pResult, void *pUserData)
2017-01-28 15:29:03 +00:00
{
CBinds *pBinds = (CBinds *)pUserData;
if(pResult->NumArguments() == 1)
2017-01-28 17:34:24 +00:00
{
2017-01-28 15:29:03 +00:00
char aBuf[256];
const char *pKeyName = pResult->GetString(0);
2017-01-28 16:02:39 +00:00
2019-04-28 13:32:14 +00:00
int Modifier;
int id = pBinds->GetBindSlot(pKeyName, &Modifier);
if(!id)
2017-01-28 16:02:39 +00:00
{
2017-03-06 17:06:55 +00:00
str_format(aBuf, sizeof(aBuf), "key '%s' not found", pKeyName);
pBinds->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "binds", aBuf);
2017-01-28 16:02:39 +00:00
}
else
2017-01-28 17:34:24 +00:00
{
if(!pBinds->m_aapKeyBindings[Modifier][id])
str_format(aBuf, sizeof(aBuf), "%s (%d) is not bound", pKeyName, id);
else
2019-04-28 13:32:14 +00:00
str_format(aBuf, sizeof(aBuf), "%s (%d) = %s", pKeyName, id, pBinds->m_aapKeyBindings[Modifier][id]);
pBinds->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "binds", aBuf);
}
}
else if(pResult->NumArguments() == 0)
{
char aBuf[1024];
2020-09-04 20:48:39 +00:00
for(int i = 0; i < MODIFIER_COMBINATION_COUNT; i++)
{
2019-04-28 13:32:14 +00:00
for(int j = 0; j < KEY_LAST; j++)
{
if(!pBinds->m_aapKeyBindings[i][j])
continue;
2020-08-30 00:01:56 +00:00
2020-09-04 20:48:39 +00:00
str_format(aBuf, sizeof(aBuf), "%s%s (%d) = %s", GetKeyBindModifiersName(i), pBinds->Input()->KeyName(j), j, pBinds->m_aapKeyBindings[i][j]);
2019-04-28 13:32:14 +00:00
pBinds->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "binds", aBuf);
}
2017-01-28 16:02:39 +00:00
}
2017-01-28 15:29:03 +00:00
}
}
void CBinds::ConUnbind(IConsole::IResult *pResult, void *pUserData)
{
2010-05-29 07:25:38 +00:00
CBinds *pBinds = (CBinds *)pUserData;
const char *pKeyName = pResult->GetString(0);
2019-04-28 13:32:14 +00:00
int Modifier;
int id = pBinds->GetBindSlot(pKeyName, &Modifier);
if(!id)
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "key %s not found", pKeyName);
pBinds->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "binds", aBuf);
return;
}
2019-04-28 13:32:14 +00:00
pBinds->Bind(id, "", false, Modifier);
}
void CBinds::ConUnbindAll(IConsole::IResult *pResult, void *pUserData)
{
2010-05-29 07:25:38 +00:00
CBinds *pBinds = (CBinds *)pUserData;
pBinds->UnbindAll();
}
int CBinds::GetKeyID(const char *pKeyName)
{
// check for numeric
2010-05-29 07:25:38 +00:00
if(pKeyName[0] == '&')
{
int i = str_toint(pKeyName + 1);
if(i > 0 && i < KEY_LAST)
return i; // numeric
}
// search for key
for(int i = 0; i < KEY_LAST; i++)
{
2010-05-29 07:25:38 +00:00
if(str_comp(pKeyName, Input()->KeyName(i)) == 0)
return i;
}
return 0;
}
2019-04-28 13:32:14 +00:00
int CBinds::GetBindSlot(const char *pBindString, int *Mod)
{
*Mod = MODIFIER_NONE;
2020-09-04 20:48:39 +00:00
char aMod[32];
aMod[0] = '\0';
2019-04-28 13:32:14 +00:00
const char *pKey = str_next_token(pBindString, "+", aMod, sizeof(aMod));
2020-08-30 00:01:56 +00:00
while(aMod[0] && *(pKey))
2019-04-28 13:32:14 +00:00
{
if(!str_comp(aMod, "shift"))
2020-08-30 00:01:56 +00:00
*Mod |= (1 << MODIFIER_SHIFT);
else if(!str_comp(aMod, "ctrl"))
2020-08-30 00:01:56 +00:00
*Mod |= (1 << MODIFIER_CTRL);
else if(!str_comp(aMod, "alt"))
2020-08-30 00:01:56 +00:00
*Mod |= (1 << MODIFIER_ALT);
2019-04-28 13:32:14 +00:00
else
return 0;
if(str_find(pKey + 1, "+"))
2020-08-30 00:01:56 +00:00
pKey = str_next_token(pKey + 1, "+", aMod, sizeof(aMod));
else
break;
}
2019-04-28 13:32:14 +00:00
return GetKeyID(*Mod == MODIFIER_NONE ? aMod : pKey + 1);
}
const char *CBinds::GetModifierName(int Modifier)
{
switch(Modifier)
{
case MODIFIER_SHIFT:
return "shift";
case MODIFIER_CTRL:
return "ctrl";
case MODIFIER_ALT:
return "alt";
case MODIFIER_NONE:
default:
return "";
}
}
2020-09-04 20:48:39 +00:00
const char *CBinds::GetKeyBindModifiersName(int Modifier)
{
static char aModifier[256];
aModifier[0] = '\0';
for(int k = 1; k < MODIFIER_COUNT; k++)
2020-09-04 20:48:39 +00:00
{
if(Modifier & (1 << k))
2020-09-04 20:48:39 +00:00
{
str_append(aModifier, GetModifierName(k), sizeof(aModifier));
str_append(aModifier, "+", sizeof(aModifier));
}
}
return aModifier;
}
void CBinds::ConfigSaveCallback(IConfigManager *pConfigManager, void *pUserData)
{
2010-05-29 07:25:38 +00:00
CBinds *pSelf = (CBinds *)pUserData;
2010-05-29 07:25:38 +00:00
char aBuffer[256];
char *pEnd = aBuffer + sizeof(aBuffer);
pConfigManager->WriteLine("unbindall");
2020-09-04 20:48:39 +00:00
for(int i = 0; i < MODIFIER_COMBINATION_COUNT; i++)
{
2019-04-28 13:32:14 +00:00
for(int j = 0; j < KEY_LAST; j++)
{
if(!pSelf->m_aapKeyBindings[i][j])
continue;
2020-09-04 20:48:39 +00:00
str_format(aBuffer, sizeof(aBuffer), "bind %s%s \"", GetKeyBindModifiersName(i), pSelf->Input()->KeyName(j));
2019-04-28 13:32:14 +00:00
// process the string. we need to escape some characters
char *pDst = aBuffer + str_length(aBuffer);
str_escape(&pDst, pSelf->m_aapKeyBindings[i][j], pEnd);
str_append(aBuffer, "\"", sizeof(aBuffer));
pConfigManager->WriteLine(aBuffer);
2019-04-28 13:32:14 +00:00
}
}
}
2011-04-17 17:14:49 +00:00
// DDRace
void CBinds::SetDDRaceBinds(bool FreeOnly)
{
if(g_Config.m_ClDDRaceBindsSet < 1)
{
Bind(KEY_KP_PLUS, "zoom+", FreeOnly);
Bind(KEY_KP_MINUS, "zoom-", FreeOnly);
Bind(KEY_KP_MULTIPLY, "zoom", FreeOnly);
Bind(KEY_PAUSE, "say /pause", FreeOnly);
Bind(KEY_UP, "+jump", FreeOnly);
Bind(KEY_LEFT, "+left", FreeOnly);
Bind(KEY_RIGHT, "+right", FreeOnly);
Bind(KEY_LEFTBRACKET, "+prevweapon", FreeOnly);
Bind(KEY_RIGHTBRACKET, "+nextweapon", FreeOnly);
Bind(KEY_C, "say /rank", FreeOnly);
Bind(KEY_V, "say /info", FreeOnly);
Bind(KEY_B, "say /top5", FreeOnly);
Bind(KEY_S, "+showhookcoll", FreeOnly);
Bind(KEY_X, "toggle cl_dummy 0 1", FreeOnly);
Bind(KEY_H, "toggle cl_dummy_hammer 0 1", FreeOnly);
Bind(KEY_UP, "bind mouse1 \"+fire; +toggle cl_dummy_hammer 1 0\"", FreeOnly);
Bind(KEY_DOWN, "bind mouse1 \"+fire\"", FreeOnly);
Bind(KEY_SLASH, "+show_chat; chat all /", FreeOnly);
Bind(KEY_PAGEDOWN, "toggle cl_show_quads 0 1", FreeOnly);
Bind(KEY_PAGEUP, "toggle cl_overlay_entities 0 100", FreeOnly);
Bind(KEY_KP_0, "say /emote normal 999999", FreeOnly);
Bind(KEY_KP_1, "say /emote happy 999999", FreeOnly);
Bind(KEY_KP_2, "say /emote angry 999999", FreeOnly);
Bind(KEY_KP_3, "say /emote pain 999999", FreeOnly);
Bind(KEY_KP_4, "say /emote surprise 999999", FreeOnly);
Bind(KEY_KP_5, "say /emote blink 999999", FreeOnly);
Bind(KEY_MOUSE_3, "+spectate", FreeOnly);
Bind(KEY_MINUS, "spectate_previous", FreeOnly);
Bind(KEY_EQUALS, "spectate_next", FreeOnly);
}
2020-09-07 13:40:20 +00:00
g_Config.m_ClDDRaceBindsSet = 1;
2013-08-18 01:33:55 +00:00
}