#include "predictionsystem.h"

float m_flOldCurtime;
float m_flOldFrametime;

void PredictionSystem::StartPrediction(CUserCmd* cmd)
{
C_BasePlayer* localplayer = (C_BasePlayer*) entityList->GetClientEntity(engine->GetLocalPlayer());

*nPredictionRandomSeed = MD5_PseudoRandom(cmd->command_number) & 0x7FFFFFFF;

m_flOldCurtime = globalVars->curtime;
m_flOldFrametime = globalVars->frametime;

globalVars->curtime = localplayer->GetTickBase() * globalVars->interval_per_tick;
globalVars->frametime = globalVars->interval_per_tick;

gameMovement->StartTrackPredictionErrors(localplayer);

moveHelper->SetHost(localplayer);
prediction->SetupMove(localplayer, cmd, moveHelper, g_MoveData);
gameMovement->ProcessMovement(localplayer, g_MoveData);
prediction->FinishMove(localplayer, cmd, g_MoveData);
}

void PredictionSystem::EndPrediction()
{
C_BasePlayer* localplayer = (C_BasePlayer*) entityList->GetClientEntity(engine->GetLocalPlayer());

gameMovement->FinishTrackPredictionErrors(localplayer);
moveHelper->SetHost(0);

*nPredictionRandomSeed = -1;

globalVars->curtime = m_flOldCurtime;
globalVars->frametime = m_flOldFrametime;
}
--------------------------------------------------------------------------------------------------------------------------------------------------
#include "fakelag.h"

bool Settings::FakeLag::enabled = false;
int Settings::FakeLag::value = 9;
bool Settings::FakeLag::adaptive = false;

static int ticks = 0;
int ticksMax = 16;

