bool CClient::Event_CheckWalkBuffer()
{
ADDTOCALLSTACK("CClient::Event_CheckWalkBuffer");
// Check if the client is trying to walk too fast.
// Direction changes don't count.

if ( !g_Cfg.m_iWalkBuffer )
return true;
if ( (m_iWalkStepCount % 7) != 0 ) // only check when we have taken 8 steps
return true;

// Client only allows 4 steps of walk ahead.
LONGLONG CurrTime = static_cast<LONGLONG>(GetTickCount());
int iTimeDiff = static_cast<int>((CurrTime - m_timeWalkStep) / 10);
int iTimeMin = m_pChar->IsStatFlag(STATF_OnHorse|STATF_Hovering) ? 70 : 140; // minimum time to move 8 steps

if ( m_pChar->m_pPlayer && m_pChar->m_pPlayer->m_speedMode != 0 )
{
// Speed Modes:
// 0 = Foot=Normal, Mount=Normal 140 - 70
// 1 = Foot=Double Speed, Mount=Normal 70 - 70 = 70
// 2 = Foot=Always Walk, Mount=Always Walk (Half Speed) 280 - 140 = x2
// 3 = Foot=Always Run, Mount=Always Walk 140 - 140 = 70|x2 (1|2)
// 4 = No Movement N/A - N/A = (handled by OnFreezeCheck)

if ( m_pChar->m_pPlayer->m_speedMode & 0x01 )
iTimeMin = 70;
if ( m_pChar->m_pPlayer->m_speedMode & 0x02 )
iTimeMin *= 2;
}

if ( iTimeDiff > iTimeMin )
{
int iRegen = ((iTimeDiff - iTimeMin) * g_Cfg.m_iWalkRegen) / 150;
if ( iRegen > g_Cfg.m_iWalkBuffer )
iRegen = g_Cfg.m_iWalkBuffer;
else if ( iRegen < -((g_Cfg.m_iWalkBuffer * g_Cfg.m_iWalkRegen) / 100) )
iRegen = -((g_Cfg.m_iWalkBuffer * g_Cfg.m_iWalkRegen) / 100);
iTimeDiff = iTimeMin + iRegen;
}

m_iWalkTimeAvg += iTimeDiff;
int oldAvg = m_iWalkTimeAvg;
m_iWalkTimeAvg -= iTimeMin;

if ( m_iWalkTimeAvg > g_Cfg.m_iWalkBuffer )
m_iWalkTimeAvg = g_Cfg.m_iWalkBuffer;
else if ( m_iWalkTimeAvg < -g_Cfg.m_iWalkBuffer )
m_iWalkTimeAvg = -g_Cfg.m_iWalkBuffer;

if ( IsPriv(PRIV_DETAIL) && IsPriv(PRIV_DEBUG) )
SysMessagef("Walkcheck trace: %i / %i (%i) :: %i", iTimeDiff, iTimeMin, oldAvg, m_iWalkTimeAvg);

if ( m_iWalkTimeAvg < 0 && iTimeDiff >= 0 ) // TICK_PER_SEC
{
// Walking too fast.
DEBUG_WARN(("%s (%lx): Fast Walk ?\n", GetName(), GetSocketID()));
if ( IsTrigUsed(TRIGGER_USEREXWALKLIMIT) )
{
if ( m_pChar->OnTrigger(CTRIG_UserExWalkLimit, m_pChar) != TRIGRET_RET_TRUE )
return false;
}
}

m_timeWalkStep = CurrTime;
return true;
}



bool CClient::Event_Walk( BYTE rawdir, BYTE sequence ) // Player moves
{
ADDTOCALLSTACK("CClient::Event_Walk");
// The client is sending a walk request to server, so the server must check
// if the movement is possible and reply with another allow/reject packet
// Return:
// true = walking was allowed
// false = walking was rejected

// The theory....
// The client sometimes echos 1 or 2 zeros or invalid echos when you first start
// walking (the invalid non zeros happen when you log off and don't exit the
// client.exe all the way and then log back in, XXX doesn't clear the stack)

if ( !m_pChar )
return false;

DIR_TYPE dir = static_cast<DIR_TYPE>(rawdir & 0x0F);
if ( dir >= DIR_QTY )
{
new PacketMovementRej(this, sequence);
return false;
}

CPointMap pt = m_pChar->GetTopPoint();
CPointMap ptOld = pt;

if ( dir == m_pChar->m_dirFace )
{
if ( IsSetEF(EF_FastWalkPrevention) )
{
// The fastest way to get system clock is using g_World.GetCurrentTime().GetTimeRaw() to
// read the value already stored by Sphere main timer. But this value is only updated at
// tenths of second precision, which won't work here because we need milliseconds precision.
// So to get this precision we must get the system clock manually at each walk request.
INT64 iCurTime = CWorldClock::GetSystemClock();
if ( iCurTime < m_timeNextEventWalk ) // fastwalk detected
{
new PacketMovementRej(this, sequence);
return false;
}

INT64 iDelay = 0;
if ( m_pChar->IsStatFlag(STATF_OnHorse|STATF_Hovering) )
iDelay = (rawdir & 0x80) ? 70 : 170; // 100ms : 200ms
else
iDelay = (rawdir & 0x80) ? 170 : 370; // 200ms : 400ms

m_timeNextEventWalk = iCurTime + iDelay;
}
else if ( !Event_CheckWalkBuffer() )
{
new PacketMovementRej(this, sequence);
return false;
}

// Move in this dir.
pt.Move(dir);

// Check the z height here.
// The client already knows this but doesn't tell us.
if ( m_pChar->CanMoveWalkTo(pt, true, false, dir) == NULL )
{
new PacketMovementRej(this, sequence);
return false;
}

if ( !m_pChar->MoveToChar(pt) )
{
new PacketMovementRej(this, sequence);
return false;
}

// Check if I stepped on any item/teleport
TRIGRET_TYPE iRet = m_pChar->CheckLocation(false);
if ( iRet == TRIGRET_RET_FALSE )
{
m_pChar->SetUnkPoint(ptOld); // we already moved, so move back to previous location
new PacketMovementRej(this, sequence);
return false;
}

// Are we invis ?
m_pChar->CheckRevealOnMove();

// Set running flag if I'm running
m_pChar->StatFlag_Mod(STATF_Fly, (rawdir & 0x80) ? true : false);

if ( iRet == TRIGRET_RET_TRUE )
{
new PacketMovementAck(this, sequence);
m_pChar->UpdateMove(ptOld, this); // Who now sees me ?
addPlayerSee(ptOld); // What new stuff do I now see ?
}

m_timeLastEventWalk = CServTime::GetCurrentTime();
m_iWalkStepCount++; // Increase step count to use on walk buffer checks
}
else
{
// Just a change in dir.
new PacketMovementAck(this, sequence);
m_pChar->m_dirFace = dir;
m_pChar->UpdateMove(ptOld, this); // Who now sees me ?
}
return true;
}