static void GetPos( const CCommand &args, Vector &vecOrigin, QAngle &angles )
{
vecOrigin = MainViewOrigin();
angles = MainViewAngles();
if ( args.ArgC() == 2 && atoi( args[1] ) == 2 )
{
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if ( pPlayer )
{
vecOrigin = pPlayer->GetAbsOrigin();
angles = pPlayer->GetAbsAngles();
}
}
}
void vParticleOperator_WorldRotationForce::Simulate( vParticle *parent )
{
QAngle cur = MainViewAngles();
Vector2D force( AngleDiff( cur.y, last.y ), AngleDiff( last.x, cur.x ) );
force *= GetImpulse( parent ) * vParticle::GetRelativeScale() * str;
float rainHack = CFrameTimeHelper::GetFrameTime() - (1.0f/60.0f);
force += force * rainHack * -20.0f;
last = cur;
parent->vecVelocity += force;
}
static void GetPos( const CCommand &args, Vector &vecOrigin, QAngle &angles )
{
int nSlot = GET_ACTIVE_SPLITSCREEN_SLOT();
vecOrigin = MainViewOrigin(nSlot);
angles = MainViewAngles(nSlot);
#ifdef INFESTED_DLL
C_ASW_Marine *pMarine = C_ASW_Marine::GetLocalMarine();
if ( pMarine )
{
vecOrigin = pMarine->GetAbsOrigin();
angles = pMarine->GetAbsAngles();
}
#endif
if ( ( args.ArgC() == 2 && atoi( args[1] ) == 2 ) || FStrEq( args[0], "getpos_exact" ) )
{
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if ( pPlayer )
{
vecOrigin = pPlayer->GetAbsOrigin();
angles = pPlayer->GetAbsAngles();
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Tesla effect
//-----------------------------------------------------------------------------
void C_EntityDissolve::BuildTeslaEffect( mstudiobbox_t *pHitBox, const matrix3x4_t &hitboxToWorld, bool bRandom, float flYawOffset )
{
Vector vecOrigin;
QAngle vecAngles;
MatrixGetColumn( hitboxToWorld, 3, vecOrigin );
MatrixAngles( hitboxToWorld, vecAngles.Base() );
C_BaseEntity *pEntity = GetMoveParent();
// Make a couple of tries at it
int iTries = -1;
Vector vecForward;
trace_t tr;
do
{
iTries++;
// Some beams are deliberatly aimed around the point, the rest are random.
if ( !bRandom )
{
QAngle vecTemp = vecAngles;
vecTemp[YAW] += flYawOffset;
AngleVectors( vecTemp, &vecForward );
// Randomly angle it up or down
vecForward.z = RandomFloat( -1, 1 );
}
else
{
vecForward = RandomVector( -1, 1 );
}
UTIL_TraceLine( vecOrigin, vecOrigin + (vecForward * 192), MASK_SHOT, pEntity, COLLISION_GROUP_NONE, &tr );
} while ( tr.fraction >= 1.0 && iTries < 3 );
Vector vecEnd = tr.endpos - (vecForward * 8);
// Only spark & glow if we hit something
if ( tr.fraction < 1.0 )
{
if ( !EffectOccluded( tr.endpos ) )
{
// Move it towards the camera
Vector vecFlash = tr.endpos;
Vector vecForward;
AngleVectors( MainViewAngles(), &vecForward );
vecFlash -= (vecForward * 8);
g_pEffects->EnergySplash( vecFlash, -vecForward, false );
// End glow
CSmartPtr<CSimpleEmitter> pSimple = CSimpleEmitter::Create( "dust" );
pSimple->SetSortOrigin( vecFlash );
SimpleParticle *pParticle;
pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), pSimple->GetPMaterial( "effects/tesla_glow_noz" ), vecFlash );
if ( pParticle != NULL )
{
pParticle->m_flLifetime = 0.0f;
pParticle->m_flDieTime = RandomFloat( 0.5, 1 );
pParticle->m_vecVelocity = vec3_origin;
Vector color( 1,1,1 );
float colorRamp = RandomFloat( 0.75f, 1.25f );
pParticle->m_uchColor[0] = MIN( 1.0f, color[0] * colorRamp ) * 255.0f;
pParticle->m_uchColor[1] = MIN( 1.0f, color[1] * colorRamp ) * 255.0f;
pParticle->m_uchColor[2] = MIN( 1.0f, color[2] * colorRamp ) * 255.0f;
pParticle->m_uchStartSize = RandomFloat( 6,13 );
pParticle->m_uchEndSize = pParticle->m_uchStartSize - 2;
pParticle->m_uchStartAlpha = 255;
pParticle->m_uchEndAlpha = 10;
pParticle->m_flRoll = RandomFloat( 0,360 );
pParticle->m_flRollDelta = 0;
}
}
}
// Build the tesla
FX_BuildTesla( pEntity, vecOrigin, tr.endpos );
}
void FX_Tesla( const CTeslaInfo &teslaInfo )
{
C_BaseEntity *pEntity = ClientEntityList().GetEnt( teslaInfo.m_nEntIndex );
// Send out beams around us
int iNumBeamsAround = (teslaInfo.m_nBeams * 2) / 3; // (2/3 of the beams are placed around in a circle)
int iNumRandomBeams = teslaInfo.m_nBeams - iNumBeamsAround;
int iTotalBeams = iNumBeamsAround + iNumRandomBeams;
float flYawOffset = RandomFloat(0,360);
for ( int i = 0; i < iTotalBeams; i++ )
{
// Make a couple of tries at it
int iTries = -1;
Vector vecForward;
trace_t tr;
do
{
iTries++;
// Some beams are deliberatly aimed around the point, the rest are random.
if ( i < iNumBeamsAround )
{
QAngle vecTemp = teslaInfo.m_vAngles;
vecTemp[YAW] += anglemod( flYawOffset + ((360 / iTotalBeams) * i) );
AngleVectors( vecTemp, &vecForward );
// Randomly angle it up or down
vecForward.z = RandomFloat( -1, 1 );
}
else
{
vecForward = RandomVector( -1, 1 );
}
VectorNormalize( vecForward );
UTIL_TraceLine( teslaInfo.m_vPos, teslaInfo.m_vPos + (vecForward * teslaInfo.m_flRadius), MASK_SHOT, pEntity, COLLISION_GROUP_NONE, &tr );
} while ( tr.fraction >= 1.0 && iTries < 3 );
Vector vecEnd = tr.endpos - (vecForward * 8);
// Only spark & glow if we hit something
if ( tr.fraction < 1.0 )
{
if ( !EffectOccluded( tr.endpos, 0 ) )
{
// Move it towards the camera
Vector vecFlash = tr.endpos;
Vector vecForward;
AngleVectors( MainViewAngles(), &vecForward );
vecFlash -= (vecForward * 8);
g_pEffects->EnergySplash( vecFlash, -vecForward, false );
// End glow
CSmartPtr<CSimpleEmitter> pSimple = CSimpleEmitter::Create( "dust" );
pSimple->SetSortOrigin( vecFlash );
SimpleParticle *pParticle;
pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), pSimple->GetPMaterial( "effects/tesla_glow_noz" ), vecFlash );
if ( pParticle != NULL )
{
pParticle->m_flLifetime = 0.0f;
pParticle->m_flDieTime = RandomFloat( 0.5, 1 );
pParticle->m_vecVelocity = vec3_origin;
Vector color( 1,1,1 );
float colorRamp = RandomFloat( 0.75f, 1.25f );
pParticle->m_uchColor[0] = MIN( 1.0f, color[0] * colorRamp ) * 255.0f;
pParticle->m_uchColor[1] = MIN( 1.0f, color[1] * colorRamp ) * 255.0f;
pParticle->m_uchColor[2] = MIN( 1.0f, color[2] * colorRamp ) * 255.0f;
pParticle->m_uchStartSize = RandomFloat( 6,13 );
pParticle->m_uchEndSize = pParticle->m_uchStartSize - 2;
pParticle->m_uchStartAlpha = 255;
pParticle->m_uchEndAlpha = 10;
pParticle->m_flRoll = RandomFloat( 0,360 );
pParticle->m_flRollDelta = 0;
}
}
}
// Build the tesla
FX_BuildTesla( pEntity, teslaInfo.m_vPos, tr.endpos, teslaInfo.m_pszSpriteName, teslaInfo.m_flBeamWidth, teslaInfo.m_vColor, FBEAM_ONLYNOISEONCE, teslaInfo.m_flTimeVisible );
}
}
void CMumbleSystem::PostRender()
{
#ifndef NO_STEAM
if ( !g_pMumbleMemory || !sv_mumble_positionalaudio.GetBool() )
return;
if ( g_pMumbleMemory->uiVersion != 2 )
{
V_wcscpy_safe( g_pMumbleMemory->name, L"Source engine: " );
wchar_t wcsGameDir[MAX_PATH];
Q_UTF8ToUnicode( COM_GetModDirectory(), wcsGameDir, sizeof(wcsGameDir) );
V_wcscat_safe( g_pMumbleMemory->name, wcsGameDir );
V_wcscpy_safe( g_pMumbleMemory->description, L"Links Source engine games to Mumble." );
g_pMumbleMemory->uiVersion = 2;
}
g_pMumbleMemory->uiTick++;
Vector vecOriginPlayer, vecOriginCamera = MainViewOrigin();
QAngle anglesPlayer, anglesCamera = MainViewAngles();
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if ( pPlayer )
{
vecOriginPlayer = pPlayer->EyePosition();
anglesPlayer = pPlayer->GetAbsAngles();
}
else
{
vecOriginPlayer = vecOriginCamera;
anglesPlayer = anglesCamera;
}
anglesPlayer.x = 0;
Vector vecPlayerForward, vecPlayerUp, vecCameraForward, vecCameraUp;
AngleVectors( anglesPlayer, &vecPlayerForward, NULL, &vecPlayerUp );
AngleVectors( anglesCamera, &vecCameraForward, NULL, &vecCameraUp );
// 1 Source unit is about one inch
// 1 mumble unit = 1 meter
vecOriginPlayer *= METERS_PER_INCH;
vecOriginCamera *= METERS_PER_INCH;
VectorToMumbleFloatArray( vecPlayerForward, g_pMumbleMemory->fAvatarFront );
VectorToMumbleFloatArray( vecPlayerUp, g_pMumbleMemory->fAvatarTop );
VectorToMumbleFloatArray( vecOriginPlayer, g_pMumbleMemory->fAvatarPosition );
VectorToMumbleFloatArray( vecCameraForward, g_pMumbleMemory->fCameraFront );
VectorToMumbleFloatArray( vecCameraUp, g_pMumbleMemory->fCameraTop );
VectorToMumbleFloatArray( vecOriginCamera, g_pMumbleMemory->fCameraPosition );
if ( pPlayer && m_bHasSetPlayerUniqueId && m_nTeamSetInUniqueId != pPlayer->GetTeamNumber() )
{
// Player changed team since we set the unique ID. Set it again.
m_bHasSetPlayerUniqueId = false;
}
if ( !m_bHasSetPlayerUniqueId && steamapicontext && steamapicontext->SteamUser() )
{
CSteamID steamid = steamapicontext->SteamUser()->GetSteamID();
if ( steamid.IsValid() )
{
int unTeam = pPlayer ? pPlayer->GetTeamNumber() : 0;
char szSteamId[256];
V_sprintf_safe( szSteamId, "universe:%u;account_type:%u;id:%u;instance:%u;team:%d", steamid.GetEUniverse(), steamid.GetEAccountType(), steamid.GetAccountID(), steamid.GetUnAccountInstance(), unTeam );
wchar_t wcsSteamId[256];
Q_UTF8ToUnicode( szSteamId, wcsSteamId, sizeof(wcsSteamId) );
// Identifier which uniquely identifies a certain player in a context.
V_wcscpy_safe( g_pMumbleMemory->identity, wcsSteamId );
m_bHasSetPlayerUniqueId = true;
m_nTeamSetInUniqueId = unTeam;
}
}
// Context should be equal for players which should be able to hear each other positional and
// differ for those who shouldn't (e.g. it could contain the server+port and team)
memcpy( g_pMumbleMemory->context, &m_szSteamIDCurrentServer, m_cubSteamIDCurrentServer );
g_pMumbleMemory->context_len = m_cubSteamIDCurrentServer;
#endif // NO_STEAM
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void FX_BuildWarp( Vector &vecOrigin, QAngle &vecAngles, float flScale )
{
if ( EffectOccluded( vecOrigin, 0 ) )
return;
CSmartPtr<CSimpleEmitter> pSimple = CSimpleEmitter::Create( "dust" );
pSimple->SetSortOrigin( vecOrigin );
SimpleParticle *pParticle;
Vector color( 1, 1, 1 );
float colorRamp;
// Big flash
pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), pSimple->GetPMaterial( "effects/blueflare2" ), vecOrigin );
if ( pParticle != NULL )
{
pParticle->m_flLifetime = 0.0f;
pParticle->m_flDieTime = 0.5;
pParticle->m_vecVelocity = vec3_origin;
colorRamp = RandomFloat( 0.75f, 1.25f );
pParticle->m_uchColor[0] = min( 1.0f, color[0] * colorRamp ) * 255.0f;
pParticle->m_uchColor[1] = min( 1.0f, color[1] * colorRamp ) * 255.0f;
pParticle->m_uchColor[2] = min( 1.0f, color[2] * colorRamp ) * 255.0f;
pParticle->m_uchStartSize = RandomFloat( 10,15 );
pParticle->m_uchEndSize = pParticle->m_uchStartSize * 8 * flScale;
pParticle->m_uchStartAlpha = 48;
pParticle->m_uchEndAlpha = 0;
pParticle->m_flRoll = 0;
pParticle->m_flRollDelta = 0;
}
// Bright light
// Move it towards the camera
Vector vecForward;
AngleVectors( MainViewAngles(), &vecForward );
vecOrigin -= (vecForward * 8);
CSmartPtr<CWarpParticleEmitter> pWarpEmitter = CWarpParticleEmitter::Create( "dust" );
pWarpEmitter->SetSortOrigin( vecOrigin );
pParticle = (SimpleParticle *) pWarpEmitter->AddParticle( sizeof( SimpleParticle ), pWarpEmitter->GetPMaterial( "effects/human_build_warp" ), vecOrigin );
if ( pParticle != NULL )
{
pParticle->m_flLifetime = 0.0f;
pParticle->m_flDieTime = 0.4;
pParticle->m_vecVelocity = vec3_origin;
colorRamp = RandomFloat( 0.75f, 1.25f );
pParticle->m_uchColor[0] = min( 1.0f, color[0] * colorRamp ) * 255.0f;
pParticle->m_uchColor[1] = min( 1.0f, color[1] * colorRamp ) * 255.0f;
pParticle->m_uchColor[2] = min( 1.0f, color[2] * colorRamp ) * 255.0f;
pParticle->m_uchStartSize = RandomInt( 10,13 ) * flScale;
pParticle->m_uchEndSize = pParticle->m_uchStartSize * 9;
pParticle->m_uchStartAlpha = 32;
pParticle->m_uchEndAlpha = 192;
pParticle->m_flRoll = 0;
pParticle->m_flRollDelta = 0;
}
}
vParticleOperator_WorldRotationForce::vParticleOperator_WorldRotationForce( float strength )
{
str = strength;
last = MainViewAngles();
}
//-----------------------------------------------------------------------------
// Purpose: Intercepts the blood spray message.
//-----------------------------------------------------------------------------
void TFBloodSprayCallback( Vector vecOrigin, Vector vecNormal, ClientEntityHandle_t hEntity )
{
QAngle vecAngles;
VectorAngles( -vecNormal, vecAngles );
// determine if the bleeding player is underwater
bool bUnderwater = false;
C_TFPlayer *pPlayer = dynamic_cast<C_TFPlayer*>( ClientEntityList().GetBaseEntityFromHandle( hEntity ) );
if ( pPlayer && ( WL_Eyes == pPlayer->GetWaterLevel() ) )
{
bUnderwater = true;
}
if ( !bUnderwater && TFGameRules() && TFGameRules()->IsBirthday() && RandomFloat(0,1) < 0.2 )
{
DispatchParticleEffect( "bday_blood", vecOrigin, vecAngles, pPlayer );
}
else
{
DispatchParticleEffect( bUnderwater ? "water_blood_impact_red_01" : "blood_impact_red_01", vecOrigin, vecAngles, pPlayer );
}
// if underwater, don't add additional spray
if ( bUnderwater )
return;
// Now throw out a spray away from the view
// Get the distance to the view
float flDistance = (vecOrigin - MainViewOrigin()).Length();
float flLODDistance = 0.25 * (flDistance / 512);
Vector right, up;
if (vecNormal != Vector(0, 0, 1) )
{
right = vecNormal.Cross( Vector(0, 0, 1) );
up = right.Cross( vecNormal );
}
else
{
right = Vector(0, 0, 1);
up = right.Cross( vecNormal );
}
// If the normal's too close to being along the view, push it out
Vector vecForward, vecRight;
AngleVectors( MainViewAngles(), &vecForward, &vecRight, NULL );
float flDot = DotProduct( vecNormal, vecForward );
if ( fabs(flDot) > 0.5 )
{
float flPush = random->RandomFloat(0.5, 1.5) + flLODDistance;
float flRightDot = DotProduct( vecNormal, vecRight );
// If we're up close, randomly move it around. If we're at a distance, always push it to the side
// Up close, this can move it back towards the view, but the random chance still looks better
if ( ( flDistance >= 512 && flRightDot > 0 ) || ( flDistance < 512 && RandomFloat(0,1) > 0.5 ) )
{
// Turn it to the right
vecNormal += (vecRight * flPush);
}
else
{
// Turn it to the left
vecNormal -= (vecRight * flPush);
}
}
VectorAngles( vecNormal, vecAngles );
if ( flDistance < 400 )
{
DispatchParticleEffect( "blood_spray_red_01", vecOrigin, vecAngles, pPlayer );
}
else
{
DispatchParticleEffect( "blood_spray_red_01_far", vecOrigin, vecAngles, pPlayer );
}
}