void FakeLag::CreateMove(CUserCmd* cmd)
{
if (!Settings::FakeLag::enabled)
return;

C_BasePlayer* localplayer = (C_BasePlayer*) entityList->GetClientEntity(engine->GetLocalPlayer());
if (!localplayer || !localplayer->GetAlive())
return;

if (localplayer->GetFlags() & FL_ONGROUND && Settings::FakeLag::adaptive)
return;

if (cmd->buttons & IN_ATTACK)
{
CreateMove::sendPacket = true;
return;
}
--------------------------------------------------------------------------------------------------------------------------------------------------
#include "aimbot.h"
#include "autowall.h"
#include "../interfaces.h"
#include <math.h>

// Default aimbot settings
bool Settings::Aimbot::enabled = false;
bool Settings::Aimbot::silent = false;
bool Settings::Aimbot::friendly = false;
Bone Settings::Aimbot::bone = Bone::BONE_HEAD;
ButtonCode_t Settings::Aimbot::aimkey = ButtonCode_t::MOUSE_MIDDLE;
bool Settings::Aimbot::aimkeyOnly = false;
bool Settings::Aimbot::Smooth::enabled = false;
float Settings::Aimbot::Smooth::value = 0.5f;
SmoothType Settings::Aimbot::Smooth::type = SmoothType::SLOW_END;
bool Settings::Aimbot::ErrorMargin::enabled = false;
float Settings::Aimbot::ErrorMargin::value = 0.0f;
bool Settings::Aimbot::AutoAim::enabled = false;
float Settings::Aimbot::AutoAim::fov = 180.0f;
bool Settings::Aimbot::AutoAim::realDistance = false;
bool Settings::Aimbot::AutoWall::enabled = false;
float Settings::Aimbot::AutoWall::value = 10.0f;
bool Settings::Aimbot::AutoWall::bones[] = { true, false, false, false, false, false };
bool Settings::Aimbot::AimStep::enabled = false;
float Settings::Aimbot::AimStep::value = 25.0f;
bool Settings::Aimbot::AutoPistol::enabled = false;
bool Settings::Aimbot::AutoShoot::enabled = false;
bool Settings::Aimbot::AutoShoot::autoscope = false;
bool Settings::Aimbot::RCS::enabled = false;
bool Settings::Aimbot::RCS::always_on = false;
float Settings::Aimbot::RCS::valueX = 2.0f;
float Settings::Aimbot::RCS::valueY = 2.0f;
bool Settings::Aimbot::AutoCrouch::enabled = false;
bool Settings::Aimbot::NoShoot::enabled = false;
bool Settings::Aimbot::IgnoreJump::enabled = false;
bool Settings::Aimbot::SmokeCheck::enabled = false;
bool Settings::Aimbot::FlashCheck::enabled = false;
bool Settings::Aimbot::Smooth::Salting::enabled = false;
float Settings::Aimbot::Smooth::Salting::multiplier = 0.0f;
bool Settings::Aimbot::AutoSlow::enabled = false;
float Settings::Aimbot::AutoSlow::minDamage = 5.0f;
bool Settings::Aimbot::Prediction::enabled = false;

bool Aimbot::aimStepInProgress = false;
std::vector<int64_t> Aimbot::friends = { };

bool shouldAim;
QAngle AimStepLastAngle;
QAngle RCSLastPunch;

std::unordered_map<Hitbox, std::vector<const char*>, Util::IntHash<Hitbox>> hitboxes = {
{ Hitbox::HITBOX_HEAD, { "head_0" } },
{ Hitbox::HITBOX_NECK, { "neck_0" } },
{ Hitbox::HITBOX_PELVIS, { "pelvis" } },
{ Hitbox::HITBOX_SPINE, { "spine_0", "spine_1", "spine_2", "spine_3" } },
{ Hitbox::HITBOX_LEGS, { "leg_upper_L", "leg_upper_R", "leg_lower_L", "leg_lower_R", "ankle_L", "ankle_R" } },
{ Hitbox::HITBOX_ARMS, { "hand_L", "hand_R", "arm_upper_L", "arm_lower_L", "arm_upper_R", "arm_lower_R" } },
};

std::unordered_map<ItemDefinitionIndex, AimbotWeapon_t, Util::IntHash<ItemDefinitionIndex>> Settings::Aimbot::weapons = {
{ ItemDefinitionIndex::INVALID, { false, false, false, Bone::BONE_HEAD, ButtonCode_t::MOUSE_MIDDLE, false, false, 1.0f, SmoothType::SLOW_END, false, 0.0f, false, 0.0f, true, 180.0f, false, 25.0f, false, false, 2.0f, 2.0f, false, false, false, false, false, false, false, false, 10.0f, false, false, false, 5.0f } },
};

static const char* targets[] = { "pelvis", "", "", "spine_0", "spine_1", "spine_2", "spine_3", "neck_0", "head_0" };

static void ApplyErrorToAngle(QAngle* angles, float margin)
{
QAngle error;
error.Random(-1.0f, 1.0f);
error *= margin;
angles->operator+=(error);
}

void GetBestBone(C_BasePlayer* player, float& bestDamage, Bone& bestBone)
{
bestBone = Bone::BONE_HEAD;

for (std::unordered_map<Hitbox, std::vector<const char*>, Util::IntHash<Hitbox>>::iterator it = hitboxes.begin(); it != hitboxes.end(); it++)
{
if (!Settings::Aimbot::AutoWall::bones[(int) it->first])
continue;

std::vector<const char*> hitboxList = hitboxes[it->first];
for (std::vector<const char*>::iterator it2 = hitboxList.begin(); it2 != hitboxList.end(); it2++)
{
Bone bone = Entity::GetBoneByName(player, *it2);
Vector vecBone = player->GetBonePosition((int) bone);

Autowall::FireBulletData data;
float damage = Autowall::GetDamage(vecBone, !Settings::Aimbot::friendly, data);

if (damage > bestDamage)
{
bestDamage = damage;
bestBone = bone;
}
}
}
}

float GetRealDistanceFOV(float distance, QAngle angle, CUserCmd* cmd)
{
/* n
w + e
s 'real distance'
|
a point -> x --.. v
| ''-- x <- a guy
| /
| /
| /
| <------------ both of these lines are the same length
| / /
| / <-----'
| /
o
localplayer
*/

Vector aimingAt;
Math::AngleVectors(cmd->viewangles, aimingAt);
aimingAt *= distance;

Vector aimAt;
Math::AngleVectors(angle, aimAt);
aimAt *= distance;

return aimingAt.DistTo(aimAt);
}

Vector VelocityExtrapolate(C_BasePlayer* player, Vector aimPos)
{
return aimPos + (player->GetVelocity() * globalVars->interval_per_tick);
}

C_BasePlayer* GetClosestPlayer(CUserCmd* cmd, bool visible, Bone& bestBone, float& bestDamage, AimTargetType aimTargetType = AimTargetType::FOV)
{
if (Settings::Aimbot::AutoAim::realDistance)
aimTargetType = AimTargetType::REAL_DISTANCE;

bestBone = static_cast<Bone>(Settings::Aimbot::bone);

C_BasePlayer* localplayer = (C_BasePlayer*) entityList->GetClientEntity(engine->GetLocalPlayer());
C_BasePlayer* closestEntity = NULL;

// TODO Change the big value with a distance/fov slider
float bestFov = Settings::Aimbot::AutoAim::fov;
float bestRealDistance = Settings::Aimbot::AutoAim::fov * 5.f;
float bestDistance = 999999999.0f;
int bestHp = 100;

if (!localplayer)
return NULL;

for (int i = 1; i < engine->GetMaxClients(); ++i)
{
C_BasePlayer* player = (C_BasePlayer*) entityList->Get