//-----------------------------------------------------------------------------
// Purpose: Receive messages from the server
// Input : classID - class to receive the message
// &msg - message in question
//-----------------------------------------------------------------------------
void C_GrenadeHopwire::ReceiveMessage( int classID, bf_read &msg )
{
if ( classID != GetClientClass()->m_ClassID )
{
// Message is for subclass
BaseClass::ReceiveMessage( classID, msg );
return;
}
int messageType = msg.ReadByte();
switch( messageType )
{
case HOPWIRE_START_EXPLOSION:
{
m_ExplosionEffect.SetActive();
m_ExplosionEffect.SetOwner( this );
m_ExplosionEffect.StartExplosion();
}
break;
case HOPWIRE_STOP_EXPLOSION:
{
m_ExplosionEffect.StopExplosion();
}
break;
default:
break;
}
}
void __fastcall hooks::hooked_postscreeneffects(void * thisptr, void * edx, CViewSetup * setup) {
static auto run_glow = []() -> void {
if (!g_ctx.available() || !g_ctx.m_local) {
return;
}
for (int i = 0; i < g_csgo.m_glow()->m_GlowObjectDefinitions.Count(); i++) {
if (g_csgo.m_glow()->m_GlowObjectDefinitions[i].IsUnused() || !g_csgo.m_glow()->m_GlowObjectDefinitions[i].GetEnt()) {
continue;
}
auto * object = &g_csgo.m_glow()->m_GlowObjectDefinitions[i];
auto entity = reinterpret_cast<entity_t*>(object->GetEnt());
if (!entity || entity->IsDormant()) {
continue;
}
if (entity == g_ctx.m_local) {
continue;
}
float color[3];
if (entity->m_iTeamNum() != g_ctx.m_local->m_iTeamNum()) {
if (!g_cfg.player.glow[GLOW_ENEMY].enabled)
continue;
color[0] = g_cfg.player.glow_color_enemy[0] / 255.0f;
color[1] = g_cfg.player.glow_color_enemy[1] / 255.0f;
color[2] = g_cfg.player.glow_color_enemy[2] / 255.0f;
}
if (entity->m_iTeamNum() == g_ctx.m_local->m_iTeamNum()) {
if (!g_cfg.player.glow[GLOW_TEAMMATE].enabled)
continue;
color[0] = g_cfg.player.glow_color_teammate[0] / 255.0f;
color[1] = g_cfg.player.glow_color_teammate[1] / 255.0f;
color[2] = g_cfg.player.glow_color_teammate[2] / 255.0f;
}
if (entity->GetClientClass()->m_ClassID == 35) {
object->Set(color[0], color[1], color[2],
g_cfg.player.glowopacity / 100.0f,
g_cfg.player.glowbloom / 100.0f,
g_cfg.player.glow_type);
}
}
};
static auto original_fn = clientmode_hook->get_func_address<DoPostScreenEffects_t>(44);
if (g_cfg.player.glow[GLOW_TEAMMATE].enabled || g_cfg.player.glow[GLOW_ENEMY].enabled)
run_glow();
return original_fn(thisptr, setup);
}
// Server to client message received
void C_NPC_Advisor::ReceiveMessage( int classID, bf_read &msg )
{
if ( classID != GetClientClass()->m_ClassID )
{
// message is for subclass
BaseClass::ReceiveMessage( classID, msg );
return;
}
int messageType = msg.ReadByte();
switch( messageType )
{
case ADVISOR_MSG_START_BEAM:
{
int eindex = msg.ReadLong();
StartBeamFX(IndexToEntity(eindex));
}
break;
case ADVISOR_MSG_STOP_BEAM:
{
int eindex = msg.ReadLong();
StopBeamFX(IndexToEntity(eindex));
}
break;
case ADVISOR_MSG_STOP_ALL_BEAMS:
{
ParticleProp()->StopEmission();
}
break;
case ADVISOR_MSG_START_ELIGHT:
{
StartElight();
}
break;
case ADVISOR_MSG_STOP_ELIGHT:
{
StopElight();
}
break;
default:
AssertMsg1( false, "Received unknown message %d", messageType);
}
}
//-----------------------------------------------------------------------------
// Purpose: Receive messages from the server
// Input : classID - class to receive the message
// &msg - message in question
//-----------------------------------------------------------------------------
void C_GrenadeHopwire::ReceiveMessage( int classID, bf_read &msg )
{
if ( classID != GetClientClass()->m_ClassID )
{
// Message is for subclass
BaseClass::ReceiveMessage( classID, msg );
return;
}
int messageType = msg.ReadByte();
switch( messageType )
{
case HOPWIRE_START_EXPLOSION:
{
m_ExplosionEffect.SetActive();
m_ExplosionEffect.SetOwner( this );
#ifdef C17
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if (pPlayer)
{
//pPlayer->EmitSound( "Weapon_AR3.Geiger" );
pPlayer->EmitSound("Weapon_AR3.BlackHole");
}
else
{
//No player?
//Emit from the blackhole instead.
//EmitSound( "Weapon_AR3.Geiger" );
EmitSound("Weapon_AR3.BlackHole");
}
#endif
m_ExplosionEffect.StartExplosion();
}
break;
case HOPWIRE_STOP_EXPLOSION:
{
m_ExplosionEffect.StopExplosion();
}
break;
default:
break;
}
}
void C_WalkerStrider::ReceiveMessage( int classID, bf_read &msg )
{
if ( classID != GetClientClass()->m_ClassID )
{
// message is for subclass
BaseClass::ReceiveMessage( classID, msg );
return;
}
Vector vHitPos;
msg.ReadBitVec3Coord( vHitPos );
CStriderBeamEffect eff;
eff.m_vHitPos = vHitPos;
eff.m_flStartTime = gpGlobals->curtime;
m_BeamEffects.AddToTail( eff );
}
void CDHLProjectile::ReceiveMessage( int classID, bf_read &msg )
{
if ( classID != GetClientClass()->m_ClassID )
{
// message is for subclass
BaseClass::ReceiveMessage( classID, msg );
return;
}
int iType = msg.ReadByte();
//Server is letting us know that we're about to be deleted
if ( iType == MSG_NOTIFY_REMOVAL )
{
if ( !m_bCollided )
{
Vector vecDir = vec3_origin;
if ( GetAbsVelocity() != vec3_origin )
vecDir = GetAbsVelocity();
else
vecDir = m_vecProjectileVelocity;
VectorNormalize( vecDir );
Vector vecStartPos = GetMoveType() == MOVETYPE_CUSTOM ? GetLocalOrigin() : m_vecProjectileOrigin;
//Try to plant a decal
trace_t decaltr;
UTIL_TraceLine( vecStartPos, vecStartPos + (vecDir * 120.0), MASK_SHOT, this, //Pretty long distance, but seems necessary in practice
COLLISION_GROUP_NONE, &decaltr );
//DebugDrawLine( decaltr.startpos, decaltr.endpos, 255, 0, 0, false, 3.0f );
if ( decaltr.DidHit() )
{
OnTouch( decaltr, true );
}
m_bCollided = true;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : length -
// *data -
// Output : void
//-----------------------------------------------------------------------------
void ReceiveMessage( int classID, bf_read &msg )
{
if ( classID != GetClientClass()->m_ClassID )
{
// message is for subclass
BaseClass::ReceiveMessage( classID, msg );
return;
}
int messageType = msg.ReadByte();
switch( messageType )
{
case GUNSHIP_MSG_STREAKS:
{
Vector pos;
msg.ReadBitVec3Coord( pos );
m_cannonFX.SetRenderOrigin( pos );
m_cannonFX.EffectInit( entindex(), LookupAttachment( "BellyGun" ) );
m_cannonFX.LimitTime( GUNSHIPFX_BIG_SHOT_TIME );
}
break;
case GUNSHIP_MSG_BIG_SHOT:
{
Vector tmp;
msg.ReadBitVec3Coord( tmp );
m_cannonFX.SetTime( GUNSHIPFX_BIG_SHOT_TIME );
m_cannonFX.LimitTime( 0 );
}
break;
case GUNSHIP_MSG_DEAD:
{
m_cannonFX.EffectShutdown();
}
break;
}
}
void CHLTVClientState::CopyNewEntity(
CEntityReadInfo &u,
int iClass,
int iSerialNum
)
{
ServerClass *pServerClass = SV_FindServerClass( iClass );
Assert( pServerClass );
ClientClass *pClientClass = GetClientClass( iClass );
Assert( pClientClass );
const int ent = u.m_nNewEntity;
// copy class & serial
CFrameSnapshot *pSnapshot = u.m_pTo->GetSnapshot();
pSnapshot->m_pEntities[ent].m_nSerialNumber = iSerialNum;
pSnapshot->m_pEntities[ent].m_pClass = pServerClass;
// Get either the static or instance baseline.
const void *pFromData = NULL;
int nFromBits = 0;
int nFromTick = 0; // MOTODO get tick when baseline last changed
PackedEntity *baseline = u.m_bAsDelta ? GetEntityBaseline( u.m_nBaseline, ent ) : NULL;
if ( baseline && baseline->m_pClientClass == pClientClass )
{
Assert( !baseline->IsCompressed() );
pFromData = baseline->GetData();
nFromBits = baseline->GetNumBits();
}
else
{
// Every entity must have a static or an instance baseline when we get here.
ErrorIfNot(
GetClassBaseline( iClass, &pFromData, &nFromBits ),
("HLTV_CopyNewEntity: GetDynamicBaseline(%d) failed.", iClass)
);
nFromBits *= 8; // convert to bits
}
// create new ChangeFrameList containing all properties set as changed
int nFlatProps = SendTable_GetNumFlatProps( pServerClass->m_pTable );
IChangeFrameList *pChangeFrame = NULL;
if ( !m_bSaveMemory )
{
pChangeFrame = AllocChangeFrameList( nFlatProps, nFromTick );
}
// Now make a PackedEntity and store the new packed data in there.
PackedEntity *pPackedEntity = framesnapshotmanager->CreatePackedEntity( pSnapshot, ent );
pPackedEntity->SetChangeFrameList( pChangeFrame );
pPackedEntity->SetServerAndClientClass( pServerClass, pClientClass );
// Make space for the baseline data.
char packedData[MAX_PACKEDENTITY_DATA];
bf_read fromBuf( "HLTV_ReadEnterPVS1", pFromData, Bits2Bytes( nFromBits ), nFromBits );
bf_write writeBuf( "HLTV_ReadEnterPVS2", packedData, sizeof( packedData ) );
int changedProps[MAX_DATATABLE_PROPS];
// decode basline, is compressed against zero values
int nChangedProps = RecvTable_MergeDeltas( pClientClass->m_pRecvTable, &fromBuf,
u.m_pBuf, &writeBuf, -1, false, changedProps );
// update change tick in ChangeFrameList
if ( pChangeFrame )
{
pChangeFrame->SetChangeTick( changedProps, nChangedProps, pSnapshot->m_nTickCount );
}
if ( u.m_bUpdateBaselines )
{
SetEntityBaseline( (u.m_nBaseline==0)?1:0, pClientClass, u.m_nNewEntity, packedData, writeBuf.GetNumBytesWritten() );
}
pPackedEntity->AllocAndCopyPadded( packedData, writeBuf.GetNumBytesWritten() );
// If ent doesn't think it's in PVS, signal that it is
Assert( u.m_pTo->last_entity <= ent );
u.m_pTo->last_entity = ent;
u.m_pTo->transmit_entity.Set( ent );
}
void C_QUA_Strider::ReceiveMessage( int classID, bf_read &msg )
{
if ( classID != GetClientClass()->m_ClassID )
{
// message is for subclass
BaseClass::ReceiveMessage( classID, msg );
return;
}
int messageType = msg.ReadByte();
switch( messageType )
{
case STRIDER_MSG_STREAKS:
{
Vector pos;
msg.ReadBitVec3Coord( pos );
m_cannonFX.SetRenderOrigin( pos );
m_cannonFX.EffectInit( entindex(), LookupAttachment( "BigGun" ) );
m_cannonFX.LimitTime( STRIDERFX_BIG_SHOT_TIME );
}
break;
case STRIDER_MSG_BIG_SHOT:
{
Vector tmp;
msg.ReadBitVec3Coord( tmp );
m_cannonFX.SetTime( STRIDERFX_BIG_SHOT_TIME );
m_cannonFX.LimitTime( STRIDERFX_END_ALL_TIME );
}
break;
case STRIDER_MSG_DEAD:
{
m_cannonFX.EffectShutdown();
}
break;
case STRIDER_MSG_MACHINEGUN:
{
// Necesario en MP, porque si no no se ven las balas.
Vector muz,dir,spr;
msg.ReadBitVec3Coord( muz );
msg.ReadBitVec3Coord( dir );
msg.ReadBitVec3Coord( spr );
int ammo = msg.ReadByte();
//Warning("x: %f,x: %f,x: %f,ammo: %i",muz.x,dir.x,spr.x,ammo);
FireBulletsInfo_t info;
info.m_iShots = 1;
info.m_vecSrc = muz;
info.m_vecDirShooting = dir;
info.m_vecSpread = spr;
info.m_pAttacker = (C_BaseEntity *) m_hPlayer;
info.m_flDistance = MAX_TRACE_LENGTH;
info.m_iAmmoType = ammo;
info.m_flDamage = 75;
info.m_iPlayerDamage = 150;
info.m_iTracerFreq = 1;
FireBullets(info);
CEffectData data;
data.m_nAttachmentIndex = LookupAttachment( "MiniGun" );
data.m_hEntity = entindex();
DispatchEffect("QUA_StriderMuzzleFlash",data );
}
}
}
void Glow::Run()
{
for (auto i = 0; i < g_GlowObjManager->m_GlowObjectDefinitions.Count(); i++) {
auto& glowObject = g_GlowObjManager->m_GlowObjectDefinitions[i];
auto entity = reinterpret_cast<C_BasePlayer*>(glowObject.m_pEntity);
glowObject.m_flAlpha = 50.0f;
if (glowObject.IsUnused())
continue;
if (!entity || entity->IsDormant())
continue;
auto class_id = entity->GetClientClass()->m_ClassID;
auto color = Color{};
switch (class_id) {
case CCSPlayer:
{
auto is_enemy = entity->m_iTeamNum() != g_LocalPlayer->m_iTeamNum();
if (entity->HasC4() && is_enemy && g_Options.glow_c4_carrier) {
color = g_Options.color_glow_c4_carrier;
break;
}
if (!g_Options.glow_players || !entity->IsAlive())
continue;
if (!is_enemy && g_Options.glow_enemies_only)
continue;
color = is_enemy ? g_Options.color_glow_enemy : g_Options.color_glow_ally;
break;
}
case CChicken:
if (!g_Options.glow_chickens)
continue;
entity->m_bShouldGlow() = true;
color = g_Options.color_glow_chickens;
break;
case CBaseAnimating:
if (!g_Options.glow_defuse_kits)
continue;
color = g_Options.color_glow_defuse;
break;
case CPlantedC4:
if (!g_Options.glow_planted_c4)
continue;
color = g_Options.color_glow_planted_c4;
break;
case CHostage:
if (!g_Options.glow_planted_c4)
continue;
color = g_Options.color_glow_planted_c4;
default:
{
if (entity->IsWeapon()) {
if (!g_Options.glow_weapons)
continue;
color = g_Options.color_glow_weapons;
}
}
}
switch (g_Options.GlowType)
{
case 0:
glowObject.m_nGlowStyle = 0;
break;
case 1:
glowObject.m_nGlowStyle = 2;
break;
case 2:
glowObject.m_nGlowStyle = 1;
break;
}
glowObject.m_flRed = color.r() / 255.0f;
glowObject.m_flGreen = color.g() / 255.0f;
glowObject.m_flBlue = color.b() / 255.0f;
glowObject.m_flAlpha = color.a() / 255.0f;
glowObject.m_bRenderWhenOccluded = true;
glowObject.m_bRenderWhenUnoccluded = false;
}
}
