//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWarsWeapon::MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType )
{
#if 0
const char* tracer = "ASWUTracer";
//if (GetActiveASWWeapon())
// tracer = GetActiveASWWeapon()->GetUTracerType();
#ifdef CLIENT_DLL
CEffectData data;
data.m_vOrigin = tr.endpos;
data.m_hEntity = this;
//data.m_nMaterial = m_iDamageAttributeEffects;
DispatchEffect( tracer, data );
#else
CRecipientFilter filter;
filter.AddAllPlayers();
if (gpGlobals->maxClients > 1 && GetCommander())
{
filter.RemoveRecipient(GetCommander());
}
UserMessageBegin( filter, tracer );
WRITE_SHORT( entindex() );
WRITE_FLOAT( tr.endpos.x );
WRITE_FLOAT( tr.endpos.y );
WRITE_FLOAT( tr.endpos.z );
//WRITE_SHORT( m_iDamageAttributeEffects );
MessageEnd();
#endif
#else
#ifdef CLIENT_DLL
ASWUTracer( GetOwner(), tr.endpos, m_vTracerColor );
#endif
#endif // 0
}
void HapticMsg_Punch(CBasePlayer* pPlayer, float x, float y, float z)
{
CSingleUserRecipientFilter user(pPlayer);
user.MakeReliable();
UserMessageBegin(user,"HapPunch");
WRITE_FLOAT(x);
WRITE_FLOAT(y);
WRITE_FLOAT(z);
MessageEnd();
}
void CASW_Sentry_Top::MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType )
{
CBroadcastRecipientFilter filter;
UserMessageBegin( filter, "ASWSentryTracer" );
WRITE_SHORT( entindex() );
WRITE_FLOAT( tr.endpos.x );
WRITE_FLOAT( tr.endpos.y );
WRITE_FLOAT( tr.endpos.z );
MessageEnd();
}
void HapticMsg_HapDmg(CBasePlayer* pPlayer, float pitch, float yaw, float dmg, float dmgType )
{
CSingleUserRecipientFilter user(pPlayer);
user.MakeReliable();
UserMessageBegin(user,"HapDmg");
WRITE_FLOAT(pitch);
WRITE_FLOAT(yaw);
WRITE_FLOAT(dmg);
WRITE_LONG(dmgType);
MessageEnd();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSDKPlayer::UpdateClientData( void )
{
if (m_DmgTake || m_DmgSave || m_bitsHUDDamage != m_bitsDamageType)
{
// Comes from inside me if not set
Vector damageOrigin = GetLocalOrigin();
// send "damage" message
// causes screen to flash, and pain compass to show direction of damage
damageOrigin = m_DmgOrigin;
// only send down damage type that have hud art
int iShowHudDamage = g_pGameRules->Damage_GetShowOnHud();
int visibleDamageBits = m_bitsDamageType & iShowHudDamage;
m_DmgTake = clamp( m_DmgTake, 0, 255 );
m_DmgSave = clamp( m_DmgSave, 0, 255 );
// If we're poisoned, but it wasn't this frame, don't send the indicator
// Without this check, any damage that occured to the player while they were
// recovering from a poison bite would register as poisonous as well and flash
// the whole screen! -- jdw
if ( visibleDamageBits & DMG_POISON )
{
float flLastPoisonedDelta = gpGlobals->curtime - m_tbdPrev;
if ( flLastPoisonedDelta > 0.1f )
{
visibleDamageBits &= ~DMG_POISON;
}
}
CSingleUserRecipientFilter user( this );
user.MakeReliable();
UserMessageBegin( user, "Damage" );
WRITE_BYTE( m_DmgSave );
WRITE_BYTE( m_DmgTake );
WRITE_LONG( visibleDamageBits );
WRITE_FLOAT( damageOrigin.x ); //BUG: Should be fixed point (to hud) not floats
WRITE_FLOAT( damageOrigin.y ); //BUG: However, the HUD does _not_ implement bitfield messages (yet)
WRITE_FLOAT( damageOrigin.z ); //BUG: We use WRITE_VEC3COORD for everything else
MessageEnd();
m_DmgTake = 0;
m_DmgSave = 0;
m_bitsHUDDamage = m_bitsDamageType;
// Clear off non-time-based damage indicators
int iTimeBasedDamage = g_pGameRules->Damage_GetTimeBased();
m_bitsDamageType &= iTimeBasedDamage;
}
BaseClass::UpdateClientData();
}
//------------------------------------------------------------------------------
// Purpose : Propagate force to each link in the rope. Check for loops
// Input :
// Output :
//------------------------------------------------------------------------------
void CRopeKeyframe::PropagateForce(CBaseEntity *pActivator, CBaseEntity *pCaller, CBaseEntity *pFirstLink, float x, float y, float z)
{
EntityMessageBegin( this, true );
WRITE_FLOAT( x );
WRITE_FLOAT( y );
WRITE_FLOAT( z );
MessageEnd();
// UNDONE: Doesn't deal with intermediate loops
// Propagate to next segment
CRopeKeyframe *pNextLink = dynamic_cast<CRopeKeyframe*>((CBaseEntity *)m_hEndPoint);
if (pNextLink && pNextLink != pFirstLink)
{
pNextLink->PropagateForce(pActivator, pCaller, pFirstLink, x, y, z);
}
}
void HapticMsg_SetDrag(CBasePlayer* pPlayer, float drag)
{
CSingleUserRecipientFilter user( pPlayer );
user.MakeReliable();
UserMessageBegin( user, "HapSetDrag" );
WRITE_FLOAT(drag);
MessageEnd();
}
void CWeaponCombatCannon::ResetFreezing( bool finished )
{
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
if ( m_pFreezingBlock )
{
if ( !finished )
{
if ( m_pFreezingBlock->IsFrozen() && m_bTempFreeze )
{
if ( pPlayer )
{
DevMsg( "Unfreezing temp freeze\n" );
m_pFreezingBlock->UnFreeze( pPlayer );
}
else
{
DevMsg( "Unfreezing temp freeze\n" );
m_pFreezingBlock->UnFreeze( NULL, FROZEN_BY_WORLD );
}
}
}
m_pFreezingBlock->SetCurrentFreezer( NULL );
}
// lolu, wut?! - Hekar
m_flLastFreeze = -1.0f;
m_flLastTime = -1.0f;
m_flFreezeRatio = 0.0f;
m_flFreezeTime = 0.0f;
m_flElapsedTime = 0.0f;
m_bTempFreeze = false;
m_bFreezing = false;
m_pFreezingBlock = NULL;
if ( pPlayer )
{
m_nReloadDebounce |= pPlayer->m_nButtons;
}
if ( GetOwner() )
{
CSingleUserRecipientFilter user( ToBasePlayer( GetOwner() ) );
user.MakeReliable();
UserMessageBegin( user, "UpdateFreezeProgress" );
WRITE_BYTE( 0 ); // Turn off the HUD
WRITE_LONG( 0 );
WRITE_FLOAT( 0 );
MessageEnd();
}
StopFreezeSound();
m_pLastBlock = NULL;
}
void CASW_Weapon_Blink::PrimaryAttack( void )
{
CASW_Player *pPlayer = GetCommander();
if (!pPlayer)
return;
CASW_Marine *pMarine = GetMarine();
if ( !pMarine || pMarine->GetCurrentMeleeAttack() || pMarine->GetForcedActionRequest() != 0 )
return;
if ( GetPower() < asw_blink_charge_time.GetFloat() )
{
#ifdef CLIENT_DLL
EmitSound( "ASW_Weapon.InsufficientBattery" );
#else
if ( gpGlobals->maxClients <= 1 )
{
EmitSound( "ASW_Weapon.InsufficientBattery" );
}
#endif
return;
}
if ( pMarine->IsInhabited() )
{
// Get the server to verify destination and do a forced action to actually blink
#ifdef GAME_DLL
if ( !SetBlinkDestination() )
{
CSingleUserRecipientFilter user( pPlayer );
UserMessageBegin( user, "ASWInvalidDesination" );
WRITE_SHORT( pMarine->entindex() );
WRITE_FLOAT( m_vecInvalidDestination.x );
WRITE_FLOAT( m_vecInvalidDestination.y );
WRITE_FLOAT( m_vecInvalidDestination.z );
MessageEnd();
return;
}
pMarine->RequestForcedAction( FORCED_ACTION_BLINK );
pMarine->OnWeaponFired( this, 1 );
#endif
}
}
//-----------------------------------------------------------------------------
// Purpose: Update a client who joined during the middle of an act
//-----------------------------------------------------------------------------
void CInfoAct::UpdateClient( CBaseTFPlayer *pPlayer )
{
CSingleUserRecipientFilter user( pPlayer );
user.MakeReliable();
UserMessageBegin( user, "ActBegin" );
WRITE_BYTE( (byte)m_iActNumber );
WRITE_FLOAT( m_flActStartedAt );
MessageEnd();
}
void NDebugOverlay::BoxAngles(const Vector &origin, const Vector &mins, const Vector &maxs, const QAngle &angles, int r, int g, int b, int a, float duration)
{
// --------------------------------------------------------------
// Have to do clip the boxes before sending so we
// don't overflow the client message buffer
// --------------------------------------------------------------
CBasePlayer *player = UTIL_PlayerByIndex(1);
if ( !player )
return;
// ------------------------------------
// Clip boxes that are far away
// ------------------------------------
if ((player->GetAbsOrigin() - origin).LengthSqr() > MAX_OVERLAY_DIST_SQR)
return;
// ------------------------------------
// Clip boxes that are behind the client
// ------------------------------------
Vector clientForward;
player->EyeVectors( &clientForward );
// Build a rotation matrix from orientation
matrix3x4_t fRotateMatrix;
AngleMatrix(angles, fRotateMatrix);
// Transform the mins and maxs
Vector tmins, tmaxs;
VectorRotate( mins, fRotateMatrix, tmins);
VectorAdd(tmins,origin,tmins);
VectorRotate( maxs, fRotateMatrix, tmaxs);
VectorAdd(tmaxs,origin,tmaxs);
Vector toMins = tmins - player->GetAbsOrigin();
Vector toMaxs = tmaxs - player->GetAbsOrigin();
float dotMins = DotProduct(clientForward,toMins);
float dotMaxs = DotProduct(clientForward,toMaxs);
if (dotMins < 0 && dotMaxs < 0)
return;
CSingleUserRecipientFilter user( player );
MessageBegin( user, SVC_DEBUG_BOX_OVERLAY );
WRITE_VEC3COORD(origin);
WRITE_VEC3COORD(mins);
WRITE_VEC3COORD(maxs);
WRITE_ANGLES(angles);
WRITE_SHORT(r);
WRITE_SHORT(g);
WRITE_SHORT(b);
WRITE_SHORT(a);
WRITE_FLOAT(duration);
MessageEnd();
}
A661_INTERNAL int a661_com_msg_EditBoxNumeric_A661_VALUE(buffer_el msg[],
a661_ushort pid, a661_float A661_VALUE_Value_){
int n3 = 0;
int n2 = 0;
int n1 = 0;
PARAMETER("A661_VALUE");
WRITE_USHORT(msg + 0, pid);
WRITE_USHORT(msg + 2, 0);
WRITE_FLOAT(msg + 4, A661_VALUE_Value_);
return 8 ;
}
//-----------------------------------------------------------------------------
// Purpose: Send debug overlay line to the client
// Input :
// Output :
//-----------------------------------------------------------------------------
void NDebugOverlay::Triangle( const Vector &p1, const Vector &p2, const Vector &p3,
int r, int g, int b, int a, bool noDepthTest, float duration )
{
// --------------------------------------------------------------
// Have to do clip the boxes before sending so we
// don't overflow the client message buffer
// --------------------------------------------------------------
CBasePlayer *player = UTIL_PlayerByIndex(1);
if ( !player )
return;
Vector to1 = p1 - player->GetAbsOrigin();
Vector to2 = p2 - player->GetAbsOrigin();
Vector to3 = p3 - player->GetAbsOrigin();
// ------------------------------------
// Clip triangles that are far away
// ------------------------------------
if ((to1.LengthSqr() > MAX_OVERLAY_DIST_SQR) &&
(to2.LengthSqr() > MAX_OVERLAY_DIST_SQR) &&
(to3.LengthSqr() > MAX_OVERLAY_DIST_SQR))
{
return;
}
// ------------------------------------
// Clip triangles that are behind the client
// ------------------------------------
Vector clientForward;
player->EyeVectors( &clientForward );
float dot1 = DotProduct(clientForward, to1);
float dot2 = DotProduct(clientForward, to2);
float dot3 = DotProduct(clientForward, to3);
if (dot1 < 0 && dot2 < 0 && dot3 < 0)
{
return;
}
CSingleUserRecipientFilter user( player );
MessageBegin( user, SVC_DEBUG_TRIANGLE_OVERLAY );
WRITE_VEC3COORD(p1);
WRITE_VEC3COORD(p2);
WRITE_VEC3COORD(p3);
WRITE_SHORT(r);
WRITE_SHORT(g);
WRITE_SHORT(b);
WRITE_SHORT(a);
WRITE_SHORT(noDepthTest);
WRITE_FLOAT(duration);
MessageEnd();
}
void CASW_Barrel_Explosive::DoExplosion()
{
// scorch the ground
trace_t tr;
UTIL_TraceLine ( GetAbsOrigin(), GetAbsOrigin() + Vector( 0, 0, -80 ), MASK_SHOT,
this, COLLISION_GROUP_NONE, &tr);
if ((tr.m_pEnt != GetWorldEntity()) || (tr.hitbox != 0))
{
// non-world needs smaller decals
if( tr.m_pEnt && !tr.m_pEnt->IsNPC() )
{
UTIL_DecalTrace( &tr, "SmallScorch" );
}
}
else
{
UTIL_DecalTrace( &tr, "Scorch" );
}
UTIL_ASW_ScreenShake( GetAbsOrigin(), 25.0, 150.0, 1.0, 750, SHAKE_START );
// explosion effects
Vector vecExplosionPos = GetAbsOrigin();
CPASFilter filter( vecExplosionPos );
UserMessageBegin( filter, "ASWBarrelExplosion" );
WRITE_FLOAT( vecExplosionPos.x );
WRITE_FLOAT( vecExplosionPos.y );
WRITE_FLOAT( vecExplosionPos.z );
WRITE_FLOAT( 160.0f );
MessageEnd();
EmitSound( "ASWBarrel.Explode" );
// damage to nearby things
CTakeDamageInfo info( this, ( m_hAttacker.Get() ? m_hAttacker.Get() : this ), m_iExplosionDamage, DMG_BLAST );
info.SetDamageCustom( DAMAGE_FLAG_HALF_FALLOFF );
ASWGameRules()->RadiusDamage( info, GetAbsOrigin(), 160.0f, CLASS_NONE, NULL );
}
//-----------------------------------------------------------------------------
// Purpose: Send debug overlay text with screen position to the client
// Input :
// Output :
//-----------------------------------------------------------------------------
void NDebugOverlay::ScreenText( float flXpos, float flYpos, const char *text, int r, int g, int b, int a, float duration)
{
// --------------------------------------------------------------
// Clip the text before sending so we
// don't overflow the client message buffer
// --------------------------------------------------------------
CBasePlayer *pClient = UTIL_PlayerByIndex(1);
if ( !pClient )
return;
CSingleUserRecipientFilter user( pClient );
MessageBegin( user, SVC_DEBUG_SCREENTEXT_OVERLAY );
WRITE_FLOAT(flXpos);
WRITE_FLOAT(flYpos);
WRITE_FLOAT(duration);
WRITE_SHORT(r);
WRITE_SHORT(g);
WRITE_SHORT(b);
WRITE_SHORT(a);
WRITE_STRING(text);
MessageEnd();
}
//-----------------------------------------------------------------------------
// Purpose: Send debug overlay text to the client
// Input :
// Output :
//-----------------------------------------------------------------------------
void NDebugOverlay::EntityText( int entityID, int text_offset, const char *text, float duration, int r, int g, int b, int a )
{
CBroadcastRecipientFilter filter;
MessageBegin( filter, SVC_DEBUG_ENTITYTEXT_OVERLAY);
WRITE_SHORT(entityID);
WRITE_SHORT(text_offset);
WRITE_FLOAT(duration);
WRITE_SHORT(r);
WRITE_SHORT(g);
WRITE_SHORT(b);
WRITE_SHORT(a);
WRITE_STRING(text);
MessageEnd();
}
//-----------------------------------------------------------------------------
// Purpose: Send debug overlay line to the client
// Input :
// Output :
//-----------------------------------------------------------------------------
void NDebugOverlay::Line( const Vector &origin, const Vector &target, int r, int g, int b, bool noDepthTest, float duration )
{
// --------------------------------------------------------------
// Clip the line before sending so we
// don't overflow the client message buffer
// --------------------------------------------------------------
CBasePlayer *player = UTIL_PlayerByIndex(1);
if ( !player )
return;
// ------------------------------------
// Clip line that is far away
// ------------------------------------
if (((player->GetAbsOrigin() - origin).LengthSqr() > MAX_OVERLAY_DIST_SQR) &&
((player->GetAbsOrigin() - target).LengthSqr() > MAX_OVERLAY_DIST_SQR) )
return;
// ------------------------------------
// Clip line that is behind the client
// ------------------------------------
Vector clientForward;
player->EyeVectors( &clientForward );
Vector toOrigin = origin - player->GetAbsOrigin();
Vector toTarget = target - player->GetAbsOrigin();
float dotOrigin = DotProduct(clientForward,toOrigin);
float dotTarget = DotProduct(clientForward,toTarget);
if (dotOrigin < 0 && dotTarget < 0)
{
return;
}
CSingleUserRecipientFilter user( player );
MessageBegin( user, SVC_DEBUG_LINE_OVERLAY );
WRITE_VEC3COORD(origin);
WRITE_VEC3COORD(target);
WRITE_SHORT(r);
WRITE_SHORT(g);
WRITE_SHORT(b);
WRITE_SHORT(noDepthTest);
WRITE_FLOAT(duration);
MessageEnd();
}
//-----------------------------------------------------------------------------
// Purpose: Send debug overlay text to the client
// Input :
// Output :
//-----------------------------------------------------------------------------
void NDebugOverlay::Text( const Vector &origin, const char *text, bool bViewCheck, float duration )
{
CBasePlayer *player = UTIL_PlayerByIndex(1);
if ( !player )
return;
// ------------------------------------
// Clip text that is far away
// ------------------------------------
if ((player->GetAbsOrigin() - origin).LengthSqr() > 4000000)
return;
// ------------------------------------
// Clip text that is behind the client
// ------------------------------------
Vector clientForward;
player->EyeVectors( &clientForward );
Vector toText = origin - player->GetAbsOrigin();
float dotPr = DotProduct(clientForward,toText);
if (dotPr < 0)
{
return;
}
if (bViewCheck)
{
trace_t tr;
UTIL_TraceLine(player->GetAbsOrigin(), origin, MASK_OPAQUE, NULL, COLLISION_GROUP_NONE, &tr);
if ((tr.endpos - origin).Length() > 10)
{
return;
}
}
CSingleUserRecipientFilter user( player );
MessageBegin( user, SVC_DEBUG_TEXT_OVERLAY );
WRITE_VEC3COORD(origin);
WRITE_FLOAT(duration);
WRITE_STRING(text);
MessageEnd();
}
void CCredits::InputShowLogo( inputdata_t &inputdata )
{
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
CSingleUserRecipientFilter user( pPlayer );
user.MakeReliable();
if ( m_flLogoLength )
{
UserMessageBegin( user, "LogoTimeMsg" );
WRITE_FLOAT( m_flLogoLength );
MessageEnd();
}
else
{
UserMessageBegin( user, "CreditsMsg" );
WRITE_BYTE( 1 );
MessageEnd();
}
}
void CWeaponCombatCannon::ResetHealing( void )
{
m_flLastHeal = -1.0f;
m_bHealing = false;
StopRepairSound();
if ( GetOwner() )
{
// Turn off the hud element
CSingleUserRecipientFilter user( ToBasePlayer( GetOwner() ) );
user.MakeReliable();
UserMessageBegin( user, "UpdateFreezeProgress" );
WRITE_BYTE( 0 );
WRITE_LONG( 0 );
WRITE_FLOAT( 0 );
MessageEnd();
}
m_pLastBlock = NULL;
}
void CASW_Objective_Kill_Goo::GooKilled(CASW_Alien_Goo* pGoo)
{
if (IsObjectiveComplete())
return;
//Msg("CASW_Objective_Kill_Goo see Alien Goo killed!\n");
m_iCurrentKills++;
//Msg(" Currently %d goos killed, target is %d\n", m_iCurrentKills, m_iTargetKills);
if (m_iCurrentKills >= m_iTargetKills)
{
Msg(" we're done!\n");
SetComplete(true);
}
else
{
CReliableBroadcastRecipientFilter filter;
UserMessageBegin( filter, "ShowObjectives" );
WRITE_FLOAT( 5.0f );
MessageEnd();
}
}
//-----------------------------------------------------------------------------
// Purpose: The act has started
//-----------------------------------------------------------------------------
void CInfoAct::StartAct( void )
{
// FIXME: Should this change?
// Don't allow two simultaneous acts
if (g_hCurrentAct)
{
g_hCurrentAct->FinishAct( );
}
// Set the global act to this
g_hCurrentAct = this;
m_flActStartedAt = gpGlobals->curtime;
m_OnStarted.FireOutput( this, this );
// Do we have a timelimit?
if ( m_flActTimeLimit )
{
SetNextThink( gpGlobals->curtime + m_flActTimeLimit );
SetThink( ActThink );
}
SetUpRespawnTimers();
// Tell all the clients
CRelieableBroadcastRecipientFilter filter;
UserMessageBegin( filter, "ActBegin" );
WRITE_BYTE( (byte)m_iActNumber );
WRITE_FLOAT( m_flActStartedAt );
MessageEnd();
// If we're not an intermission, clean up
if ( !HasSpawnFlags( SF_ACT_INTERMISSION ) )
{
CleanupOnActStart();
}
// Cycle through all players and start the act
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CBaseTFPlayer *pPlayer = (CBaseTFPlayer*)UTIL_PlayerByIndex( i );
if ( pPlayer )
{
// Am I an intermission?
if ( HasSpawnFlags( SF_ACT_INTERMISSION ) )
{
StartIntermission( pPlayer );
}
else
{
StartActOverlayTime( pPlayer );
}
}
}
// Think again soon, to remove player locks
if ( !HasSpawnFlags(SF_ACT_INTERMISSION) )
{
SetNextThink( gpGlobals->curtime + MIN_ACT_OVERLAY_TIME );
SetThink( ActThinkEndActOverlayTime );
}
}
void CWeaponCombatCannon::CombatFreezeIncrement( void )
{
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
// Find and check the player's punch angle for
// a block in sight
CBlockBase *pBlock = FindTraceBlock();
if( !pBlock )
{
ResetFreezing();
return;
}
if ( !pBlock->IsFreezeable() ||
( pBlock->IsBeingFrozen() && pBlock->GetCurrentFreezer() != pPlayer ) )
{
ResetFreezing();
return;
}
// Let's presume we're not unfreezing a block
bool IsUnFreezing = false;
// Are we looking at the same entity we started to freeze?
if ( pBlock != m_pFreezingBlock )
{
if ( m_flFreezeTime > 0.0f && m_flElapsedTime > 0.0 )
{
ResetFreezing();
}
m_pFreezingBlock = pBlock;
}
if ( !m_grabController.GetAttached() )
{
// Check if the player has moved too far back from the freezing point
float freezeDistance = fabs( ( pPlayer->Weapon_ShootPosition() - m_tr.endpos ).Length() );
if ( freezeDistance > lf_freeze_distance_combat.GetFloat() )
{
ResetFreezing();
return;
}
}
// The player has started freezing a block
if ( m_flLastFreeze <= 0.0f )
{
m_flStartTime = gpGlobals->curtime;
// Amount of time required to Freeze/UnFreeze a block in combat
float flFreezeTime = lf_combat_unfreeze_enemy.GetFloat();
// Check if the block is on our team
if ( pBlock->GetTeamNumber() == GetOwner()->GetTeamNumber() )
{
// Calculate our freeze time
if ( pBlock->IsFrozen() )
{
flFreezeTime = lf_combat_unfreeze_friendly.GetFloat();
}
else
{
flFreezeTime = lf_combat_freeze_friendly.GetFloat();
m_bTempFreeze = true;
pBlock->Freeze( pPlayer );
}
}
else
{
// Completely different values for unfreezing on enemy team
float flHealthRatio = (float)pBlock->GetHealth() / (float)pBlock->GetMaxHealth();
flFreezeTime = (float)lf_combat_unfreeze_enemy.GetFloat() * (float)flHealthRatio;
}
// Play our freezing noise
float duration = 10.0f;
pBlock->EmitSound( "Luminousforts.Freeze", 0.0f, &duration );
m_pLastBlock = pBlock;
m_flFreezeTime = flFreezeTime;
}
// Check if we're unfreezing (Block will be frozen if we're unfreezing)
if ( pBlock->IsFrozen() && !m_bTempFreeze )
{
IsUnFreezing = true;
}
// Calculate the freezing ratio
m_flFreezeRatio = 0.0f;
if ( m_flFreezeTime > 0.0f && m_flElapsedTime > 0.0 )
{
m_flFreezeRatio = ( m_flElapsedTime / m_flFreezeTime );
}
// Send a message with information on the amount frozen.
CSingleUserRecipientFilter user( ToBasePlayer(GetOwner( )) );
float percentage = m_flFreezeRatio * 100.0f;
// Make Reliable for first packet sent
if( percentage < 2.0f )
{
user.MakeReliable();
}
int iFreezingType = SFH_FREEZEPROGRESS_NONE;
// Do all our checks here and only send a single enum
// to save a little bit of our precious bandwidth
if ( IsUnFreezing )
{
if ( GetOwner()->GetTeamNumber() != m_pFreezingBlock->GetTeamNumber() )
{
iFreezingType = SFH_FREEZEPROGRESS_UNFREEZING_ENEMY;
}
else
{
iFreezingType = SFH_FREEZEPROGRESS_UNFREEZING;
}
m_bFreezing = false;
}
else
{
iFreezingType = SFH_FREEZEPROGRESS_FREEZING;
m_bFreezing = true;
}
// Send our stuff over the wire
UserMessageBegin( user, "UpdateFreezeProgress" );
WRITE_BYTE( 1 ); // Letting the HUD know it's time to turn on
WRITE_LONG( iFreezingType );
WRITE_FLOAT( percentage );
MessageEnd();
// Display the welding sparks
GenerateSparks( m_tr.endpos );
pBlock->SetCurrentFreezer( pPlayer );
m_flElapsedTime = gpGlobals->curtime - m_flStartTime;
m_flLastFreeze = gpGlobals->curtime;
}
void CWeaponCombatCannon::CombatHealIncrement( void )
{
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
// Find and check the player's punch angle for
// a block in sight
CBlockBase *pBlock = FindTraceBlock();
if( !pBlock )
{
ResetHealing();
return;
}
if ( pBlock->GetHealth() + lf_heal_increment_combat.GetFloat() >= pBlock->GetMaxHealth() )
{
return;
}
else if ( pPlayer->GetTeamNumber() != pBlock->GetTeamNumber() )
{
// You may not heal a block not belonging to your team
return;
}
m_vecPlayerHealPosition = m_tr.endpos;
// Check if the player has moved too far back from the freezing point
float healDistance = fabs( ( pPlayer->GetAbsOrigin() - m_vecPlayerHealPosition ).Length() );
if ( healDistance > lf_heal_distance_combat.GetFloat() )
{
ResetHealing();
return;
}
// First time heaing, so start the sound
if ( m_flLastHeal <= 0.0f )
{
// Play our repairing noise
pBlock->EmitSound( "Luminousforts.Repair" );
m_pLastBlock = pBlock;
}
// Start healing the block
if ( m_flLastHeal + lf_heal_delay_combat.GetFloat() <= gpGlobals->curtime )
{
pBlock->SetHealth( pBlock->GetHealth() + lf_heal_increment_combat.GetFloat() );
SendWeaponAnim( ACT_VM_PRIMARYATTACK );
DoEffect( EFFECT_HOLDING );
float health = pBlock->GetHealth();
float maxHealth = pBlock->GetMaxHealth();
float percentage = ( health / maxHealth ) * 100;
// Send a message with information on the amount frozen.
CSingleUserRecipientFilter user( ToBasePlayer( GetOwner() ) );
// Send our stuff over the wire
UserMessageBegin( user, "UpdateFreezeProgress" );
WRITE_BYTE( 1 ); // Letting the HUD know it's time to turn on
WRITE_LONG( SFH_FREEZEPROGRESS_HEALING );
WRITE_FLOAT( percentage );
MessageEnd();
m_bHealing = true;
m_flLastHeal = gpGlobals->curtime;
}
}
void testforloop() {
float f;
for (f = -1.f; f < 1.f; f += 0.2f) {
WRITE_FLOAT(f, 10);
}
}
