//-----------------------------------------------------------------------------
// Purpose: Save CPU cycles by letting the HUD system early cull
// costly traversal. Called per frame, return true if thinking and
// painting need to occur.
//-----------------------------------------------------------------------------
bool CHudCrosshair::ShouldDraw( void )
{
bool bNeedsDraw;
if ( m_bHideCrosshair )
return false;
C_BasePlayer* pPlayer = C_BasePlayer::GetLocalPlayer();
if ( !pPlayer )
return false;
C_BaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
if ( pWeapon && !pWeapon->ShouldDrawCrosshair() )
return false;
/* disabled to avoid assuming it's an HL2 player.
// suppress crosshair in zoom.
if ( pPlayer->m_HL2Local.m_bZooming )
return false;
*/
// draw a crosshair only if alive or spectating in eye
bNeedsDraw = m_pCrosshair &&
crosshair.GetInt() &&
!engine->IsDrawingLoadingImage() &&
!engine->IsPaused() &&
g_pClientMode->ShouldDrawCrosshair() &&
!( pPlayer->GetFlags() & FL_FROZEN ) &&
( pPlayer->entindex() == render->GetViewEntity() ) &&
//!pPlayer->IsInVGuiInputMode() &&
( pPlayer->IsAlive() || ( pPlayer->GetObserverMode() == OBS_MODE_IN_EYE ) || ( cl_observercrosshair.GetBool() && pPlayer->GetObserverMode() == OBS_MODE_ROAMING ) );
return ( bNeedsDraw && CHudElement::ShouldDraw() );
}
//-----------------------------------------------------------------------------
// Purpose
//-----------------------------------------------------------------------------
void C_BaseViewModel::FireEvent( const Vector& origin, const QAngle& angles, int eventNum, const char *options )
{
// We override sound requests so that we can play them locally on the owning player
if ( ( eventNum == AE_CL_PLAYSOUND ) || ( eventNum == CL_EVENT_SOUND ) )
{
// Only do this if we're owned by someone
if ( GetOwner() != NULL )
{
CLocalPlayerFilter filter;
EmitSound( filter, GetOwner()->GetSoundSourceIndex(), options, &GetAbsOrigin() );
return;
}
}
C_BasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( !pOwner )
return;
ACTIVE_SPLITSCREEN_PLAYER_GUARD_ENT( pOwner );
// Otherwise pass the event to our associated weapon
C_BaseCombatWeapon *pWeapon = pOwner->GetActiveWeapon();
if ( pWeapon )
{
bool bResult = pWeapon->OnFireEvent( this, origin, angles, eventNum, options );
if ( !bResult )
{
if ( eventNum == AE_CLIENT_EFFECT_ATTACH && ::input->CAM_IsThirdPerson() )
return;
BaseClass::FireEvent( origin, angles, eventNum, options );
}
}
}
void UpdateAmmoState()
{
C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
if ( player == NULL )
return;
C_BaseCombatWeapon *wpn = player->GetActiveWeapon();
if (player && wpn && wpn->UsesSecondaryAmmo())
{
SetAmmo(player->GetAmmoCount(wpn->GetSecondaryAmmoType()));
}
if ( m_hCurrentActiveWeapon != wpn )
{
if ( wpn->UsesSecondaryAmmo() )
{
// we've changed to a weapon that uses secondary ammo
GetClientMode()->GetViewportAnimationController()->StartAnimationSequence("WeaponUsesSecondaryAmmo");
}
else
{
// we've changed away from a weapon that uses secondary ammo
GetClientMode()->GetViewportAnimationController()->StartAnimationSequence("WeaponDoesNotUseSecondaryAmmo");
}
m_hCurrentActiveWeapon = wpn;
// Get the icon we should be displaying
m_iconSecondaryAmmo = gWR.GetAmmoIconFromWeapon( m_hCurrentActiveWeapon->GetSecondaryAmmoType() );
}
}
void CHudCrosshair::Paint( void )
{
if ( !m_pCrosshair )
return;
if ( !IsCurrentViewAccessAllowed() )
return;
C_BasePlayer* pPlayer = C_BasePlayer::GetLocalPlayer();
if ( !pPlayer )
return;
float x, y;
bool bBehindCamera;
GetDrawPosition ( &x, &y, &bBehindCamera, m_vecCrossHairOffsetAngle );
if( bBehindCamera )
return;
float flWeaponScale = 1.f;
int iTextureW = m_pCrosshair->Width();
int iTextureH = m_pCrosshair->Height();
C_BaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
if ( pWeapon )
{
pWeapon->GetWeaponCrosshairScale( flWeaponScale );
}
float flPlayerScale = 1.0f;
#ifdef TF_CLIENT_DLL
Color clr( cl_crosshair_red.GetInt(), cl_crosshair_green.GetInt(), cl_crosshair_blue.GetInt(), 255 );
flPlayerScale = cl_crosshair_scale.GetFloat() / 32.0f; // the player can change the scale in the options/multiplayer tab
#else
Color clr = m_clrCrosshair;
#endif
float flWidth = flWeaponScale * flPlayerScale * (float)iTextureW;
float flHeight = flWeaponScale * flPlayerScale * (float)iTextureH;
int iWidth = (int)( flWidth + 0.5f );
int iHeight = (int)( flHeight + 0.5f );
int iX = (int)( x + 0.5f );
int iY = (int)( y + 0.5f );
if (pPlayer->IsInVGuiInputMode() && m_pVGUIHoverIcon)
m_pVGUIHoverIcon->DrawSelf(
iX - (m_pVGUIHoverIcon->Width() / 2),
iY - (m_pVGUIHoverIcon->Height() / 2),
m_pVGUIHoverIcon->Width(),
m_pVGUIHoverIcon->Height(),
Color(0, 255, 0, 255));
else
{
m_pCrosshair->DrawSelfCropped(
iX - (iWidth / 2), iY - (iHeight + 2),
0, 0,
iTextureW, iTextureH,
iWidth, iHeight,
clr);
}
}
//-----------------------------------------------------------------------------
// Purpose: Gets the local client's active weapon, if any.
//-----------------------------------------------------------------------------
C_BaseCombatWeapon *GetActiveWeapon( void )
{
C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
if ( !player )
return NULL;
return player->GetActiveWeapon();
}
//Might be able to handle this better...
void HapticsHandleMsg_SPHapWeapEvent( int iActivity )
{
C_BasePlayer* pPlayer = C_BasePlayer::GetLocalPlayer();
C_BaseCombatWeapon* weap = NULL;
if(pPlayer)
weap = pPlayer->GetActiveWeapon();
if(weap)
haptics->ProcessHapticEvent(4,"Weapons",weap->GetName(),"Activities",VarArgs("%i",iActivity));
}
//-----------------------------------------------------------------------------
// Purpose: Save CPU cycles by letting the HUD system early cull
// costly traversal. Called per frame, return true if thinking and
// painting need to occur.
//-----------------------------------------------------------------------------
bool CHudCrosshair::ShouldDraw( void )
{
bool bNeedsDraw;
if ( m_bHideCrosshair )
return false;
C_BasePlayer* pPlayer = C_BasePlayer::GetLocalPlayer();
if ( !pPlayer )
return false;
C_BaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
if ( pWeapon && !pWeapon->ShouldDrawCrosshair() )
return false;
#ifdef PORTAL
// C_Portal_Player *portalPlayer = ToPortalPlayer(pPlayer);
// if ( portalPlayer && portalPlayer->IsSuppressingCrosshair() )
// return false;
#endif // PORTAL
/* disabled to avoid assuming it's an HL2 player.
// suppress crosshair in zoom.
if ( pPlayer->m_HL2Local.m_bZooming )
return false;
*/
// draw a crosshair only if alive or spectating in eye
if ( IsX360() )
{
bNeedsDraw = m_pCrosshair &&
!engine->IsDrawingLoadingImage() &&
!engine->IsPaused() &&
( !pPlayer->IsSuitEquipped() || g_pGameRules->IsMultiplayer() ) &&
g_pClientMode->ShouldDrawCrosshair() &&
!( pPlayer->GetFlags() & FL_FROZEN ) &&
( pPlayer->entindex() == render->GetViewEntity() ) &&
( pPlayer->IsAlive() || ( pPlayer->GetObserverMode() == OBS_MODE_IN_EYE ) || ( cl_observercrosshair.GetBool() && pPlayer->GetObserverMode() == OBS_MODE_ROAMING ) );
}
else
{
bNeedsDraw = m_pCrosshair &&
crosshair.GetInt() &&
!engine->IsDrawingLoadingImage() &&
!engine->IsPaused() &&
g_pClientMode->ShouldDrawCrosshair() &&
!( pPlayer->GetFlags() & FL_FROZEN ) &&
( pPlayer->entindex() == render->GetViewEntity() ) &&
!pPlayer->IsInVGuiInputMode() &&
( pPlayer->IsAlive() || ( pPlayer->GetObserverMode() == OBS_MODE_IN_EYE ) || ( cl_observercrosshair.GetBool() && pPlayer->GetObserverMode() == OBS_MODE_ROAMING ) );
}
return ( bNeedsDraw && CHudElement::ShouldDraw() );
}
void CHudWeapon::Paint( void )
{
C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
if ( !player )
return;
MDLCACHE_CRITICAL_SECTION();
C_BaseCombatWeapon *pWeapon = player->GetActiveWeapon();
if ( pWeapon )
pWeapon->Redraw();
else if ( m_pCrosshair )
m_pCrosshair->ResetCrosshair();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_BaseViewModel::GetBoneControllers(float controllers[MAXSTUDIOBONECTRLS])
{
BaseClass::GetBoneControllers( controllers );
// Tell the weapon itself that we've rendered, in case it wants to do something
C_BasePlayer *pPlayer = ToBasePlayer( GetOwner() );
if ( !pPlayer )
return;
C_BaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
if ( pWeapon )
{
pWeapon->GetViewmodelBoneControllers( this, controllers );
}
}
//-----------------------------------------------------------------------------
// Purpose: Save CPU cycles by letting the HUD system early cull
// costly traversal. Called per frame, return true if thinking and
// painting need to occur.
//-----------------------------------------------------------------------------
bool CDAHudCrosshair::ShouldDraw( void )
{
// OnThink isn't called when the thing isn't visible so force it to update.
CalculateCrosshair();
bool bNeedsDraw;
if ( m_bHideCrosshair )
return false;
C_BasePlayer* pPlayer = C_BasePlayer::GetLocalPlayer();
if ( !pPlayer )
return false;
C_BaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
if ( pWeapon && !pWeapon->ShouldDrawCrosshair() )
return false;
ConVarRef cl_observercrosshair("cl_observercrosshair");
// draw a crosshair only if alive or spectating in eye
if ( IsX360() )
{
bNeedsDraw = m_pCrosshair &&
!engine->IsDrawingLoadingImage() &&
!engine->IsPaused() &&
( !pPlayer->IsSuitEquipped() || g_pGameRules->IsMultiplayer() ) &&
g_pClientMode->ShouldDrawCrosshair() &&
!( pPlayer->GetFlags() & FL_FROZEN ) &&
( pPlayer->entindex() == render->GetViewEntity() ) &&
( pPlayer->IsAlive() || ( pPlayer->GetObserverMode() == OBS_MODE_IN_EYE ) || ( cl_observercrosshair.GetBool() && pPlayer->GetObserverMode() == OBS_MODE_ROAMING ) );
}
else
{
bNeedsDraw = m_pCrosshair &&
da_crosshair.GetInt() &&
!engine->IsDrawingLoadingImage() &&
!engine->IsPaused() &&
g_pClientMode->ShouldDrawCrosshair() &&
!( pPlayer->GetFlags() & FL_FROZEN ) &&
( pPlayer->entindex() == render->GetViewEntity() ) &&
!pPlayer->IsInVGuiInputMode() &&
( pPlayer->IsAlive() || ( pPlayer->GetObserverMode() == OBS_MODE_IN_EYE ) || ( cl_observercrosshair.GetBool() && pPlayer->GetObserverMode() == OBS_MODE_ROAMING ) );
}
return ( bNeedsDraw && CHudElement::ShouldDraw() );
}
void CHudCrosshair::Paint( void )
{
if ( !m_pCrosshair )
return;
if ( !IsCurrentViewAccessAllowed() )
return;
C_BasePlayer* pPlayer = C_BasePlayer::GetLocalPlayer();
if ( !pPlayer )
return;
float x, y;
bool bBehindCamera;
GetDrawPosition ( &x, &y, &bBehindCamera, m_vecCrossHairOffsetAngle );
if( bBehindCamera )
return;
float flWeaponScale = 1.f;
int iTextureW = m_pCrosshair->Width();
int iTextureH = m_pCrosshair->Height();
C_BaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
if ( pWeapon )
{
pWeapon->GetWeaponCrosshairScale( flWeaponScale );
}
float flPlayerScale = 1.0f;
Color clr = m_clrCrosshair;
float flWidth = flWeaponScale * flPlayerScale * (float)iTextureW;
float flHeight = flWeaponScale * flPlayerScale * (float)iTextureH;
int iWidth = (int)( flWidth + 0.5f );
int iHeight = (int)( flHeight + 0.5f );
int iX = (int)( x + 0.5f );
int iY = (int)( y + 0.5f );
m_pCrosshair->DrawSelfCropped (
iX-(iWidth/2), iY-(iHeight/2),
0, 0,
iTextureW, iTextureH,
iWidth, iHeight,
clr );
}
virtual void OnThink()
{
// set whether or not the panel draws based on if we have a weapon that supports secondary ammo
C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
C_BaseCombatWeapon *wpn = player ? player->GetActiveWeapon() : NULL;
IClientVehicle *pVehicle = player ? player->GetVehicle() : NULL;
if (!wpn || !player || pVehicle)
{
m_hCurrentActiveWeapon = NULL;
SetPaintEnabled(false);
SetPaintBackgroundEnabled(false);
return;
}
else
{
SetPaintEnabled(true);
SetPaintBackgroundEnabled(true);
}
UpdateAmmoState();
}
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 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);
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int C_SpriteRenderer::DrawSprite(
IClientEntity *entity,
const model_t *model,
const Vector& origin,
const QAngle& angles,
float frame,
IClientEntity *attachedto,
int attachmentindex,
int rendermode,
int renderfx,
int alpha,
int r,
int g,
int b,
float scale,
float flHDRColorScale
)
{
VPROF_BUDGET( "C_SpriteRenderer::DrawSprite", VPROF_BUDGETGROUP_PARTICLE_RENDERING );
if ( !r_drawsprites.GetBool() || !model || modelinfo->GetModelType( model ) != mod_sprite )
return 0;
// Get extra data
CEngineSprite *psprite = (CEngineSprite *)modelinfo->GetModelExtraData(model);
if ( !psprite )
return 0;
Vector effect_origin;
VectorCopy(origin, effect_origin);
// Use attachment point
if ( attachedto )
{
C_BaseEntity *ent = attachedto->GetBaseEntity();
if ( ent )
{
if ( ent->GetBaseAnimating() && ent->GetBaseAnimating()->IsViewModel() && ::input->CAM_IsThirdPersonOverShoulder() )
{
C_BaseViewModel *pVm = (C_BaseViewModel*)ent;
C_BasePlayer *pOwner = ( pVm->GetOwner() && pVm->GetOwner()->IsPlayer() ) ? (C_BasePlayer*)pVm->GetOwner() : NULL;
if ( pOwner && pOwner->GetActiveWeapon() )
return 0; //worldmodels don't have the same attachments, so just get out (crossbow)
}
// don't draw viewmodel effects in reflections
if ( CurrentViewID() == VIEW_REFLECTION )
{
int group = ent->GetRenderGroup();
if ( group == RENDER_GROUP_VIEW_MODEL_TRANSLUCENT || group == RENDER_GROUP_VIEW_MODEL_OPAQUE )
return 0;
}
QAngle temp;
ent->GetAttachment(attachmentindex, effect_origin, temp);
}
}
if ( rendermode != kRenderNormal )
{
float blend = render->GetBlend();
// kRenderGlow and kRenderWorldGlow have a special blending function
if (( rendermode == kRenderGlow ) || ( rendermode == kRenderWorldGlow ))
{
blend *= GlowBlend( psprite, effect_origin, rendermode, renderfx, alpha, &scale );
// Fade out the sprite depending on distance from the view origin.
r *= blend;
g *= blend;
b *= blend;
}
render->SetBlend( blend );
if ( blend <= 0.0f )
{
return 0;
}
}
// Get orthonormal basis
Vector forward, right, up;
GetSpriteAxes( (SPRITETYPE)psprite->GetOrientation(), origin, angles, forward, right, up );
// Draw
DrawSpriteModel(
entity,
psprite,
effect_origin,
scale,
frame,
rendermode,
r,
g,
b,
alpha,
forward, right, up, flHDRColorScale );
return 1;
}
//====================================================================
//====================================================================
void CBaseHTML::WebThink()
{
if ( !cl_web_think.GetBool() )
return;
float flNextThink = cl_web_think_interval.GetFloat();
// Información de la partida
SetProperty( "isInGame", JSValue(engine->IsInGame()), m_pGameObject );
SetProperty( "isPaused", JSValue(engine->IsPaused()), m_pGameObject );
SetProperty( "maxClients", JSValue(engine->GetMaxClients()), m_pGameObject );
SetProperty( "isLoading", JSValue(GameUI().m_bIsLoading), m_pGameObject );
if ( InRules )
SetProperty( "gameMode", JSValue(InRules->GameMode()), m_pGameObject );
// Obtenemos al Jugador
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
// Existe, estamos en una partida
if ( pPlayer )
{
// Información actual del Jugador
C_BaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
int iHealth = pPlayer->GetHealth();
int iAmmo = 0;
int iAmmoTotal = 0;
// Tenemos un arma
if ( pWeapon )
{
iAmmo = pWeapon->Clip1();
iAmmoTotal = pPlayer->GetAmmoCount( pWeapon->GetPrimaryAmmoType() );
}
// Actualizamos la información básica
SetProperty( "health", JSValue(iHealth), m_pPlayerObject );
SetProperty( "clip1Ammo", JSValue(iAmmo), m_pPlayerObject );
SetProperty( "clip1TotalAmmo", JSValue(iAmmoTotal), m_pPlayerObject );
}
// Información de la API de Steam
if ( IsPC() && steamapicontext )
{
// ID de Steam
if ( !m_pSteamID )
{
// Intentamos obtener la ID
if ( steamapicontext->SteamUser() )
{
CSteamID steamID = steamapicontext->SteamUser()->GetSteamID();
uint64 mySteamID = steamID.ConvertToUint64();
m_pSteamID = VarArgs("%llu", mySteamID);
}
// ID cargada, se lo dejamos a JavaScript...
if ( m_pSteamID )
{
SetProperty( "playerID", JSValue(WSLit(m_pSteamID)), m_pSteamObject );
ExecuteJavaScript( "Helper.loadUserInfo()", "" );
}
}
// Utilidades e información
if ( steamapicontext->SteamUtils() )
{
uint32 serverTime = steamapicontext->SteamUtils()->GetServerRealTime();
const char *country = steamapicontext->SteamUtils()->GetIPCountry();
uint8 battery = steamapicontext->SteamUtils()->GetCurrentBatteryPower();
uint32 computer = steamapicontext->SteamUtils()->GetSecondsSinceComputerActive();
SetProperty( "serverTime", JSValue(WSLit(VarArgs("%llu", serverTime))), m_pSteamObject );
SetProperty( "country", JSValue(country), m_pSteamObject );
SetProperty( "batteryPower", JSValue(WSLit(VarArgs("%llu", battery))), m_pSteamObject );
SetProperty( "computerActive", JSValue(WSLit(VarArgs("%llu", computer))), m_pSteamObject );
}
}
// Pensamiento en JS
ExecuteJavaScript( "think()", "" );
// Pensamiento nuevamente en...
m_flNextThink = gpGlobals->curtime + flNextThink;
}
void C_TEHL2MPFireBullets::CreateEffects( void )
{
CAmmoDef* pAmmoDef = GetAmmoDef();
if ( pAmmoDef == NULL )
return;
C_BaseEntity *pEnt = ClientEntityList().GetEnt( m_iPlayer );
if ( pEnt )
{
C_BasePlayer *pPlayer = dynamic_cast<C_BasePlayer *>(pEnt);
if ( pPlayer && pPlayer->GetActiveWeapon() )
{
C_BaseCombatWeapon *pWpn = dynamic_cast<C_BaseCombatWeapon *>( pPlayer->GetActiveWeapon() );
if ( pWpn )
{
int iSeed = m_iSeed;
CShotManipulator Manipulator( m_vecDir );
for (int iShot = 0; iShot < m_iShots; iShot++)
{
RandomSeed( iSeed ); // init random system with this seed
// Don't run the biasing code for the player at the moment.
Vector vecDir = Manipulator.ApplySpread( Vector( m_flSpread, m_flSpread, m_flSpread ) );
Vector vecEnd = m_vecOrigin + vecDir * MAX_TRACE_LENGTH;
trace_t tr;
CTraceFilterSkipPlayerAndViewModelOnly traceFilter;
if( m_iShots > 1 && iShot % 2 )
{
// Half of the shotgun pellets are hulls that make it easier to hit targets with the shotgun.
UTIL_TraceHull( m_vecOrigin, vecEnd, Vector( -3, -3, -3 ), Vector( 3, 3, 3 ), MASK_SHOT, &traceFilter, &tr );
}
else
{
UTIL_TraceLine( m_vecOrigin, vecEnd, MASK_SHOT, &traceFilter, &tr);
}
if ( m_bDoTracers )
{
const char *pTracerName = pWpn->GetTracerType();
CEffectData data;
data.m_vStart = tr.startpos;
data.m_vOrigin = tr.endpos;
data.m_hEntity = pWpn->GetRefEHandle();
data.m_flScale = 0.0f;
data.m_fFlags |= TRACER_FLAG_USEATTACHMENT;
// Stomp the start, since it's not going to be used anyway
data.m_nAttachmentIndex = 1;
if ( pTracerName )
{
DispatchEffect( pTracerName, data );
}
else
{
DispatchEffect( "Tracer", data );
}
}
if ( m_bDoImpacts )
{
pWpn->DoImpactEffect( tr, pAmmoDef->DamageType( m_iAmmoID ) );
}
iSeed++;
}
}
}
}
}
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;
}
