ddnet/src/game/client/components/controls.cpp
Chairn a69dc599a9 Huge variable naming format
Fix pointer and pointer array variable naming

Huge renaming to match our rules

Used regex: (?!(return|delete)\b)\b\w+ (m_|ms_|g_|gs_|s_)[^a]\w+\[
            (?!(return|delete)\b)\b\w+ (?!(m_|ms_|g_|gs_|s_))[^a]\w+\[

Further format static variables

Format almost all pointer names accordingly

Used regex: (?!(return)\b)\b\w+
\*(?!(m_p|p|s_p|m_ap|s_ap|g_p|g_ap|ap|gs_ap|ms_ap|gs_p|ms_p))\w+\b[^:\(p]

clang-format

Fix CI fail

Fix misnamed non pointer as pointer and non array as array

Used regex: (?!(return|delete)\b)\b\w+ (m_|ms_|g_|gs_|s_)p\w+\b
            (?!return\b)\b\w+ (ms_|m_|g_|gs_|s_)a\w+\b[^\[]

clang-format

Revert to SCREAMING_SNAKE_CASE and reinstate dead code
2022-07-08 18:01:29 +02:00

447 lines
16 KiB
C++

/* (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 <base/math.h>
#include <engine/shared/config.h>
#include <game/client/components/camera.h>
#include <game/client/components/chat.h>
#include <game/client/components/menus.h>
#include <game/client/components/scoreboard.h>
#include <game/client/gameclient.h>
#include <game/collision.h>
#include <base/vmath.h>
#include "controls.h"
CControls::CControls()
{
mem_zero(&m_aLastData, sizeof(m_aLastData));
m_LastDummy = 0;
m_OtherFire = 0;
}
void CControls::OnReset()
{
ResetInput(0);
ResetInput(1);
for(int &AmmoCount : m_aAmmoCount)
AmmoCount = 0;
m_OldMouseX = m_OldMouseY = 0.0f;
}
void CControls::ResetInput(int Dummy)
{
m_aLastData[Dummy].m_Direction = 0;
//m_aLastData[Dummy].m_Hook = 0;
// simulate releasing the fire button
if((m_aLastData[Dummy].m_Fire & 1) != 0)
m_aLastData[Dummy].m_Fire++;
m_aLastData[Dummy].m_Fire &= INPUT_STATE_MASK;
m_aLastData[Dummy].m_Jump = 0;
m_aInputData[Dummy] = m_aLastData[Dummy];
m_aInputDirectionLeft[Dummy] = 0;
m_aInputDirectionRight[Dummy] = 0;
}
void CControls::OnRelease()
{
//OnReset();
}
void CControls::OnPlayerDeath()
{
for(int &AmmoCount : m_aAmmoCount)
AmmoCount = 0;
}
struct CInputState
{
CControls *m_pControls;
int *m_pVariable1;
int *m_pVariable2;
};
static void ConKeyInputState(IConsole::IResult *pResult, void *pUserData)
{
CInputState *pState = (CInputState *)pUserData;
if(pState->m_pControls->GameClient()->m_GameInfo.m_BugDDRaceInput && pState->m_pControls->GameClient()->m_Snap.m_SpecInfo.m_Active)
return;
if(g_Config.m_ClDummy)
*pState->m_pVariable2 = pResult->GetInteger(0);
else
*pState->m_pVariable1 = pResult->GetInteger(0);
}
static void ConKeyInputCounter(IConsole::IResult *pResult, void *pUserData)
{
CInputState *pState = (CInputState *)pUserData;
if(pState->m_pControls->GameClient()->m_GameInfo.m_BugDDRaceInput && pState->m_pControls->GameClient()->m_Snap.m_SpecInfo.m_Active)
return;
int *v;
if(g_Config.m_ClDummy)
v = pState->m_pVariable2;
else
v = pState->m_pVariable1;
if(((*v) & 1) != pResult->GetInteger(0))
(*v)++;
*v &= INPUT_STATE_MASK;
}
struct CInputSet
{
CControls *m_pControls;
int *m_pVariable1;
int *m_pVariable2;
int m_Value;
};
static void ConKeyInputSet(IConsole::IResult *pResult, void *pUserData)
{
CInputSet *pSet = (CInputSet *)pUserData;
if(pResult->GetInteger(0))
{
if(g_Config.m_ClDummy)
*pSet->m_pVariable2 = pSet->m_Value;
else
*pSet->m_pVariable1 = pSet->m_Value;
}
}
static void ConKeyInputNextPrevWeapon(IConsole::IResult *pResult, void *pUserData)
{
CInputSet *pSet = (CInputSet *)pUserData;
ConKeyInputCounter(pResult, pSet);
pSet->m_pControls->m_aInputData[g_Config.m_ClDummy].m_WantedWeapon = 0;
}
void CControls::OnConsoleInit()
{
// game commands
{
static CInputState s_State = {this, &m_aInputDirectionLeft[0], &m_aInputDirectionLeft[1]};
Console()->Register("+left", "", CFGFLAG_CLIENT, ConKeyInputState, (void *)&s_State, "Move left");
}
{
static CInputState s_State = {this, &m_aInputDirectionRight[0], &m_aInputDirectionRight[1]};
Console()->Register("+right", "", CFGFLAG_CLIENT, ConKeyInputState, (void *)&s_State, "Move right");
}
{
static CInputState s_State = {this, &m_aInputData[0].m_Jump, &m_aInputData[1].m_Jump};
Console()->Register("+jump", "", CFGFLAG_CLIENT, ConKeyInputState, (void *)&s_State, "Jump");
}
{
static CInputState s_State = {this, &m_aInputData[0].m_Hook, &m_aInputData[1].m_Hook};
Console()->Register("+hook", "", CFGFLAG_CLIENT, ConKeyInputState, (void *)&s_State, "Hook");
}
{
static CInputState s_State = {this, &m_aInputData[0].m_Fire, &m_aInputData[1].m_Fire};
Console()->Register("+fire", "", CFGFLAG_CLIENT, ConKeyInputCounter, (void *)&s_State, "Fire");
}
{
static CInputState s_State = {this, &m_aShowHookColl[0], &m_aShowHookColl[1]};
Console()->Register("+showhookcoll", "", CFGFLAG_CLIENT, ConKeyInputState, (void *)&s_State, "Show Hook Collision");
}
{
static CInputSet s_Set = {this, &m_aInputData[0].m_WantedWeapon, &m_aInputData[1].m_WantedWeapon, 1};
Console()->Register("+weapon1", "", CFGFLAG_CLIENT, ConKeyInputSet, (void *)&s_Set, "Switch to hammer");
}
{
static CInputSet s_Set = {this, &m_aInputData[0].m_WantedWeapon, &m_aInputData[1].m_WantedWeapon, 2};
Console()->Register("+weapon2", "", CFGFLAG_CLIENT, ConKeyInputSet, (void *)&s_Set, "Switch to gun");
}
{
static CInputSet s_Set = {this, &m_aInputData[0].m_WantedWeapon, &m_aInputData[1].m_WantedWeapon, 3};
Console()->Register("+weapon3", "", CFGFLAG_CLIENT, ConKeyInputSet, (void *)&s_Set, "Switch to shotgun");
}
{
static CInputSet s_Set = {this, &m_aInputData[0].m_WantedWeapon, &m_aInputData[1].m_WantedWeapon, 4};
Console()->Register("+weapon4", "", CFGFLAG_CLIENT, ConKeyInputSet, (void *)&s_Set, "Switch to grenade");
}
{
static CInputSet s_Set = {this, &m_aInputData[0].m_WantedWeapon, &m_aInputData[1].m_WantedWeapon, 5};
Console()->Register("+weapon5", "", CFGFLAG_CLIENT, ConKeyInputSet, (void *)&s_Set, "Switch to laser");
}
{
static CInputSet s_Set = {this, &m_aInputData[0].m_NextWeapon, &m_aInputData[1].m_NextWeapon, 0};
Console()->Register("+nextweapon", "", CFGFLAG_CLIENT, ConKeyInputNextPrevWeapon, (void *)&s_Set, "Switch to next weapon");
}
{
static CInputSet s_Set = {this, &m_aInputData[0].m_PrevWeapon, &m_aInputData[1].m_PrevWeapon, 0};
Console()->Register("+prevweapon", "", CFGFLAG_CLIENT, ConKeyInputNextPrevWeapon, (void *)&s_Set, "Switch to previous weapon");
}
}
void CControls::OnMessage(int Msg, void *pRawMsg)
{
if(Msg == NETMSGTYPE_SV_WEAPONPICKUP)
{
CNetMsg_Sv_WeaponPickup *pMsg = (CNetMsg_Sv_WeaponPickup *)pRawMsg;
if(g_Config.m_ClAutoswitchWeapons)
m_aInputData[g_Config.m_ClDummy].m_WantedWeapon = pMsg->m_Weapon + 1;
// We don't really know ammo count, until we'll switch to that weapon, but any non-zero count will suffice here
m_aAmmoCount[pMsg->m_Weapon % NUM_WEAPONS] = 10;
}
}
int CControls::SnapInput(int *pData)
{
static int64_t LastSendTime = 0;
bool Send = false;
// update player state
if(m_pClient->m_Chat.IsActive())
m_aInputData[g_Config.m_ClDummy].m_PlayerFlags = PLAYERFLAG_CHATTING;
else if(m_pClient->m_Menus.IsActive())
m_aInputData[g_Config.m_ClDummy].m_PlayerFlags = PLAYERFLAG_IN_MENU;
else
m_aInputData[g_Config.m_ClDummy].m_PlayerFlags = PLAYERFLAG_PLAYING;
if(m_pClient->m_Scoreboard.Active())
m_aInputData[g_Config.m_ClDummy].m_PlayerFlags |= PLAYERFLAG_SCOREBOARD;
if(m_pClient->m_Controls.m_aShowHookColl[g_Config.m_ClDummy])
m_aInputData[g_Config.m_ClDummy].m_PlayerFlags |= PLAYERFLAG_AIM;
if(m_aLastData[g_Config.m_ClDummy].m_PlayerFlags != m_aInputData[g_Config.m_ClDummy].m_PlayerFlags)
Send = true;
m_aLastData[g_Config.m_ClDummy].m_PlayerFlags = m_aInputData[g_Config.m_ClDummy].m_PlayerFlags;
// we freeze the input if chat or menu is activated
if(!(m_aInputData[g_Config.m_ClDummy].m_PlayerFlags & PLAYERFLAG_PLAYING))
{
if(!GameClient()->m_GameInfo.m_BugDDRaceInput)
ResetInput(g_Config.m_ClDummy);
mem_copy(pData, &m_aInputData[g_Config.m_ClDummy], sizeof(m_aInputData[0]));
// set the target anyway though so that we can keep seeing our surroundings,
// even if chat or menu are activated
m_aInputData[g_Config.m_ClDummy].m_TargetX = (int)m_aMousePos[g_Config.m_ClDummy].x;
m_aInputData[g_Config.m_ClDummy].m_TargetY = (int)m_aMousePos[g_Config.m_ClDummy].y;
// send once a second just to be sure
if(time_get() > LastSendTime + time_freq())
Send = true;
}
else
{
m_aInputData[g_Config.m_ClDummy].m_TargetX = (int)m_aMousePos[g_Config.m_ClDummy].x;
m_aInputData[g_Config.m_ClDummy].m_TargetY = (int)m_aMousePos[g_Config.m_ClDummy].y;
if(!m_aInputData[g_Config.m_ClDummy].m_TargetX && !m_aInputData[g_Config.m_ClDummy].m_TargetY)
{
m_aInputData[g_Config.m_ClDummy].m_TargetX = 1;
m_aMousePos[g_Config.m_ClDummy].x = 1;
}
// set direction
m_aInputData[g_Config.m_ClDummy].m_Direction = 0;
if(m_aInputDirectionLeft[g_Config.m_ClDummy] && !m_aInputDirectionRight[g_Config.m_ClDummy])
m_aInputData[g_Config.m_ClDummy].m_Direction = -1;
if(!m_aInputDirectionLeft[g_Config.m_ClDummy] && m_aInputDirectionRight[g_Config.m_ClDummy])
m_aInputData[g_Config.m_ClDummy].m_Direction = 1;
// dummy copy moves
if(g_Config.m_ClDummyCopyMoves)
{
CNetObj_PlayerInput *pDummyInput = &m_pClient->m_DummyInput;
pDummyInput->m_Direction = m_aInputData[g_Config.m_ClDummy].m_Direction;
pDummyInput->m_Hook = m_aInputData[g_Config.m_ClDummy].m_Hook;
pDummyInput->m_Jump = m_aInputData[g_Config.m_ClDummy].m_Jump;
pDummyInput->m_PlayerFlags = m_aInputData[g_Config.m_ClDummy].m_PlayerFlags;
pDummyInput->m_TargetX = m_aInputData[g_Config.m_ClDummy].m_TargetX;
pDummyInput->m_TargetY = m_aInputData[g_Config.m_ClDummy].m_TargetY;
pDummyInput->m_WantedWeapon = m_aInputData[g_Config.m_ClDummy].m_WantedWeapon;
pDummyInput->m_Fire += m_aInputData[g_Config.m_ClDummy].m_Fire - m_aLastData[g_Config.m_ClDummy].m_Fire;
pDummyInput->m_NextWeapon += m_aInputData[g_Config.m_ClDummy].m_NextWeapon - m_aLastData[g_Config.m_ClDummy].m_NextWeapon;
pDummyInput->m_PrevWeapon += m_aInputData[g_Config.m_ClDummy].m_PrevWeapon - m_aLastData[g_Config.m_ClDummy].m_PrevWeapon;
m_aInputData[!g_Config.m_ClDummy] = *pDummyInput;
}
if(g_Config.m_ClDummyControl)
{
CNetObj_PlayerInput *pDummyInput = &m_pClient->m_DummyInput;
pDummyInput->m_Jump = g_Config.m_ClDummyJump;
pDummyInput->m_Fire = g_Config.m_ClDummyFire;
pDummyInput->m_Hook = g_Config.m_ClDummyHook;
}
// stress testing
#ifdef CONF_DEBUG
if(g_Config.m_DbgStress)
{
float t = Client()->LocalTime();
mem_zero(&m_aInputData[g_Config.m_ClDummy], sizeof(m_aInputData[0]));
m_aInputData[g_Config.m_ClDummy].m_Direction = ((int)t / 2) & 1;
m_aInputData[g_Config.m_ClDummy].m_Jump = ((int)t);
m_aInputData[g_Config.m_ClDummy].m_Fire = ((int)(t * 10));
m_aInputData[g_Config.m_ClDummy].m_Hook = ((int)(t * 2)) & 1;
m_aInputData[g_Config.m_ClDummy].m_WantedWeapon = ((int)t) % NUM_WEAPONS;
m_aInputData[g_Config.m_ClDummy].m_TargetX = (int)(sinf(t * 3) * 100.0f);
m_aInputData[g_Config.m_ClDummy].m_TargetY = (int)(cosf(t * 3) * 100.0f);
}
#endif
// check if we need to send input
if(m_aInputData[g_Config.m_ClDummy].m_Direction != m_aLastData[g_Config.m_ClDummy].m_Direction)
Send = true;
else if(m_aInputData[g_Config.m_ClDummy].m_Jump != m_aLastData[g_Config.m_ClDummy].m_Jump)
Send = true;
else if(m_aInputData[g_Config.m_ClDummy].m_Fire != m_aLastData[g_Config.m_ClDummy].m_Fire)
Send = true;
else if(m_aInputData[g_Config.m_ClDummy].m_Hook != m_aLastData[g_Config.m_ClDummy].m_Hook)
Send = true;
else if(m_aInputData[g_Config.m_ClDummy].m_WantedWeapon != m_aLastData[g_Config.m_ClDummy].m_WantedWeapon)
Send = true;
else if(m_aInputData[g_Config.m_ClDummy].m_NextWeapon != m_aLastData[g_Config.m_ClDummy].m_NextWeapon)
Send = true;
else if(m_aInputData[g_Config.m_ClDummy].m_PrevWeapon != m_aLastData[g_Config.m_ClDummy].m_PrevWeapon)
Send = true;
// send at at least 10hz
if(time_get() > LastSendTime + time_freq() / 25)
Send = true;
if(m_pClient->m_Snap.m_pLocalCharacter && m_pClient->m_Snap.m_pLocalCharacter->m_Weapon == WEAPON_NINJA && (m_aInputData[g_Config.m_ClDummy].m_Direction || m_aInputData[g_Config.m_ClDummy].m_Jump || m_aInputData[g_Config.m_ClDummy].m_Hook))
Send = true;
}
// copy and return size
m_aLastData[g_Config.m_ClDummy] = m_aInputData[g_Config.m_ClDummy];
if(!Send)
return 0;
LastSendTime = time_get();
mem_copy(pData, &m_aInputData[g_Config.m_ClDummy], sizeof(m_aInputData[0]));
return sizeof(m_aInputData[0]);
}
void CControls::OnRender()
{
if(g_Config.m_ClAutoswitchWeaponsOutOfAmmo && !GameClient()->m_GameInfo.m_UnlimitedAmmo && m_pClient->m_Snap.m_pLocalCharacter)
{
// Keep track of ammo count, we know weapon ammo only when we switch to that weapon, this is tracked on server and protocol does not track that
m_aAmmoCount[m_pClient->m_Snap.m_pLocalCharacter->m_Weapon % NUM_WEAPONS] = m_pClient->m_Snap.m_pLocalCharacter->m_AmmoCount;
// Autoswitch weapon if we're out of ammo
if(m_aInputData[g_Config.m_ClDummy].m_Fire % 2 != 0 &&
m_pClient->m_Snap.m_pLocalCharacter->m_AmmoCount == 0 &&
m_pClient->m_Snap.m_pLocalCharacter->m_Weapon != WEAPON_HAMMER &&
m_pClient->m_Snap.m_pLocalCharacter->m_Weapon != WEAPON_NINJA)
{
int w;
for(w = WEAPON_LASER; w > WEAPON_GUN; w--)
{
if(w == m_pClient->m_Snap.m_pLocalCharacter->m_Weapon)
continue;
if(m_aAmmoCount[w] > 0)
break;
}
if(w != m_pClient->m_Snap.m_pLocalCharacter->m_Weapon)
m_aInputData[g_Config.m_ClDummy].m_WantedWeapon = w + 1;
}
}
// update target pos
if(m_pClient->m_Snap.m_pGameInfoObj && !m_pClient->m_Snap.m_SpecInfo.m_Active)
m_aTargetPos[g_Config.m_ClDummy] = m_pClient->m_LocalCharacterPos + m_aMousePos[g_Config.m_ClDummy];
else if(m_pClient->m_Snap.m_SpecInfo.m_Active && m_pClient->m_Snap.m_SpecInfo.m_UsePosition)
m_aTargetPos[g_Config.m_ClDummy] = m_pClient->m_Snap.m_SpecInfo.m_Position + m_aMousePos[g_Config.m_ClDummy];
else
m_aTargetPos[g_Config.m_ClDummy] = m_aMousePos[g_Config.m_ClDummy];
}
bool CControls::OnCursorMove(float x, float y, IInput::ECursorType CursorType)
{
if(m_pClient->m_Snap.m_pGameInfoObj && (m_pClient->m_Snap.m_pGameInfoObj->m_GameStateFlags & GAMESTATEFLAG_PAUSED))
return false;
if(CursorType == IInput::CURSOR_JOYSTICK && g_Config.m_InpControllerAbsolute && m_pClient->m_Snap.m_pGameInfoObj && !m_pClient->m_Snap.m_SpecInfo.m_Active)
{
float AbsX = 0.0f, AbsY = 0.0f;
if(Input()->GetActiveJoystick()->Absolute(&AbsX, &AbsY))
m_aMousePos[g_Config.m_ClDummy] = vec2(AbsX, AbsY) * GetMaxMouseDistance();
return true;
}
float Factor = 1.0f;
if(g_Config.m_ClDyncam && g_Config.m_ClDyncamMousesens)
{
Factor = g_Config.m_ClDyncamMousesens / 100.0f;
}
else
{
switch(CursorType)
{
case IInput::CURSOR_MOUSE:
Factor = g_Config.m_InpMousesens / 100.0f;
break;
case IInput::CURSOR_JOYSTICK:
Factor = g_Config.m_InpControllerSens / 100.0f;
break;
default:
dbg_msg("assert", "CControls::OnCursorMove CursorType %d", (int)CursorType);
dbg_break();
break;
}
}
if(m_pClient->m_Snap.m_SpecInfo.m_Active && m_pClient->m_Snap.m_SpecInfo.m_SpectatorID < 0)
Factor *= m_pClient->m_Camera.m_Zoom;
m_aMousePos[g_Config.m_ClDummy] += vec2(x, y) * Factor;
ClampMousePos();
return true;
}
void CControls::ClampMousePos()
{
if(m_pClient->m_Snap.m_SpecInfo.m_Active && m_pClient->m_Snap.m_SpecInfo.m_SpectatorID < 0)
{
m_aMousePos[g_Config.m_ClDummy].x = clamp(m_aMousePos[g_Config.m_ClDummy].x, 0.0f, Collision()->GetWidth() * 32.0f);
m_aMousePos[g_Config.m_ClDummy].y = clamp(m_aMousePos[g_Config.m_ClDummy].y, 0.0f, Collision()->GetHeight() * 32.0f);
}
else
{
float MouseMax = GetMaxMouseDistance();
float MinDistance = g_Config.m_ClDyncam ? g_Config.m_ClDyncamMinDistance : g_Config.m_ClMouseMinDistance;
float MouseMin = MinDistance;
float MDistance = length(m_aMousePos[g_Config.m_ClDummy]);
if(MDistance < 0.001f)
{
m_aMousePos[g_Config.m_ClDummy].x = 0.001f;
m_aMousePos[g_Config.m_ClDummy].y = 0;
MDistance = 0.001f;
}
if(MDistance < MouseMin)
m_aMousePos[g_Config.m_ClDummy] = normalize_pre_length(m_aMousePos[g_Config.m_ClDummy], MDistance) * MouseMin;
MDistance = length(m_aMousePos[g_Config.m_ClDummy]);
if(MDistance > MouseMax)
m_aMousePos[g_Config.m_ClDummy] = normalize_pre_length(m_aMousePos[g_Config.m_ClDummy], MDistance) * MouseMax;
}
}
float CControls::GetMaxMouseDistance() const
{
float CameraMaxDistance = 200.0f;
float FollowFactor = (g_Config.m_ClDyncam ? g_Config.m_ClDyncamFollowFactor : g_Config.m_ClMouseFollowfactor) / 100.0f;
float DeadZone = g_Config.m_ClDyncam ? g_Config.m_ClDyncamDeadzone : g_Config.m_ClMouseDeadzone;
float MaxDistance = g_Config.m_ClDyncam ? g_Config.m_ClDyncamMaxDistance : g_Config.m_ClMouseMaxDistance;
return minimum((FollowFactor != 0 ? CameraMaxDistance / FollowFactor + DeadZone : MaxDistance), MaxDistance);
}