//----------------------------------------------------------------------------- // 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); } }