//-----------------------------------------------------------------------------
// Purpose: Calculate m_vecVelocity and m_flNextThink to reach vecDest from
// GetLocalOrigin() traveling at flSpeed. Just like LinearMove, but rotational.
// Input : vecDestAngle -
// flSpeed -
//-----------------------------------------------------------------------------
void CBaseToggle::AngularMove( const QAngle &vecDestAngle, float flSpeed )
{
ASSERTSZ(flSpeed != 0, "AngularMove: no speed is defined!");
m_vecFinalAngle = vecDestAngle;
m_movementType = MOVE_TOGGLE_ANGULAR;
// Already there?
if (vecDestAngle == GetLocalAngles())
{
MoveDone();
return;
}
// set destdelta to the vector needed to move
QAngle vecDestDelta = vecDestAngle - GetLocalAngles();
// divide by speed to get time to reach dest
float flTravelTime = vecDestDelta.Length() / flSpeed;
const float MinTravelTime = 0.01f;
if ( flTravelTime < MinTravelTime )
{
// If we only travel for a short time, we can fail WillSimulateGamePhysics()
flTravelTime = MinTravelTime;
flSpeed = vecDestDelta.Length() / flTravelTime;
}
// set m_flNextThink to trigger a call to AngularMoveDone when dest is reached
SetMoveDoneTime( flTravelTime );
// scale the destdelta vector by the time spent traveling to get velocity
SetLocalAngularVelocity( vecDestDelta * (1.0 / flTravelTime) );
}
//-----------------------------------------------------------------------------
// Purpose: Returns the magnitude of the entity's angular velocity.
//-----------------------------------------------------------------------------
float CPointAngularVelocitySensor::SampleAngularVelocity(CBaseEntity *pEntity)
{
if (pEntity->GetMoveType() == MOVETYPE_VPHYSICS)
{
IPhysicsObject *pPhys = pEntity->VPhysicsGetObject();
if (pPhys != NULL)
{
Vector vecVelocity;
AngularImpulse vecAngVelocity;
pPhys->GetVelocity(&vecVelocity, &vecAngVelocity);
QAngle angles;
pPhys->GetPosition( NULL, &angles );
float dt = gpGlobals->curtime - GetLastThink();
if ( dt == 0 )
dt = 0.1;
// HACKHACK: We don't expect a real 'delta' orientation here, just enough of an error estimate to tell if this thing
// is trying to move, but failing.
QAngle delta = angles - m_lastOrientation;
if ( ( delta.Length() / dt ) < ( vecAngVelocity.Length() * 0.01 ) )
{
return 0.0f;
}
m_lastOrientation = angles;
if ( m_bUseHelper == false )
{
return vecAngVelocity.Length();
}
else
{
Vector vLine = m_vecAxis - GetAbsOrigin();
VectorNormalize( vLine );
Vector vecWorldAngVelocity;
pPhys->LocalToWorldVector( &vecWorldAngVelocity, vecAngVelocity );
float flDot = DotProduct( vecWorldAngVelocity, vLine );
return flDot;
}
}
}
else
{
QAngle vecAngVel = pEntity->GetLocalAngularVelocity();
float flMax = MAX(fabs(vecAngVel[PITCH]), fabs(vecAngVel[YAW]));
return MAX(flMax, fabs(vecAngVel[ROLL]));
}
return 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_ObjectSentrygun::PostDataUpdate( DataUpdateType_t updateType )
{
BaseClass::PostDataUpdate( updateType );
if ( m_bLastTurtled != m_bTurtled )
{
if ( m_bTurtled )
{
m_flStartedTurtlingAt = gpGlobals->curtime;
m_flStartedUnTurtlingAt = 0;
}
else
{
m_flStartedUnTurtlingAt = gpGlobals->curtime;
m_flStartedTurtlingAt = 0;
}
}
if ( m_nLastAnimationParity != m_nAnimationParity )
{
m_flCycle = 0.0f;
}
bool changed = false;
QAngle angleDiff;
angleDiff = ( GetAbsAngles() - m_angPrevLocalAngles );
for (int i = 0;i < 3; i++ )
{
angleDiff[i] = UTIL_AngleMod( angleDiff[ i ] );
}
if ( angleDiff.Length() > 0.1f )
{
changed = true;
}
if ( updateType == DATA_UPDATE_CREATED || changed )
{
// Orient it
m_vecCurAngles.y = UTIL_AngleMod( GetLocalAngles().y );
RecomputeOrientation();
}
else if ( m_nPrevOrientationParity != m_nOrientationParity )
{
if ( changed )
{
RecomputeOrientation();
}
}
}
void Aimbot::Smooth(C_BasePlayer* player, QAngle& angle, CUserCmd* cmd)
{
if (!Settings::Aimbot::Smooth::enabled)
return;
if (Settings::AntiAim::Pitch::enabled || Settings::AntiAim::Yaw::enabled)
return;
if (!shouldAim || !player)
return;
if (Settings::Aimbot::silent)
return;
QAngle viewAngles = QAngle(0.f, 0.f, 0.f);
engine->GetViewAngles(viewAngles);
QAngle delta = angle - viewAngles;
Math::NormalizeAngles(delta);
float smooth = powf(Settings::Aimbot::Smooth::value, 0.4f); // Makes more slider space for actual useful values
smooth = std::min(0.99f, smooth);
if (Settings::Aimbot::Smooth::Salting::enabled)
Salt(smooth);
QAngle toChange = QAngle();
int type = (int) Settings::Aimbot::Smooth::type;
if (type == (int) SmoothType::SLOW_END)
toChange = delta - delta * smooth;
else if (type == (int) SmoothType::CONSTANT || type == (int) SmoothType::FAST_END)
{
float coeff = (1.0f - smooth) / delta.Length() * 4.f;
if (type == (int) SmoothType::FAST_END)
coeff = powf(coeff, 2.f) * 10.f;
coeff = std::min(1.f, coeff);
toChange = delta * coeff;
}
angle = viewAngles + toChange;
}
//-----------------------------------------------------------------------------
// Purpose: Sends Hammer an update to the current position
//-----------------------------------------------------------------------------
void NWCEdit::UpdateEntityPosition( CBaseEntity *pEntity )
{
const Vector &newPos = pEntity->GetAbsOrigin();
const QAngle &newAng = pEntity->GetAbsAngles();
DevMsg( 1, "%s\n origin %f %f %f\n angles %f %f %f\n", pEntity->GetClassname(), newPos.x, newPos.y, newPos.z, newAng.x, newAng.y, newAng.z );
if ( Ragdoll_IsPropRagdoll(pEntity) )
{
char tmp[2048];
Ragdoll_GetAngleOverrideString( tmp, sizeof(tmp), pEntity );
DevMsg( 1, "pose: %s\n", tmp );
}
if ( !(pEntity->ObjectCaps() & FCAP_WCEDIT_POSITION) )
return;
// can't do this unless in edit mode
if ( !engine->IsInEditMode() )
return;
int entIndex = pEntity->entindex();
Vector pos = g_EntityPositions[entIndex];
EditorSendResult_t result = Editor_BadCommand;
const char *pClassname = STRING(g_EntityClassnames[entIndex]);
if ( pEntity->GetModel() && modelinfo->GetModelType(pEntity->GetModel()) == mod_brush )
{
QAngle xformAngles;
RotationDelta( g_EntityOrientations[entIndex], newAng, &xformAngles );
if ( xformAngles.Length() > 1e-4 )
{
result = Editor_RotateEntity( pClassname, pos.x, pos.y, pos.z, xformAngles );
}
else
{
// don't call through for an identity rotation, may just increase error
result = Editor_OK;
}
}
else
{
if ( Ragdoll_IsPropRagdoll(pEntity) )
{
char tmp[2048];
Ragdoll_GetAngleOverrideString( tmp, sizeof(tmp), pEntity );
result = Editor_SetKeyValue( pClassname, pos.x, pos.y, pos.z, "angleOverride", tmp );
if ( result != Editor_OK )
goto error;
}
result = Editor_SetKeyValue( pClassname, pos.x, pos.y, pos.z, "angles", CFmtStr("%f %f %f", newAng.x, newAng.y, newAng.z) );
}
if ( result != Editor_OK )
goto error;
result = Editor_SetKeyValue( pClassname, pos.x, pos.y, pos.z, "origin", CFmtStr("%f %f %f", newPos.x, newPos.y, newPos.z) );
if ( result != Editor_OK )
goto error;
NDebugOverlay::EntityBounds(pEntity, 0, 255, 0, 0 ,5);
// save the update
RememberEntityPosition( pEntity );
return;
error:
NDebugOverlay::EntityBounds(pEntity, 255, 0, 0, 0 ,5);
}