void Aimbot::UpdateValues()
{
C_BasePlayer* localplayer = (C_BasePlayer*) entityList->GetClientEntity(engine->GetLocalPlayer());
if (!localplayer || !localplayer->GetAlive())
return;
C_BaseCombatWeapon* activeWeapon = (C_BaseCombatWeapon*) entityList->GetClientEntityFromHandle(localplayer->GetActiveWeapon());
if (!activeWeapon)
return;
ItemDefinitionIndex index = ItemDefinitionIndex::INVALID;
if (Settings::Aimbot::weapons.find(*activeWeapon->GetItemDefinitionIndex()) != Settings::Aimbot::weapons.end())
index = *activeWeapon->GetItemDefinitionIndex();
const AimbotWeapon_t& currentWeaponSetting = Settings::Aimbot::weapons.at(index);
Settings::Aimbot::enabled = currentWeaponSetting.enabled;
Settings::Aimbot::silent = currentWeaponSetting.silent;
Settings::Aimbot::friendly = currentWeaponSetting.friendly;
Settings::Aimbot::bone = currentWeaponSetting.bone;
Settings::Aimbot::aimkey = currentWeaponSetting.aimkey;
Settings::Aimbot::aimkeyOnly = currentWeaponSetting.aimkeyOnly;
Settings::Aimbot::Smooth::enabled = currentWeaponSetting.smoothEnabled;
Settings::Aimbot::Smooth::value = currentWeaponSetting.smoothAmount;
Settings::Aimbot::Smooth::type = currentWeaponSetting.smoothType;
Settings::Aimbot::ErrorMargin::enabled = currentWeaponSetting.errorMarginEnabled;
Settings::Aimbot::ErrorMargin::value = currentWeaponSetting.errorMarginValue;
Settings::Aimbot::AutoAim::enabled = currentWeaponSetting.autoAimEnabled;
Settings::Aimbot::AutoAim::fov = currentWeaponSetting.autoAimFov;
Settings::Aimbot::AimStep::enabled = currentWeaponSetting.aimStepEnabled;
Settings::Aimbot::AimStep::value = currentWeaponSetting.aimStepValue;
Settings::Aimbot::AutoPistol::enabled = currentWeaponSetting.autoPistolEnabled;
Settings::Aimbot::AutoShoot::enabled = currentWeaponSetting.autoShootEnabled;
Settings::Aimbot::AutoShoot::autoscope = currentWeaponSetting.autoScopeEnabled;
Settings::Aimbot::RCS::enabled = currentWeaponSetting.rcsEnabled;
Settings::Aimbot::RCS::always_on = currentWeaponSetting.rcsAlwaysOn;
Settings::Aimbot::RCS::valueX = currentWeaponSetting.rcsAmountX;
Settings::Aimbot::RCS::valueY = currentWeaponSetting.rcsAmountY;
Settings::Aimbot::NoShoot::enabled = currentWeaponSetting.noShootEnabled;
Settings::Aimbot::IgnoreJump::enabled = currentWeaponSetting.ignoreJumpEnabled;
Settings::Aimbot::Smooth::Salting::enabled = currentWeaponSetting.smoothSaltEnabled;
Settings::Aimbot::Smooth::Salting::multiplier = currentWeaponSetting.smoothSaltMultiplier;
Settings::Aimbot::SmokeCheck::enabled = currentWeaponSetting.smokeCheck;
Settings::Aimbot::FlashCheck::enabled = currentWeaponSetting.flashCheck;
Settings::Aimbot::AutoWall::enabled = currentWeaponSetting.autoWallEnabled;
Settings::Aimbot::AutoWall::value = currentWeaponSetting.autoWallValue;
Settings::Aimbot::AutoSlow::enabled = currentWeaponSetting.autoSlow;
Settings::Aimbot::AutoSlow::minDamage = currentWeaponSetting.autoSlowMinDamage;
for (int i = (int) Hitbox::HITBOX_HEAD; i <= (int) Hitbox::HITBOX_ARMS; i++)
Settings::Aimbot::AutoWall::bones[i] = currentWeaponSetting.autoWallBones[i];
Settings::Aimbot::AutoAim::realDistance = currentWeaponSetting.autoAimRealDistance;
}
void AutoStrafe::CreateMove(CUserCmd* cmd)
{
if (!Settings::AutoStrafe::enabled)
return;
C_BasePlayer* localplayer = (C_BasePlayer*)entitylist->GetClientEntity(engine->GetLocalPlayer());
if (!localplayer)
return;
if (!localplayer->GetAlive())
return;
if (localplayer->GetFlags() & FL_ONGROUND)
return;
if (localplayer->GetMoveType() == MOVETYPE_LADDER || localplayer->GetMoveType() == MOVETYPE_NOCLIP)
return;
if (cmd->mousedx > 1 || cmd->mousedx < -1)
{
switch (Settings::AutoStrafe::type)
{
case AS_FORWARDS:
cmd->sidemove = cmd->mousedx < 0.f ? -450.f : 450.f;
break;
case AS_BACKWARDS:
cmd->sidemove = cmd->mousedx < 0.f ? 450.f : -450.f;
break;
case AS_LEFTSIDEWAYS:
cmd->forwardmove = cmd->mousedx < 0.f ? -450.f : 450.f;
break;
case AS_RIGHTSIDEWAYS:
cmd->forwardmove = cmd->mousedx < 0.f ? 450.f : -450.f;
break;
}
}
}
void Aimbot::CreateMove(CUserCmd* cmd)
{
Aimbot::UpdateValues();
if (!Settings::Aimbot::enabled)
return;
QAngle oldAngle;
engine->GetViewAngles(oldAngle);
float oldForward = cmd->forwardmove;
float oldSideMove = cmd->sidemove;
QAngle angle = cmd->viewangles;
shouldAim = Settings::Aimbot::AutoShoot::enabled;
C_BasePlayer* localplayer = (C_BasePlayer*) entityList->GetClientEntity(engine->GetLocalPlayer());
if (!localplayer || !localplayer->GetAlive())
return;
if (Settings::Aimbot::IgnoreJump::enabled && !(localplayer->GetFlags() & FL_ONGROUND))
return;
C_BaseCombatWeapon* activeWeapon = (C_BaseCombatWeapon*) entityList->GetClientEntityFromHandle(localplayer->GetActiveWeapon());
if (!activeWeapon || activeWeapon->GetInReload())
return;
CSWeaponType weaponType = activeWeapon->GetCSWpnData()->GetWeaponType();
if (weaponType == CSWeaponType::WEAPONTYPE_C4 || weaponType == CSWeaponType::WEAPONTYPE_GRENADE || weaponType == CSWeaponType::WEAPONTYPE_KNIFE)
return;
Bone aw_bone;
float bestDamage = 0.0f;
C_BasePlayer* player = GetClosestPlayer(cmd, true, aw_bone, bestDamage);
if (player)
{
bool skipPlayer = false;
Vector eVecTarget = player->GetBonePosition((int) aw_bone);
Vector pVecTarget = localplayer->GetEyePosition();
if (Settings::Aimbot::SmokeCheck::enabled && LineGoesThroughSmoke(pVecTarget, eVecTarget, true))
skipPlayer = true;
if (Settings::Aimbot::FlashCheck::enabled && localplayer->GetFlashBangTime() - globalVars->curtime > 2.0f)
skipPlayer = true;
if (skipPlayer)
player = nullptr;
if (Settings::Aimbot::AutoAim::enabled && !skipPlayer)
{
if (cmd->buttons & IN_ATTACK && !Settings::Aimbot::aimkeyOnly)
shouldAim = true;
if (inputSystem->IsButtonDown(Settings::Aimbot::aimkey))
shouldAim = true;
if (shouldAim)
{
if (Settings::Aimbot::Prediction::enabled)
{
pVecTarget = VelocityExtrapolate(localplayer, pVecTarget); // get eye pos next tick
eVecTarget = VelocityExtrapolate(player, eVecTarget); // get target pos next tick
}
angle = Math::CalcAngle(pVecTarget, eVecTarget);
if (Settings::Aimbot::ErrorMargin::enabled)
ApplyErrorToAngle(&angle, Settings::Aimbot::ErrorMargin::value);
}
}
}
Aimbot::AimStep(player, angle, cmd);
Aimbot::AutoCrouch(player, cmd);
Aimbot::AutoSlow(player, oldForward, oldSideMove, bestDamage, activeWeapon, cmd);
Aimbot::AutoPistol(activeWeapon, cmd);
Aimbot::AutoShoot(player, activeWeapon, cmd);
Aimbot::RCS(angle, player, cmd);
Aimbot::Smooth(player, angle, cmd);
Aimbot::ShootCheck(activeWeapon, cmd);
Aimbot::NoShoot(activeWeapon, player, cmd);
Math::NormalizeAngles(angle);
Math::ClampAngles(angle);
if (angle != cmd->viewangles)
cmd->viewangles = angle;
Math::CorrectMovement(oldAngle, cmd, oldForward, oldSideMove);
if (!Settings::Aimbot::silent)
engine->SetViewAngles(cmd->viewangles);
}
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->GetClientEntity(i);
if (!player
|| player == localplayer
|| player->GetDormant()
|| !player->GetAlive()
|| player->GetImmune())
continue;
if (!Settings::Aimbot::friendly && player->GetTeam() == localplayer->GetTeam())
continue;
IEngineClient::player_info_t entityInformation;
engine->GetPlayerInfo(i, &entityInformation);
if (std::find(Aimbot::friends.begin(), Aimbot::friends.end(), entityInformation.xuid) != Aimbot::friends.end())
continue;
Vector eVecTarget = player->GetBonePosition((int) Settings::Aimbot::bone);
Vector pVecTarget = localplayer->GetEyePosition();
QAngle viewAngles;
engine->GetViewAngles(viewAngles);
float distance = pVecTarget.DistTo(eVecTarget);
float fov = Math::GetFov(viewAngles, Math::CalcAngle(pVecTarget, eVecTarget));
float real_distance = GetRealDistanceFOV(distance, Math::CalcAngle(pVecTarget, eVecTarget), cmd);
int hp = player->GetHealth();
if (aimTargetType == AimTargetType::DISTANCE && distance > bestDistance)
continue;
if (aimTargetType == AimTargetType::FOV && fov > bestFov)
continue;
if (aimTargetType == AimTargetType::REAL_DISTANCE && real_distance > bestRealDistance)
continue;
if (aimTargetType == AimTargetType::HP && hp > bestHp)
continue;
if (visible && !Settings::Aimbot::AutoWall::enabled && !Entity::IsVisible(player, Settings::Aimbot::bone))
continue;
bestBone = static_cast<Bone>(Entity::GetBoneByName(player, targets[(int) Settings::Aimbot::bone]));
if (Settings::Aimbot::AutoWall::enabled)
{
float damage = 0.0f;
Bone bone;
GetBestBone(player, damage, bone);
if (damage >= bestDamage && damage >= Settings::Aimbot::AutoWall::value)
{
bestDamage = damage;
bestBone = bone;
closestEntity = player;
}
}
else
{
closestEntity = player;
bestFov = fov;
bestRealDistance = real_distance;
bestDistance = distance;
bestHp = hp;
}
}
return closestEntity;
}
void Triggerbot::CreateMove(CUserCmd *cmd)
{
if (!Settings::Triggerbot::enabled)
return;
if (!inputSystem->IsButtonDown(Settings::Triggerbot::key))
return;
C_BasePlayer* localplayer = (C_BasePlayer*) entityList->GetClientEntity(engine->GetLocalPlayer());
if (!localplayer || !localplayer->GetAlive())
return;
if (Settings::Triggerbot::Filters::flashCheck && localplayer->GetFlashBangTime() - globalVars->curtime > 2.0f)
return;
long currentTime_ms = Util::GetEpochTime();
static long timeStamp = currentTime_ms;
long oldTimeStamp;
static int localMin = Settings::Triggerbot::RandomDelay::lowBound;
static int localMax = Settings::Triggerbot::RandomDelay::highBound;
static int randomDelay = localMin + rand() % (localMax - localMin);
if( localMin != Settings::Triggerbot::RandomDelay::lowBound || localMax != Settings::Triggerbot::RandomDelay::highBound ) // Done in case Low/high bounds change before the next triggerbot shot.
{
localMin = Settings::Triggerbot::RandomDelay::lowBound;
localMax = Settings::Triggerbot::RandomDelay::highBound;
randomDelay = localMin + rand() % (localMax - localMin);
}
Vector traceStart, traceEnd;
trace_t tr;
QAngle viewAngles;
engine->GetViewAngles(viewAngles);
QAngle viewAngles_rcs = viewAngles + *localplayer->GetAimPunchAngle() * 2.0f;
Math::AngleVectors(viewAngles_rcs, traceEnd);
traceStart = localplayer->GetEyePosition();
traceEnd = traceStart + (traceEnd * 8192.0f);
if (Settings::Triggerbot::Filters::walls)
{
Autowall::FireBulletData data;
if (Autowall::GetDamage(traceEnd, !Settings::Triggerbot::Filters::allies, data) == 0.0f)
return;
tr = data.enter_trace;
}
else
{
Ray_t ray;
ray.Init(traceStart, traceEnd);
CTraceFilter traceFilter;
traceFilter.pSkip = localplayer;
trace->TraceRay(ray, 0x46004003, &traceFilter, &tr);
}
oldTimeStamp = timeStamp;
timeStamp = currentTime_ms;
C_BasePlayer* player = (C_BasePlayer*) tr.m_pEntityHit;
if (!player)
return;
if (player->GetClientClass()->m_ClassID != EClassIds::CCSPlayer)
return;
if (player == localplayer
|| player->GetDormant()
|| !player->GetAlive()
|| player->GetImmune())
return;
if (player->GetTeam() != localplayer->GetTeam() && !Settings::Triggerbot::Filters::enemies)
return;
if (player->GetTeam() == localplayer->GetTeam() && !Settings::Triggerbot::Filters::allies)
return;
bool filter;
switch (tr.hitgroup)
{
case HitGroups::HITGROUP_HEAD:
filter = Settings::Triggerbot::Filters::head;
break;
case HitGroups::HITGROUP_CHEST:
filter = Settings::Triggerbot::Filters::chest;
break;
case HitGroups::HITGROUP_STOMACH:
filter = Settings::Triggerbot::Filters::stomach;
break;
case HitGroups::HITGROUP_LEFTARM:
case HitGroups::HITGROUP_RIGHTARM:
filter = Settings::Triggerbot::Filters::arms;
break;
case HitGroups::HITGROUP_LEFTLEG:
case HitGroups::HITGROUP_RIGHTLEG:
filter = Settings::Triggerbot::Filters::legs;
break;
default:
filter = false;
}
if (!filter)
return;
if (Settings::Triggerbot::Filters::smokeCheck && LineGoesThroughSmoke(tr.startpos, tr.endpos, 1))
return;
C_BaseCombatWeapon* activeWeapon = (C_BaseCombatWeapon*) entityList->GetClientEntityFromHandle(localplayer->GetActiveWeapon());
if (!activeWeapon || activeWeapon->GetAmmo() == 0)
return;
ItemDefinitionIndex itemDefinitionIndex = *activeWeapon->GetItemDefinitionIndex();
if (itemDefinitionIndex == ItemDefinitionIndex::WEAPON_KNIFE || itemDefinitionIndex >= ItemDefinitionIndex::WEAPON_KNIFE_BAYONET)
return;
CSWeaponType weaponType = activeWeapon->GetCSWpnData()->GetWeaponType();
if (weaponType == CSWeaponType::WEAPONTYPE_C4 || weaponType == CSWeaponType::WEAPONTYPE_GRENADE)
return;
if (activeWeapon->GetNextPrimaryAttack() > globalVars->curtime)
{
if (*activeWeapon->GetItemDefinitionIndex() == ItemDefinitionIndex::WEAPON_REVOLVER)
cmd->buttons &= ~IN_ATTACK2;
else
cmd->buttons &= ~IN_ATTACK;
}
else
{
if (Settings::Triggerbot::RandomDelay::enabled && currentTime_ms - oldTimeStamp < randomDelay)
{
timeStamp = oldTimeStamp;
return;
}
if (*activeWeapon->GetItemDefinitionIndex() == ItemDefinitionIndex::WEAPON_REVOLVER)
cmd->buttons |= IN_ATTACK2;
else
cmd->buttons |= IN_ATTACK;
if(Settings::Triggerbot::RandomDelay::enabled)
Settings::Triggerbot::RandomDelay::lastRoll = randomDelay;
randomDelay = localMin + rand() % (localMax - localMin);
}
timeStamp = currentTime_ms;
}