Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

1155 lines
36 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "cbase.h"
#include "tf_weapon_jar.h"
#include "decals.h"
// Client specific.
#ifdef CLIENT_DLL
#include "c_tf_player.h"
// Server specific.
#else
#include "soundent.h"
#include "te_effect_dispatch.h"
#include "tf_player.h"
#include "func_break.h"
#include "func_nogrenades.h"
#include "Sprite.h"
#include "tf_fx.h"
#include "tf_team.h"
#include "tf_gamestats.h"
#include "tf_gamerules.h"
#include "particle_parse.h"
#include "bone_setup.h"
#endif
//=============================================================================
//
// Weapon Jar tables.
//
IMPLEMENT_NETWORKCLASS_ALIASED( TFJar, DT_TFWeaponJar )
BEGIN_NETWORK_TABLE( CTFJar, DT_TFWeaponJar )
END_NETWORK_TABLE()
BEGIN_PREDICTION_DATA( CTFJar )
END_PREDICTION_DATA()
LINK_ENTITY_TO_CLASS( tf_weapon_jar, CTFJar );
PRECACHE_WEAPON_REGISTER( tf_weapon_jar );
IMPLEMENT_NETWORKCLASS_ALIASED( TFJarMilk, DT_TFWeaponJarMilk )
BEGIN_NETWORK_TABLE( CTFJarMilk, DT_TFWeaponJarMilk )
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_weapon_jar_milk, CTFJarMilk );
PRECACHE_WEAPON_REGISTER( tf_weapon_jar_milk );
IMPLEMENT_NETWORKCLASS_ALIASED( TFCleaver, DT_TFWeaponCleaver )
BEGIN_NETWORK_TABLE( CTFCleaver, DT_TFWeaponCleaver )
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_weapon_cleaver, CTFCleaver );
PRECACHE_WEAPON_REGISTER( tf_weapon_cleaver );
// Projectile tables.
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_Jar, DT_TFProjectile_Jar )
BEGIN_NETWORK_TABLE( CTFProjectile_Jar, DT_TFProjectile_Jar )
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_projectile_jar, CTFProjectile_Jar );
PRECACHE_WEAPON_REGISTER( tf_projectile_jar );
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_JarMilk, DT_TFProjectile_JarMilk )
BEGIN_NETWORK_TABLE( CTFProjectile_JarMilk, DT_TFProjectile_JarMilk )
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_projectile_jar_milk, CTFProjectile_JarMilk );
PRECACHE_WEAPON_REGISTER( tf_projectile_jar_milk );
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_Cleaver, DT_TFProjectile_Cleaver )
BEGIN_NETWORK_TABLE( CTFProjectile_Cleaver, DT_TFProjectile_Cleaver )
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_projectile_cleaver, CTFProjectile_Cleaver );
PRECACHE_WEAPON_REGISTER( tf_projectile_cleaver );
#define TF_JAR_LAUNCH_SPEED 1000.f
#define TF_CLEAVER_LAUNCH_SPEED 7000.f
#define TF_WEAPON_PEEJAR_MODEL "models/weapons/c_models/urinejar.mdl"
#define TF_WEAPON_FESTIVE_PEEJAR_MODEL "models/weapons/c_models/c_xms_urinejar.mdl"
#ifdef STAGING_ONLY
#define TF_WEAPON_MILKJAR_MODEL "models/workshop/weapons/c_models/c_madmilk/c_madmilk.mdl"
#define TF_WEAPON_CLEAVER_MODEL "models/workshop_partner/weapons/c_models/c_sd_cleaver/c_sd_cleaver.mdl"
#else
#define TF_WEAPON_MILKJAR_MODEL "models/weapons/c_models/c_madmilk/c_madmilk.mdl"
#define TF_WEAPON_CLEAVER_MODEL "models/weapons/c_models/c_sd_cleaver/c_sd_cleaver.mdl"
#endif
#define TF_WEAPON_PEEJAR_EXPLODE_SOUND "Jar.Explode"
#define TF_WEAPON_CLEAVER_IMPACT_FLESH_SOUND "Cleaver.ImpactFlesh"
#define TF_WEAPON_CLEAVER_IMPACT_WORLD_SOUND "Cleaver.ImpactWorld"
#ifdef STAGING_ONLY
#define TF_WEAPON_WATER_BALLOON_KILL_SOUND "Game.PenetrationKill"
#define TF_WEAPON_WATER_BALLOON_HIT_SOUND "Weapon_waterbomb.hit"
#define TF_WEAPON_WATER_BALLOON_SCORE_SOUND "Weapon_waterbomb.score"
#define TF_BREAD_MODEL "models/props_gameplay/small_loaf.mdl"
#define TF_WATERBALLOON_RADIUS 32
#define TF_WATERBALLOON_CHARGEDRADIUS 64
#define TF_WATERBALLOON_EXPLODE_SOUND "Weapon_waterbomb.explode"
#endif
//=============================================================================
//
// Weapon Jar functions.
//
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFJar::CTFJar()
{
}
float CTFJar::GetProjectileSpeed( void )
{
return TF_JAR_LAUNCH_SPEED;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFJar::PrimaryAttack( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
int iJarCount = pPlayer->GetAmmoCount( m_iPrimaryAmmoType );
if ( iJarCount == 0 )
return;
if ( ( pPlayer->GetWaterLevel() == WL_Eyes ) && !CanThrowUnderWater() )
return;
BaseClass::PrimaryAttack();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseEntity *CTFJar::FireJar( CTFPlayer *pPlayer )
{
StartEffectBarRegen();
SetContextThink( &CTFJar::TossJarThink, gpGlobals->curtime + 0.1f, "TOSS_JAR_THINK" );
return NULL;
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFProjectile_Jar *CTFJar::CreateJarProjectile( const Vector &position, const QAngle &angles, const Vector &velocity,
const AngularImpulse &angVelocity, CBaseCombatCharacter *pOwner, const CTFWeaponInfo &weaponInfo )
{
return CTFProjectile_Jar::Create( position, angles, velocity, angVelocity, pOwner, weaponInfo );
}
#endif
#ifdef GAME_DLL
Vector CTFJar::GetVelocityVector( const Vector &vecForward, const Vector &vecRight, const Vector &vecUp )
{
return ( ( vecForward * GetProjectileSpeed() ) + ( vecUp * 200.0f ) + ( random->RandomFloat( -10.0f, 10.0f ) * vecRight ) +
( random->RandomFloat( -10.0f, 10.0f ) * vecUp ) );
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFJar::TossJarThink( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
PlayWeaponShootSound();
#ifdef GAME_DLL
Vector vecForward, vecRight, vecUp;
AngleVectors( pPlayer->EyeAngles(), &vecForward, &vecRight, &vecUp );
float fRight = 8.f;
if ( IsViewModelFlipped() )
{
fRight *= -1;
}
Vector vecSrc = pPlayer->Weapon_ShootPosition();
vecSrc += vecForward * 16.0f + vecRight * fRight + vecUp * -6.0f;
trace_t trace;
Vector vecEye = pPlayer->EyePosition();
CTraceFilterSimple traceFilter( this, COLLISION_GROUP_NONE );
UTIL_TraceHull( vecEye, vecSrc, -Vector(8,8,8), Vector(8,8,8), MASK_SOLID_BRUSHONLY, &traceFilter, &trace );
// If we started in solid, don't let them fire at all
if ( trace.startsolid )
return;
Vector vecVelocity = GetVelocityVector( vecForward, vecRight, vecUp );
CTFProjectile_Jar *pProjectile = CreateJarProjectile( trace.endpos, pPlayer->EyeAngles(), vecVelocity,
GetAngularImpulse(), pPlayer, GetTFWpnData() );
if ( pProjectile )
{
pProjectile->SetCritical( IsCurrentAttackACrit() );
pProjectile->SetLauncher( this );
}
if ( ShouldSpeakWhenFiring() )
{
pPlayer->SpeakWeaponFire( MP_CONCEPT_JARATE_LAUNCH );
}
#endif
}
//-----------------------------------------------------------------------------
void CTFJar::GetProjectileEntityName( CAttribute_String *attrProjectileEntityName )
{
static CSchemaAttributeDefHandle pAttrDef_ProjectileEntityName( "projectile entity name" );
CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( pAttrDef_ProjectileEntityName && pItem )
{
//CAttribute_String attrProjectileEntityName;
pItem->FindAttribute( pAttrDef_ProjectileEntityName, attrProjectileEntityName );
}
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFProjectile_Jar::CTFProjectile_Jar()
{
m_vCollisionVelocity = Vector( 0,0,0 );
m_iProjectileType = TF_PROJECTILE_JAR;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Jar::Precache()
{
PrecacheModel( TF_WEAPON_PEEJAR_MODEL );
PrecacheModel( TF_WEAPON_FESTIVE_PEEJAR_MODEL );
PrecacheModel( "models/weapons/c_models/c_breadmonster/c_breadmonster.mdl" );
PrecacheScriptSound( TF_WEAPON_PEEJAR_EXPLODE_SOUND );
BaseClass::Precache();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Jar::SetCustomPipebombModel()
{
// Check for Model Override
int iProjectile = 0;
CTFPlayer *pThrower = ToTFPlayer( GetThrower() );
if ( pThrower && pThrower->GetActiveWeapon() )
{
CALL_ATTRIB_HOOK_INT_ON_OTHER( pThrower->GetActiveWeapon(), iProjectile, override_projectile_type );
switch ( iProjectile )
{
case TF_PROJECTILE_FESTIVE_JAR :
m_iProjectileType = iProjectile;
SetModel( TF_WEAPON_FESTIVE_PEEJAR_MODEL );
return;
case TF_PROJECTILE_BREADMONSTER_JARATE:
case TF_PROJECTILE_BREADMONSTER_MADMILK:
m_iProjectileType = iProjectile;
SetModel( "models/weapons/c_models/c_breadmonster/c_breadmonster.mdl" );
return;
}
}
SetModel( TF_WEAPON_PEEJAR_MODEL );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFProjectile_Jar* CTFProjectile_Jar::Create( const Vector &position, const QAngle &angles,
const Vector &velocity, const AngularImpulse &angVelocity,
CBaseCombatCharacter *pOwner, const CTFWeaponInfo &weaponInfo )
{
CTFProjectile_Jar *pGrenade = static_cast<CTFProjectile_Jar*>( CBaseEntity::CreateNoSpawn( "tf_projectile_jar", position, angles, pOwner ) );
if ( pGrenade )
{
// Set the pipebomb mode before calling spawn, so the model & associated vphysics get setup properly.
pGrenade->SetPipebombMode();
DispatchSpawn( pGrenade );
pGrenade->InitGrenade( velocity, angVelocity, pOwner, weaponInfo );
#ifdef _X360
if ( pGrenade->m_iType != TF_GL_MODE_REMOTE_DETONATE )
{
pGrenade->SetDamage( TF_WEAPON_GRENADE_XBOX_DAMAGE );
}
#endif
pGrenade->m_flFullDamage = 0;
pGrenade->ApplyLocalAngularVelocityImpulse( angVelocity );
}
return pGrenade;
}
extern void ExtinguishPlayer( CEconEntity *pExtinguisher, CTFPlayer *pOwner, CTFPlayer *pTarget, const char *pExtinguisherName );
void JarExplode( int iEntIndex, CTFPlayer *pAttacker, CBaseEntity *pOriginalWeapon, CBaseEntity *pWeapon, const Vector& vContactPoint, int iTeam, float flRadius, ETFCond cond, float flDuration, const char *pszImpactEffect )
{
// Splash!
CPVSFilter particleFilter( vContactPoint );
TE_TFParticleEffect( particleFilter, 0.0, pszImpactEffect, vContactPoint, vec3_angle );
// Explosion effect.
CBroadcastRecipientFilter soundFilter;
Vector vecOrigin = vContactPoint;
CBaseEntity::EmitSound( soundFilter, iEntIndex, TF_WEAPON_PEEJAR_EXPLODE_SOUND, &vecOrigin );
// Treat this trace exactly like radius damage
CTraceFilterIgnorePlayers traceFilter( pAttacker, COLLISION_GROUP_PROJECTILE );
// Splash pee on everyone nearby.
CBaseEntity *pListOfEntities[32];
int iEntities = UTIL_EntitiesInSphere( pListOfEntities, 32, vContactPoint, flRadius, FL_CLIENT );
for ( int i = 0; i < iEntities; ++i )
{
CTFPlayer *pPlayer = ToTFPlayer( pListOfEntities[i] );
if ( !pPlayer || !pPlayer->IsAlive() )
continue;
// Do a quick trace to see if there's any geometry in the way.
// Pee isn't stopped by other entities. Splishy splashy.
trace_t trace;
UTIL_TraceLine( vContactPoint, pPlayer->GetAbsOrigin(), ( MASK_SHOT & ~( CONTENTS_HITBOX ) ), &traceFilter, &trace );
if ( trace.DidHitWorld() )
continue;
// Drench the target.
if ( pPlayer->GetTeamNumber() != iTeam )
{
if ( pPlayer->m_Shared.IsInvulnerable() )
continue;
if ( pPlayer->m_Shared.InCond( TF_COND_PHASE ) || pPlayer->m_Shared.InCond( TF_COND_PASSTIME_INTERCEPTION ) )
continue;
if ( !pPlayer->CanGetWet() )
continue;
pPlayer->m_Shared.AddCond( cond, flDuration, pAttacker );
pPlayer->m_Shared.SetPeeAttacker( pAttacker );
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_JARATE_HIT );
if ( pAttacker )
{
if ( pPlayer->IsPlayerClass( TF_CLASS_SPY ) && pPlayer->m_Shared.GetPercentInvisible() == 1.0f )
{
pAttacker->AwardAchievement( ACHIEVEMENT_TF_SNIPER_JARATE_REVEAL_SPY );
}
float flStun = 1.0f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pAttacker, flStun, applies_snare_effect );
if ( flStun != 1.0f )
{
pPlayer->m_Shared.StunPlayer( flDuration, flStun, TF_STUN_MOVEMENT, pAttacker );
}
// Stats tracking?
if ( cond == TF_COND_URINE || cond == TF_COND_MAD_MILK )
{
if ( TFGameRules() && TFGameRules()->IsPVEModeActive() )
{
// These if statements are intentionally split to avoid falling through to the normal kKillEaterEvent_PeeVictims event if we're in
// IsPVEModeActive() but not a robot, or don't have the stun.
if ( pPlayer->GetTeamNumber() == TF_TEAM_PVE_INVADERS && flStun != 1.0f )
{
EconEntity_OnOwnerKillEaterEvent( dynamic_cast<CEconEntity *>( pWeapon ), pAttacker, pPlayer, kKillEaterEvent_RobotsSlowed );
}
}
else
{
EconEntity_OnOwnerKillEaterEvent( dynamic_cast<CEconEntity *>( pWeapon ), pAttacker, pPlayer, kKillEaterEvent_PeeVictims );
}
}
// Tell the clients involved in the jarate
CRecipientFilter involved_filter;
involved_filter.AddRecipient( pPlayer );
involved_filter.AddRecipient( pAttacker );
UserMessageBegin( involved_filter, "PlayerJarated" );
WRITE_BYTE( pAttacker->entindex() );
WRITE_BYTE( pPlayer->entindex() );
MessageEnd();
const char *pszEvent = NULL;
switch( cond )
{
case TF_COND_URINE:
pszEvent = "jarate_attack";
break;
case TF_COND_MAD_MILK:
pszEvent = "milk_attack";
break;
}
if ( pszEvent && pszEvent[0] )
{
UTIL_LogPrintf( "\"%s<%i><%s><%s>\" triggered \"%s\" against \"%s<%i><%s><%s>\" with \"%s\" (attacker_position \"%d %d %d\") (victim_position \"%d %d %d\")\n",
pAttacker->GetPlayerName(),
pAttacker->GetUserID(),
pAttacker->GetNetworkIDString(),
pAttacker->GetTeam()->GetName(),
pszEvent,
pPlayer->GetPlayerName(),
pPlayer->GetUserID(),
pPlayer->GetNetworkIDString(),
pPlayer->GetTeam()->GetName(),
"tf_weapon_jar",
(int)pAttacker->GetAbsOrigin().x,
(int)pAttacker->GetAbsOrigin().y,
(int)pAttacker->GetAbsOrigin().z,
(int)pPlayer->GetAbsOrigin().x,
(int)pPlayer->GetAbsOrigin().y,
(int)pPlayer->GetAbsOrigin().z );
}
}
}
else
{
if ( pAttacker && pPlayer->m_Shared.InCond( TF_COND_BURNING ) )
{
ExtinguishPlayer( dynamic_cast<CEconEntity *>( pWeapon ), pAttacker, pPlayer, "tf_weapon_jar" );
// Return some percentage of the jar to the thrown weapon if extinguishing an ally
auto pLauncher = dynamic_cast< CTFWeaponBase* >( pOriginalWeapon );
if ( pLauncher && pAttacker != pPlayer && pLauncher->HasEffectBarRegeneration() )
{
float fCooldown = 1.0f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pLauncher, fCooldown, extinguish_reduces_cooldown );
fCooldown = 1.0f - fCooldown;
if ( fCooldown > 0 )
{
if ( pLauncher->GetEffectBarProgress() < fCooldown )
{
float fDuration = pLauncher->GetEffectBarRechargeTime();
float fIncrement = fDuration * fCooldown;
pLauncher->DecrementBarRegenTime( fIncrement );
}
}
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Jar::Explode( trace_t *pTrace, int bitsDamageType )
{
SetModelName( NULL_STRING );//invisible
AddSolidFlags( FSOLID_NOT_SOLID );
m_takedamage = DAMAGE_NO;
// Pull out of the wall a bit.
if ( pTrace->fraction != 1.0 )
{
SetAbsOrigin( pTrace->endpos + ( pTrace->plane.normal * 1.0f ) );
}
CTFPlayer *pThrower = ToTFPlayer( GetThrower() );
JarExplode( entindex(), pThrower, GetOriginalLauncher(), GetLauncher(), GetAbsOrigin(), GetTeamNumber(), GetDamageRadius(), GetEffectCondition(), 10.f, GetImpactEffect() );
// Debug radius draw.
//DrawRadius( GetDamageRadius() );
SetContextThink( &CBaseGrenade::SUB_Remove, gpGlobals->curtime, "RemoveThink" );
SetTouch( NULL );
AddEffects( EF_NODRAW );
SetAbsVelocity( vec3_origin );
}
//-----------------------------------------------------------------------------
void CTFProjectile_Jar::PipebombTouch( CBaseEntity *pOther )
{
if ( pOther == GetThrower() )
return;
if ( !pOther->IsSolid() || pOther->IsSolidFlagSet( FSOLID_VOLUME_CONTENTS ) )
return;
if ( !pOther->IsWorld() && !pOther->IsPlayer() )
return;
// Don't collide with teammate if we're still in the grace period.
if ( pOther->IsPlayer() && pOther->GetTeamNumber() == GetTeamNumber() && !CanCollideWithTeammates() )
{
// Exception to this rule - if we're a jar or milk, and our potential victim is on fire, then allow collision after all.
// If we're a jar or milk, then still allow collision if our potential victim is on fire.
if (m_iProjectileType == TF_PROJECTILE_JAR || m_iProjectileType == TF_PROJECTILE_JAR_MILK)
{
auto victim = ToTFPlayer(pOther);
if (!victim->m_Shared.InCond(TF_COND_BURNING))
{
return;
}
}
else
{
return;
}
}
// Handle hitting skybox (disappear).
trace_t pTrace;
Vector velDir = GetAbsVelocity();
if ( velDir.IsZero() && pOther && pOther->IsPlayer() )
{
velDir = pOther->WorldSpaceCenter() - GetAbsOrigin();
}
VectorNormalize( velDir );
Vector vecSpot = GetAbsOrigin() - velDir * 32;
UTIL_TraceLine( vecSpot, vecSpot + velDir * 64, MASK_SOLID, this, COLLISION_GROUP_NONE, &pTrace );
if ( pTrace.fraction < 1.0 && pTrace.surface.flags & SURF_SKY )
{
UTIL_Remove( this );
return;
}
// If we already touched a surface then we're not exploding on contact anymore.
if ( m_bTouched == true )
return;
OnHit( pOther );
if ( m_iProjectileType == TF_PROJECTILE_BREADMONSTER_JARATE || m_iProjectileType == TF_PROJECTILE_BREADMONSTER_MADMILK )
{
OnBreadMonsterHit( pOther, &pTrace );
}
if ( ExplodesOnHit() )
{
// Save this entity as enemy, they will take 100% damage if applicable
m_hEnemy = pOther;
Explode( &pTrace, GetDamageType() );
}
}
//-----------------------------------------------------------------------------
void CTFProjectile_Jar::OnBreadMonsterHit( CBaseEntity *pOther, trace_t *pTrace )
{
if ( m_iProjectileType != TF_PROJECTILE_BREADMONSTER_JARATE && m_iProjectileType != TF_PROJECTILE_BREADMONSTER_MADMILK )
return;
CTFPlayer *pVictim = ToTFPlayer( pOther );
if ( !pVictim || pVictim->GetTeamNumber() == GetTeamNumber() )
return;
// This is a player on the other team, attach a breadmonster
CTFPlayer *pOwner = ToTFPlayer( GetThrower() );
// Attach Breadmonster to Victim
CreateStickyAttachmentToTarget( pOwner, pVictim, pTrace );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Jar::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent )
{
BaseClass::VPhysicsCollision( index, pEvent );
int otherIndex = !index;
CBaseEntity *pHitEntity = pEvent->pEntities[otherIndex];
if ( !pHitEntity )
return;
if ( pHitEntity->IsWorld() )
{
OnHitWorld();
}
// Break if we hit the world.
bool bIsDynamicProp = ( NULL != dynamic_cast<CDynamicProp *>( pHitEntity ) );
if ( ExplodesOnHit() && pHitEntity && ( pHitEntity->IsWorld() || bIsDynamicProp ) )
{
// Explode immediately next frame. (Can't explode in the collision callback.)
m_vCollisionVelocity = pEvent->preVelocity[index];
SetContextThink( &CTFProjectile_Jar::VPhysicsCollisionThink, gpGlobals->curtime, "JarCollisionThink" );
}
}
//-----------------------------------------------------------------------------
// Purpose: Handles exploding after a vphysics collision has happened.
// This prevents changing collision properties during the vphysics callback itself.
//-----------------------------------------------------------------------------
void CTFProjectile_Jar::VPhysicsCollisionThink( void )
{
if ( !ExplodesOnHit() )
return;
trace_t pTrace;
Vector velDir = m_vCollisionVelocity;
VectorNormalize( velDir );
Vector vecSpot = GetAbsOrigin() - velDir * 16;
UTIL_TraceLine( vecSpot, vecSpot + velDir * 32, MASK_SOLID, this, COLLISION_GROUP_NONE, &pTrace );
Explode( &pTrace, GetDamageType() );
}
//-----------------------------------------------------------------------------
bool CTFProjectile_Jar::PositionArrowOnBone( mstudiobbox_t *pBox, CBaseAnimating *pOtherAnim )
{
CStudioHdr *pStudioHdr = pOtherAnim->GetModelPtr();
if ( !pStudioHdr )
return false;
mstudiohitboxset_t *set = pStudioHdr->pHitboxSet( pOtherAnim->GetHitboxSet() );
if ( !set )
return false;
if ( !set->numhitboxes ) // Target must have hit boxes.
return false;
if ( pBox->bone < 0 || pBox->bone >= pStudioHdr->numbones() ) // Bone index must be valid.
return false;
CBoneCache *pCache = pOtherAnim->GetBoneCache();
if ( !pCache )
return false;
matrix3x4_t *bone_matrix = pCache->GetCachedBone( pBox->bone );
if ( !bone_matrix )
return false;
Vector vecBoxAbsMins, vecBoxAbsMaxs;
TransformAABB( *bone_matrix, pBox->bbmin, pBox->bbmax, vecBoxAbsMins, vecBoxAbsMaxs );
// Adjust the arrow so it isn't exactly in the center of the box.
Vector position;
Vector vecDelta = vecBoxAbsMaxs - vecBoxAbsMins;
float frand = (float)rand() / VALVE_RAND_MAX;
position.x = vecBoxAbsMins.x + vecDelta.x*0.6f - vecDelta.x*frand*0.2f;
frand = (float)rand() / VALVE_RAND_MAX;
position.y = vecBoxAbsMins.y + vecDelta.y*0.6f - vecDelta.y*frand*0.2f;
frand = (float)rand() / VALVE_RAND_MAX;
position.z = vecBoxAbsMins.z + vecDelta.z*0.6f - vecDelta.z*frand*0.2f;
SetAbsOrigin( position );
return true;
}
//-----------------------------------------------------------------------------
void CTFProjectile_Jar::GetBoneAttachmentInfo( mstudiobbox_t *pBox, CBaseAnimating *pOtherAnim, Vector &bonePosition, QAngle &boneAngles, int &boneIndexAttached, int &physicsBoneIndex )
{
// Find a bone to stick to.
matrix3x4_t arrowWorldSpace;
MatrixCopy( EntityToWorldTransform(), arrowWorldSpace );
// Get the bone info so we can follow the bone.
boneIndexAttached = pBox->bone;
physicsBoneIndex = pOtherAnim->GetPhysicsBone( boneIndexAttached );
matrix3x4_t boneToWorld;
pOtherAnim->GetBoneTransform( boneIndexAttached, boneToWorld );
Vector attachedBonePos;
QAngle attachedBoneAngles;
pOtherAnim->GetBonePosition( boneIndexAttached, attachedBonePos, attachedBoneAngles );
// Transform my current position/orientation into the hit bone's space.
matrix3x4_t worldToBone, localMatrix;
MatrixInvert( boneToWorld, worldToBone );
ConcatTransforms( worldToBone, arrowWorldSpace, localMatrix );
MatrixAngles( localMatrix, boneAngles, bonePosition );
}
//-----------------------------------------------------------------------------
void CTFProjectile_Jar::CreateStickyAttachmentToTarget( CTFPlayer *pOwner, CTFPlayer *pVictim, trace_t *trace )
{
// Dont stick to the sky!
if ( trace->surface.flags & SURF_SKY )
{
return;
}
// If I hit a player, remove the jar and replace with the face eater version
CStudioHdr *pStudioHdr = NULL;
mstudiohitboxset_t *set = NULL;
pStudioHdr = pVictim->GetModelPtr();
if ( pStudioHdr )
{
set = pStudioHdr->pHitboxSet( pVictim->GetHitboxSet() );
}
// Look for nearest hitbox
mstudiobbox_t *closest_box = NULL;
if ( trace->m_pEnt && trace->m_pEnt->GetTeamNumber() != GetTeamNumber() )
{
closest_box = set->pHitbox( trace->hitbox );
}
if ( closest_box )
{
if ( !PositionArrowOnBone( closest_box, pVictim ) )
return;
// See if we're supposed to stick in the target.
Vector bonePosition = vec3_origin;
QAngle boneAngles = QAngle( 0, 0, 0 );
int boneIndexAttached = -1;
int physicsBoneIndex = -1;
GetBoneAttachmentInfo( closest_box, pVictim, bonePosition, boneAngles, boneIndexAttached, physicsBoneIndex );
IGameEvent * event = gameeventmanager->CreateEvent( "arrow_impact" );
if ( event )
{
event->SetInt( "attachedEntity", pVictim->entindex() );
event->SetInt( "shooter", pOwner->entindex() );
event->SetInt( "attachedEntity", pVictim->entindex() );
event->SetInt( "boneIndexAttached", boneIndexAttached );
event->SetFloat( "bonePositionX", bonePosition.x );
event->SetFloat( "bonePositionY", bonePosition.y );
event->SetFloat( "bonePositionZ", bonePosition.z );
event->SetFloat( "boneAnglesX", boneAngles.x );
event->SetFloat( "boneAnglesY", boneAngles.y );
event->SetFloat( "boneAnglesZ", boneAngles.z );
event->SetInt( "projectileType", GetProjectileType() );
event->SetBool( "isCrit", IsCritical() );
gameeventmanager->FireEvent( event );
}
}
}
#endif
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CTFProjectile_Jar::GetTrailParticleName( void )
{
if ( GetTeamNumber() == TF_TEAM_BLUE )
{
return "peejar_trail_blu";
}
else
{
return "peejar_trail_red";
}
}
#endif
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFProjectile_Jar *CTFJarMilk::CreateJarProjectile( const Vector &position, const QAngle &angles, const Vector &velocity,
const AngularImpulse &angVelocity, CBaseCombatCharacter *pOwner, const CTFWeaponInfo &weaponInfo )
{
return CTFProjectile_JarMilk::Create( position, angles, velocity, angVelocity, pOwner, weaponInfo );
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_JarMilk::Precache()
{
PrecacheModel( TF_WEAPON_MILKJAR_MODEL );
BaseClass::Precache();
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFProjectile_JarMilk* CTFProjectile_JarMilk::Create( const Vector &position, const QAngle &angles,
const Vector &velocity, const AngularImpulse &angVelocity,
CBaseCombatCharacter *pOwner, const CTFWeaponInfo &weaponInfo )
{
CTFProjectile_JarMilk *pGrenade = static_cast<CTFProjectile_JarMilk*>( CBaseEntity::CreateNoSpawn( "tf_projectile_jar_milk", position, angles, pOwner ) );
if ( pGrenade )
{
// Set the pipebomb mode before calling spawn, so the model & associated vphysics get setup properly.
pGrenade->SetPipebombMode();
DispatchSpawn( pGrenade );
pGrenade->InitGrenade( velocity, angVelocity, pOwner, weaponInfo );
#ifdef _X360
if ( pGrenade->m_iType != TF_GL_MODE_REMOTE_DETONATE )
{
pGrenade->SetDamage( TF_WEAPON_GRENADE_XBOX_DAMAGE );
}
#endif
pGrenade->m_flFullDamage = 0;
pGrenade->ApplyLocalAngularVelocityImpulse( angVelocity );
}
return pGrenade;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_JarMilk::SetCustomPipebombModel()
{
// Check for Model Override
int iProjectile = 0;
CTFPlayer *pThrower = ToTFPlayer( GetThrower() );
if ( pThrower && pThrower->GetActiveWeapon() )
{
CALL_ATTRIB_HOOK_INT_ON_OTHER( pThrower->GetActiveWeapon(), iProjectile, override_projectile_type );
switch ( iProjectile )
{
case TF_PROJECTILE_BREADMONSTER_JARATE:
case TF_PROJECTILE_BREADMONSTER_MADMILK:
m_iProjectileType = iProjectile;
SetModel( "models/weapons/c_models/c_breadmonster/c_breadmonster_milk.mdl" );
return;
}
}
SetModel( TF_WEAPON_MILKJAR_MODEL );
}
#endif
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char* CTFJarMilk::ModifyEventParticles( const char* token )
{
if ( FStrEq( token, "energydrink_splash") )
{
CEconItemView *pItem = m_AttributeManager.GetItem();
int iSystems = pItem->GetStaticData()->GetNumAttachedParticles( GetTeamNumber() );
for ( int i = 0; i < iSystems; i++ )
{
attachedparticlesystem_t *pSystem = pItem->GetStaticData()->GetAttachedParticleData( GetTeamNumber(),i );
if ( pSystem->iCustomType == 1 )
{
return pSystem->pszSystemName;
}
}
}
return BaseClass::ModifyEventParticles( token );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFJarMilk::Holster( CBaseCombatWeapon *pSwitchingTo )
{
CTFPlayer *pOwner = ToTFPlayer( GetPlayerOwner() );
if ( pOwner && pOwner->IsLocalPlayer() )
{
C_BaseEntity *pParticleEnt = pOwner->GetViewModel(0);
if ( pParticleEnt )
{
pOwner->StopViewModelParticles( pParticleEnt );
}
}
return BaseClass::Holster( pSwitchingTo );
}
#endif
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
Vector CTFCleaver::GetVelocityVector( const Vector &vecForward, const Vector &vecRight, const Vector &vecUp )
{
Vector vecVelocity;
// Calculate the initial impulse on the item.
vecVelocity = Vector( 0.0f, 0.0f, 0.0f );
vecVelocity += vecForward * 10;
vecVelocity += vecUp * 1;
VectorNormalize( vecVelocity );
vecVelocity *= 3000;
return vecVelocity;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFProjectile_Jar *CTFCleaver::CreateJarProjectile( const Vector &position, const QAngle &angles, const Vector &velocity,
const AngularImpulse &angVelocity, CBaseCombatCharacter *pOwner, const CTFWeaponInfo &weaponInfo )
{
return CTFProjectile_Cleaver::Create( position, angles, velocity, angVelocity, pOwner, weaponInfo, GetSkin() );
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTFCleaver::GetProjectileSpeed( void )
{
return TF_CLEAVER_LAUNCH_SPEED;
}
//-----------------------------------------------------------------------------
void CTFCleaver::SecondaryAttack( void )
{
PrimaryAttack();
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char* CTFCleaver::ModifyEventParticles( const char* token )
{
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFCleaver::Holster( CBaseCombatWeapon *pSwitchingTo )
{
return BaseClass::Holster( pSwitchingTo );
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Cleaver::Precache()
{
PrecacheModel( TF_WEAPON_CLEAVER_MODEL );
PrecacheScriptSound( TF_WEAPON_CLEAVER_IMPACT_FLESH_SOUND );
PrecacheScriptSound( TF_WEAPON_CLEAVER_IMPACT_WORLD_SOUND );
BaseClass::Precache();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Cleaver::SetCustomPipebombModel()
{
SetModel( TF_WEAPON_CLEAVER_MODEL );
}
CTFProjectile_Cleaver::CTFProjectile_Cleaver()
{
#ifdef GAME_DLL
m_bHitPlayer = false;
m_bSoundPlayed = false;
#endif
}
#ifdef GAME_DLL
#define FLIGHT_TIME_TO_MAX_DMG 1.f
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Cleaver::OnHit( CBaseEntity *pOther )
{
SetModelName( NULL_STRING );//invisible
AddSolidFlags( FSOLID_NOT_SOLID );
CTFPlayer *pOwner = ToTFPlayer( GetThrower() );
if ( !pOwner )
return;
if ( !pOther || !pOther->IsPlayer() )
return;
CTFPlayer *pPlayer = ToTFPlayer( pOther );
if ( !pPlayer )
return;
// Can't bleed an invul player.
if ( pPlayer->m_Shared.IsInvulnerable() || pPlayer->m_Shared.InCond( TF_COND_INVULNERABLE_WEARINGOFF ) )
return;
if ( pPlayer->GetTeamNumber() == pOwner->GetTeamNumber() )
return;
if ( TFGameRules() && TFGameRules()->IsTruceActive() && pOwner->IsTruceValidForEnt() )
return;
bool bIsCriticalHit = IsCritical();
bool bIsMiniCrit = false;
float flBleedTime = 5.0f;
float flLifeTime = gpGlobals->curtime - m_flCreationTime;
if ( flLifeTime >= FLIGHT_TIME_TO_MAX_DMG )
{
bIsMiniCrit = true;
}
// just do the bleed effect directly since the bleed
// attribute comes from the inflictor, which is the cleaver.
pPlayer->m_Shared.MakeBleed( pOwner, (CTFCleaver *)GetLauncher(), flBleedTime );
// Give 'em a love tap.
const trace_t *pTrace = &CBaseEntity::GetTouchTrace();
trace_t *pNewTrace = const_cast<trace_t*>( pTrace );
CBaseEntity *pInflictor = GetLauncher();
CTakeDamageInfo info;
info.SetAttacker( pOwner );
info.SetInflictor( pInflictor );
info.SetWeapon( pInflictor );
info.SetDamage( GetDamage() );
info.SetDamageCustom( bIsMiniCrit ? TF_DMG_CUSTOM_CLEAVER_CRIT : TF_DMG_CUSTOM_CLEAVER );
info.SetDamagePosition( GetAbsOrigin() );
int iDamageType = GetDamageType();
if ( bIsCriticalHit )
{
iDamageType |= DMG_CRITICAL;
}
info.SetDamageType( iDamageType );
// Hurt 'em.
Vector dir;
AngleVectors( GetAbsAngles(), &dir );
pPlayer->DispatchTraceAttack( info, dir, pNewTrace );
ApplyMultiDamage();
// sound effects
EmitSound_t params;
params.m_flSoundTime = 0;
params.m_pflSoundDuration = 0;
params.m_pSoundName = TF_WEAPON_CLEAVER_IMPACT_FLESH_SOUND;
CPASFilter filter( GetAbsOrigin() );
filter.RemoveRecipient( pOwner );
EmitSound( filter, entindex(), params );
CSingleUserRecipientFilter attackerFilter( pOwner );
EmitSound( attackerFilter, pOwner->entindex(), params );
AddEffects( EF_NODRAW );
SetAbsVelocity( vec3_origin );
SetContextThink( &CBaseGrenade::SUB_Remove, gpGlobals->curtime + 2, "RemoveThink" );
SetTouch( NULL );
m_bHitPlayer = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Cleaver::Explode( trace_t *pTrace, int bitsDamageType )
{
if ( !m_bHitPlayer )
{
if ( !m_bSoundPlayed )
{
EmitSound( TF_WEAPON_CLEAVER_IMPACT_WORLD_SOUND );
m_bSoundPlayed = true;
}
SetContextThink( &CBaseGrenade::SUB_Remove, gpGlobals->curtime + 2, "RemoveThink" );
SetTouch( NULL );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Cleaver::Detonate( void )
{
trace_t tr;
Vector vecSpot;// trace starts here!
SetThink( NULL );
vecSpot = GetAbsOrigin() + Vector ( 0 , 0 , 8 );
UTIL_TraceLine ( vecSpot, vecSpot + Vector ( 0, 0, -32 ), MASK_SHOT_HULL, this, COLLISION_GROUP_NONE, & tr);
Explode( &tr, GetDamageType() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFProjectile_Cleaver* CTFProjectile_Cleaver::Create( const Vector &position, const QAngle &angles,
const Vector &velocity, const AngularImpulse &angVelocity,
CBaseCombatCharacter *pOwner, const CTFWeaponInfo &weaponInfo, int nSkin )
{
CTFProjectile_Cleaver *pGrenade = static_cast<CTFProjectile_Cleaver*>( CBaseEntity::CreateNoSpawn( "tf_projectile_cleaver", position, angles, pOwner ) );
if ( pGrenade )
{
// Set the pipebomb mode before calling spawn, so the model & associated vphysics get setup properly.
pGrenade->SetPipebombMode();
DispatchSpawn( pGrenade );
pGrenade->m_nSkin = nSkin;
pGrenade->InitGrenade( velocity, angVelocity, pOwner, weaponInfo );
pGrenade->m_flFullDamage = 0;
pGrenade->ApplyLocalAngularVelocityImpulse( angVelocity );
}
return pGrenade;
}
#else
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CTFProjectile_Cleaver::GetTrailParticleName( void )
{
if ( GetTeamNumber() == TF_TEAM_BLUE )
{
return "peejar_trail_blu_glow";
}
else
{
return "peejar_trail_red_glow";
}
}
#endif // GAME_DLL