mv
/
sqwarmed
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
sqwarmed/sdk_src/game/server/swarm/asw_marine.cpp

4770 lines
147 KiB
C++
Raw Blame History

//========= Copyright © 1996-2003, Valve LLC, All rights reserved. ============
//
// Purpose:
//
//=============================================================================
#include "cbase.h"
#include "ai_default.h"
#include "ai_task.h"
#include "ai_schedule.h"
#include "ai_node.h"
#include "ai_hull.h"
#include "ai_hint.h"
#include "ai_squad.h"
#include "ai_senses.h"
#include "ai_navigator.h"
#include "ai_motor.h"
#include "ai_behavior.h"
#include "ai_baseactor.h"
#include "ai_behavior_lead.h"
#include "ai_behavior_follow.h"
#include "ai_behavior_standoff.h"
#include "ai_behavior_assault.h"
#include "soundent.h"
#include "game.h"
#include "npcevent.h"
#include "entitylist.h"
#include "activitylist.h"
#include "vstdlib/random.h"
#include "engine/IEngineSound.h"
#include "sceneentity.h"
#include "asw_marine.h"
#include "asw_player.h"
#include "asw_marine_resource.h"
#include "asw_marine_profile.h"
#include "asw_weapon.h"
#include "asw_marine_speech.h"
//#include "asw_drone.h"
#include "asw_pickup.h"
#include "asw_pickup_weapon.h"
#include "asw_gamerules.h"
#include "asw_gamestats.h"
#include "asw_mission_manager.h"
#include "asw_fail_advice.h"
#include "ammodef.h"
#include "asw_shareddefs.h"
#include "asw_sentry_base.h"
#include "asw_button_area.h"
#include "asw_equipment_list.h"
#include "asw_weapon_parse.h"
#include "asw_fx_shared.h"
#include "asw_parasite.h"
#include "shareddefs.h"
#include "iasw_vehicle.h"
#include "obstacle_pushaway.h"
#include "asw_computer_area.h"
#include "asw_remote_turret_shared.h"
#include "asw_util_shared.h"
#include "EntityFlame.h"
#include "physics_prop_ragdoll.h"
#include "asw_weapon_flashlight_shared.h"
#include "beam_shared.h"
#include "iasw_server_usable_entity.h"
#include "asw_weapon_ammo_bag_shared.h"
#include "datacache/imdlcache.h"
#include "asw_weapon_autogun_shared.h"
#include "asw_burning.h"
#include "asw_door.h"
#include "asw_hack.h"
#include "te_effect_dispatch.h"
#include "asw_trace_filter_melee.h"
#include "ai_moveprobe.h"
#include "asw_ai_senses.h"
#include "particle_parse.h"
#include "asw_director.h"
#include "asw_melee_system.h"
#include "ai_network.h"
#include "asw_weapon_normal_armor.h"
#include "asw_fire.h"
#include "asw_achievements.h"
#include "asw_objective_escape.h"
#include "sendprop_priorities.h"
#include "asw_marine_gamemovement.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define ASW_DEFAULT_MARINE_MODEL "models/swarm/marine/marine.mdl"
//#define ASW_MARINE_ALWAYS_VPHYSICS
//=========================================================
// Marine activities
//=========================================================
LINK_ENTITY_TO_CLASS( asw_marine, CASW_Marine );
//---------------------------------------------------------
//
//---------------------------------------------------------
void SendProxy_CropMarineFlagsToPlayerFlagBitsLength( const SendProp *pProp, const void *pStruct, const void *pVarData, DVariant *pOut, int iElement, int objectID)
{
int mask = (1<<PLAYER_FLAG_BITS) - 1;
int data = *(int *)pVarData;
pOut->m_Int = ( data & mask );
//CBaseEntity *pEntity = (CBaseEntity *)pProp;
//if (pEntity)
//{
//if (( data & mask ) & FL_ONGROUND)
//{
//Msg(" [S] Transmitting FL_ONGROUND (flags=%d)\n", pEntity->GetFlags());
//}
//else
//{
//Msg(" [S] Not Transmitting FL_ONGROUND (flags=%d)\n", pEntity->GetFlags());
//}
//}
//else
//{
//Msg(" WARNING updated flags without an ent\n");
//}
}
IMPLEMENT_SERVERCLASS_ST(CASW_Marine, DT_ASW_Marine)
SendPropExclude( "DT_BaseEntity", "m_angRotation" ),
SendPropExclude( "DT_BaseAnimating", "m_flPoseParameter" ),
SendPropExclude( "DT_BaseAnimating", "m_flPlaybackRate" ),
SendPropExclude( "DT_BaseAnimating", "m_nSequence" ),
SendPropExclude( "DT_BaseAnimatingOverlay", "overlay_vars" ),
SendPropExclude( "DT_BaseAnimating", "m_nNewSequenceParity" ),
SendPropExclude( "DT_BaseAnimating", "m_nResetEventsParity" ),
SendPropExclude( "DT_BaseCombatCharacter", "bcc_localdata" ),
// asw_playeranimstate and clientside animation takes care of these on the client
SendPropExclude( "DT_ServerAnimationData" , "m_flCycle" ),
SendPropExclude( "DT_AnimTimeMustBeFirst" , "m_flAnimTime" ),
// We need to send a hi-res origin to avoid prediction errors sliding along walls
SendPropExclude( "DT_BaseEntity", "m_vecOrigin" ),
// send a hi-res origin to the local player for use in prediction
//SendPropVector (SENDINFO(m_vecOrigin), -1, SPROP_NOSCALE|SPROP_CHANGES_OFTEN, 0.0f, HIGH_DEFAULT, SendProxy_Origin ),
SendPropVectorXY(SENDINFO(m_vecOrigin), -1, SPROP_NOSCALE | SPROP_CHANGES_OFTEN, 0.0f, HIGH_DEFAULT, SendProxy_OriginXY ),
SendPropFloat (SENDINFO_VECTORELEM(m_vecOrigin, 2), -1, SPROP_NOSCALE | SPROP_CHANGES_OFTEN, 0.0f, HIGH_DEFAULT, SendProxy_OriginZ ), // , SENDPROP_LOCALPLAYER_ORIGINZ_PRIORITY
SendPropFloat ( SENDINFO_VECTORELEM(m_vecVelocity, 0), 32, SPROP_NOSCALE|SPROP_CHANGES_OFTEN ),
SendPropFloat ( SENDINFO_VECTORELEM(m_vecVelocity, 1), 32, SPROP_NOSCALE|SPROP_CHANGES_OFTEN ),
SendPropFloat ( SENDINFO_VECTORELEM(m_vecVelocity, 2), 32, SPROP_NOSCALE|SPROP_CHANGES_OFTEN ),
#if PREDICTION_ERROR_CHECK_LEVEL > 1
SendPropAngle( SENDINFO_VECTORELEM(m_angRotation, 0), 13, SPROP_NOSCALE|SPROP_CHANGES_OFTEN, CBaseEntity::SendProxy_AnglesX ),
SendPropAngle( SENDINFO_VECTORELEM(m_angRotation, 1), 13, SPROP_NOSCALE|SPROP_CHANGES_OFTEN, CBaseEntity::SendProxy_AnglesY ),
SendPropAngle( SENDINFO_VECTORELEM(m_angRotation, 2), 13, SPROP_NOSCALE|SPROP_CHANGES_OFTEN, CBaseEntity::SendProxy_AnglesZ ),
#else
SendPropAngle( SENDINFO_VECTORELEM(m_angRotation, 0), 13, SPROP_CHANGES_OFTEN, CBaseEntity::SendProxy_AnglesX ),
SendPropAngle( SENDINFO_VECTORELEM(m_angRotation, 1), 13, SPROP_CHANGES_OFTEN, CBaseEntity::SendProxy_AnglesY ),
SendPropAngle( SENDINFO_VECTORELEM(m_angRotation, 2), 13, SPROP_CHANGES_OFTEN, CBaseEntity::SendProxy_AnglesZ ),
#endif
SendPropFloat ( SENDINFO(m_fAIPitch), 0, SPROP_NOSCALE),
SendPropInt (SENDINFO(m_fFlags), PLAYER_FLAG_BITS, SPROP_UNSIGNED|SPROP_CHANGES_OFTEN, SendProxy_CropMarineFlagsToPlayerFlagBitsLength ),
SendPropInt (SENDINFO(m_iHealth), 10 ),
SendPropInt( SENDINFO(m_iMaxHealth), 10 ),
SendPropFloat (SENDINFO(m_fInfestedTime), 6, SPROP_UNSIGNED, 0.0f, 64.0f ),
SendPropFloat (SENDINFO(m_fInfestedStartTime), 0, SPROP_NOSCALE ),
SendPropInt (SENDINFO(m_ASWOrders), 4),
SendPropEHandle( SENDINFO ( m_Commander ) ),
SendPropArray3 ( SENDINFO_ARRAY3(m_iAmmo), SendPropInt( SENDINFO_ARRAY(m_iAmmo), 10, SPROP_UNSIGNED ) ),
SendPropBool (SENDINFO(m_bSlowHeal)),
SendPropInt (SENDINFO(m_iSlowHealAmount), 10 ),
SendPropBool (SENDINFO(m_bPreventMovement)),
SendPropBool (SENDINFO(m_bWalking) ),
SendPropFloat (SENDINFO(m_fFFGuardTime), 0, SPROP_NOSCALE ),
SendPropEHandle( SENDINFO ( m_hUsingEntity ) ),
SendPropEHandle( SENDINFO ( m_hCurrentHack ) ),
SendPropVector( SENDINFO ( m_vecFacingPointFromServer ), 0, SPROP_NOSCALE ),
SendPropEHandle ( SENDINFO( m_hGroundEntity ), SPROP_CHANGES_OFTEN ),
SendPropEHandle( SENDINFO ( m_hMarineFollowTarget ) ),
SendPropTime( SENDINFO(m_fStopMarineTime) ),
SendPropTime( SENDINFO(m_fNextMeleeTime) ),
SendPropTime( SENDINFO( m_flNextAttack ) ),
SendPropInt ( SENDINFO( m_iMeleeAttackID ), 7, SPROP_UNSIGNED ),
SendPropBool (SENDINFO(m_bOnFire)),
// emotes
SendPropBool (SENDINFO(bEmoteMedic)),
SendPropBool (SENDINFO(bEmoteAmmo)),
SendPropBool (SENDINFO(bEmoteSmile)),
SendPropBool (SENDINFO(bEmoteStop)),
SendPropBool (SENDINFO(bEmoteGo)),
SendPropBool (SENDINFO(bEmoteExclaim)),
SendPropBool (SENDINFO(bEmoteAnimeSmile)),
SendPropBool (SENDINFO(bEmoteQuestion)),
// driving
SendPropEHandle( SENDINFO ( m_hASWVehicle ) ),
SendPropBool (SENDINFO(m_bDriving)),
SendPropBool (SENDINFO(m_bIsInVehicle)),
// knocked out
SendPropBool (SENDINFO(m_bKnockedOut)),
// turret
SendPropEHandle( SENDINFO ( m_hRemoteTurret ) ),
// We want to send all the marine's weapons to all the other marines
SendPropArray3( SENDINFO_ARRAY3(m_hMyWeapons), SendPropEHandle( SENDINFO_ARRAY(m_hMyWeapons) ) ),
SendPropFloat ( SENDINFO_VECTORELEM(m_vecViewOffset, 0), 0, SPROP_NOSCALE ),
SendPropFloat ( SENDINFO_VECTORELEM(m_vecViewOffset, 1), 0, SPROP_NOSCALE ),
SendPropFloat ( SENDINFO_VECTORELEM(m_vecViewOffset, 2), 0, SPROP_NOSCALE ),
#ifdef MELEE_CHARGE_ATTACKS
SendPropFloat ( SENDINFO(m_flMeleeHeavyKeyHoldStart), 0, SPROP_NOSCALE ),
#endif
SendPropInt ( SENDINFO( m_iForcedActionRequest ) ),
SendPropBool ( SENDINFO( m_bReflectingProjectiles ) ),
SendPropTime ( SENDINFO( m_flDamageBuffEndTime ) ),
SendPropTime ( SENDINFO( m_flElectrifiedArmorEndTime ) ),
SendPropInt ( SENDINFO( m_iPowerupType ) ),
SendPropTime ( SENDINFO( m_flPowerupExpireTime ) ),
SendPropBool ( SENDINFO( m_bPowerupExpires ) ),
SendPropFloat ( SENDINFO(m_flKnockdownYaw) ),
SendPropFloat ( SENDINFO( m_flMeleeYaw ) ),
SendPropBool ( SENDINFO( m_bFaceMeleeYaw ) ),
SendPropFloat ( SENDINFO( m_flPreventLaserSightTime ) ),
SendPropBool ( SENDINFO( m_bAICrouch ) ),
SendPropInt ( SENDINFO( m_iJumpJetting )),
END_SEND_TABLE()
//---------------------------------------------------------
// Save/Restore
//---------------------------------------------------------
BEGIN_DATADESC( CASW_Marine )
DEFINE_FIELD( m_bSlowHeal, FIELD_BOOLEAN ),
DEFINE_FIELD( m_iSlowHealAmount, FIELD_INTEGER ),
DEFINE_FIELD( m_vecFacingPointFromServer, FIELD_VECTOR ),
DEFINE_FIELD( m_hRemoteTurret, FIELD_EHANDLE ),
DEFINE_FIELD( m_hASWVehicle, FIELD_EHANDLE ),
DEFINE_FIELD( m_bDriving, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bIsInVehicle, FIELD_BOOLEAN ),
DEFINE_FIELD( bEmoteMedic, FIELD_BOOLEAN ),
DEFINE_FIELD( bEmoteAmmo, FIELD_BOOLEAN ),
DEFINE_FIELD( bEmoteStop, FIELD_BOOLEAN ),
DEFINE_FIELD( bEmoteGo, FIELD_BOOLEAN ),
DEFINE_FIELD( bEmoteExclaim, FIELD_BOOLEAN ),
DEFINE_FIELD( bEmoteAnimeSmile, FIELD_BOOLEAN ),
DEFINE_FIELD( bEmoteQuestion, FIELD_BOOLEAN ),
DEFINE_FIELD( m_Commander, FIELD_EHANDLE),
DEFINE_FIELD( m_hRemoteTurret, FIELD_EHANDLE ),
DEFINE_FIELD( m_fHoldingYaw, FIELD_FLOAT ),
DEFINE_FIELD( m_flFirstBurnTime, FIELD_FLOAT ),
DEFINE_FIELD( m_flLastBurnTime, FIELD_FLOAT ),
DEFINE_FIELD( m_flLastBurnSoundTime, FIELD_TIME ),
DEFINE_FIELD( m_fNextPainSoundTime, FIELD_TIME ),
DEFINE_FIELD( m_fStartedFiringTime, FIELD_TIME ),
DEFINE_FIELD( m_fNextSlowHealTick, FIELD_FLOAT ),
DEFINE_FIELD( m_fInfestedTime, FIELD_TIME ),
DEFINE_FIELD( m_fInfestedStartTime, FIELD_TIME ),
DEFINE_FIELD( m_fStopFacingPointTime, FIELD_FLOAT ),
DEFINE_FIELD( m_fLastASWThink, FIELD_TIME ),
DEFINE_FIELD( m_iSlowHealAmount, FIELD_INTEGER ),
DEFINE_FIELD( m_iInfestCycle, FIELD_INTEGER ),
DEFINE_FIELD( m_fLastASWThink, FIELD_INTEGER ),
DEFINE_FIELD( m_Commander, FIELD_EHANDLE),
DEFINE_FIELD( m_bHacking, FIELD_BOOLEAN ),
DEFINE_FIELD( m_hCurrentHack, FIELD_EHANDLE),
DEFINE_FIELD( m_hUsingEntity, FIELD_EHANDLE),
DEFINE_FIELD( m_bKnockedOut, FIELD_BOOLEAN),
DEFINE_FIELD( m_fKickTime, FIELD_TIME ),
DEFINE_FIELD( m_fNextMeleeTime, FIELD_TIME ),
DEFINE_FIELD( m_fStopMarineTime, FIELD_TIME ),
DEFINE_FIELD( m_hLastWeaponSwitchedTo, FIELD_EHANDLE ),
// m_PlayerAnimState - recreated
// m_MarineSpeech - recreated
DEFINE_FIELD( m_MarineResource, FIELD_EHANDLE ),
DEFINE_FIELD( m_nOldButtons, FIELD_INTEGER ),
DEFINE_FIELD( m_bWantsToFire, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bWantsToFire2, FIELD_BOOLEAN ),
DEFINE_FIELD( m_fMarineAimError, FIELD_FLOAT ),
DEFINE_FIELD( m_ASWOrders, FIELD_INTEGER ),
DEFINE_FIELD( m_fOverkillShootTime, FIELD_TIME ),
DEFINE_FIELD( m_vecOverkillPos, FIELD_VECTOR ),
DEFINE_FIELD( m_fUnfreezeTime, FIELD_TIME ),
DEFINE_FIELD( m_fFFGuardTime, FIELD_FLOAT ),
DEFINE_FIELD( m_fLastStillTime, FIELD_TIME ),
DEFINE_FIELD( m_bDoneWoundedRebuke, FIELD_BOOLEAN ),
DEFINE_FIELD( m_vecMoveToOrderPos, FIELD_VECTOR ),
DEFINE_FIELD( m_fFriendlyFireDamage, FIELD_FLOAT ),
DEFINE_ARRAY( m_pRecentAttackers, FIELD_INTEGER, ASW_MOB_VICTIM_SIZE ),
DEFINE_FIELD( m_fLastMobDamageTime, FIELD_TIME ),
DEFINE_FIELD( m_bHasBeenMobAttacked, FIELD_BOOLEAN ),
DEFINE_FIELD( m_hInfestationCurer, FIELD_EHANDLE ),
DEFINE_FIELD( m_bOnFire, FIELD_BOOLEAN ),
DEFINE_FIELD( m_fLastShotAlienTime, FIELD_TIME ),
DEFINE_FIELD( m_fLastShotJunkTime, FIELD_TIME ),
DEFINE_FIELD( m_fUsingEngineeringAura, FIELD_TIME ),
DEFINE_FIELD( m_fCachedIdealSpeed, FIELD_FLOAT ),
DEFINE_FIELD( m_fNextAlienWalkDamage, FIELD_FLOAT ),
DEFINE_FIELD( m_iLightLevel, FIELD_INTEGER ),
DEFINE_FIELD( m_fLastFriendlyFireTime, FIELD_FLOAT ),
DEFINE_FIELD( m_fLastAmmoCheckTime, FIELD_FLOAT ),
DEFINE_FIELD( m_fFriendlyFireAbsorptionTime, FIELD_FLOAT ),
DEFINE_FIELD( m_vecMeleeStartPos, FIELD_VECTOR ),
DEFINE_FIELD( m_bFaceMeleeYaw, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flMeleeStartTime, FIELD_FLOAT ),
DEFINE_FIELD( m_flMeleeLastCycle, FIELD_FLOAT ),
DEFINE_FIELD( m_flMeleeYaw, FIELD_FLOAT ),
DEFINE_FIELD( m_bMeleeCollisionDamage, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bMeleeComboKeypressAllowed, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bMeleeComboKeyPressed, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bMeleeComboTransitionAllowed, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bMeleeMadeContact, FIELD_BOOLEAN ),
DEFINE_FIELD( m_iUsableItemsOnMeleePress, FIELD_INTEGER ),
DEFINE_FIELD( m_iMeleeAllowMovement, FIELD_INTEGER ),
DEFINE_FIELD( m_bMeleeKeyReleased, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bPlayedMeleeHitSound, FIELD_BOOLEAN ),
#ifdef MELEE_CHARGE_ATTACKS
DEFINE_FIELD( m_flMeleeHeavyKeyHoldStart, FIELD_FLOAT ),
DEFINE_FIELD( m_bMeleeHeavyKeyHeld, FIELD_BOOLEAN ),
#endif
DEFINE_FIELD( m_bMeleeChargeActivate, FIELD_BOOLEAN ),
DEFINE_AUTO_ARRAY( m_iPredictedEvent, FIELD_INTEGER ),
DEFINE_AUTO_ARRAY( m_flPredictedEventTime, FIELD_FLOAT ),
DEFINE_FIELD( m_iNumPredictedEvents, FIELD_INTEGER ),
DEFINE_FIELD( m_iOnLandMeleeAttackID, FIELD_INTEGER ),
DEFINE_FIELD( m_flNextStumbleTime, FIELD_FLOAT ),
DEFINE_FIELD( m_flDamageBuffEndTime, FIELD_FLOAT ),
DEFINE_FIELD( m_flElectrifiedArmorEndTime, FIELD_FLOAT ),
DEFINE_FIELD( m_flLastSquadEnemyTime, FIELD_FLOAT ),
DEFINE_FIELD( m_flLastSquadShotAlienTime, FIELD_FLOAT ),
DEFINE_FIELD( m_flLastHurtAlienTime, FIELD_FLOAT ),
DEFINE_FIELD( m_flLastAttributeExplosionSound, FIELD_TIME ),
DEFINE_FIELD( m_iPowerupType, FIELD_INTEGER ),
DEFINE_FIELD( m_flPowerupExpireTime, FIELD_FLOAT ),
DEFINE_FIELD( m_bPowerupExpires, FIELD_BOOLEAN ),
END_DATADESC()
extern ConVar weapon_showproficiency;
extern ConVar asw_leadership_radius;
extern ConVar asw_buzzer_poison_duration;
extern ConVar asw_debug_marine_chatter;
extern ConVar asw_debug_medals;
extern ConVar ai_show_hull_attacks;
extern ConVar asw_medal_melee_hits;
extern int AE_MARINE_KICK;
extern int AE_MARINE_UNFREEZE;
ConVar asw_marine_stumble_on_damage( "asw_marine_stumble_on_damage", "1", FCVAR_CHEAT, "Marine stumbles when he takes damage" );
ConVar asw_stumble_interval( "asw_stumble_interval", "2.0", FCVAR_CHEAT, "Min time between stumbles" );
ConVar asw_knockdown_interval( "asw_knockdown_interval", "3.0", FCVAR_CHEAT, "Min time between knockdowns" );
ConVar asw_marine_fall_damage( "asw_marine_fall_damage", "0", FCVAR_CHEAT, "Marines take falling damage" );
ConVar asw_screenflash("asw_screenflash", "0", FCVAR_CHEAT, "Alpha of damage screen flash");
ConVar asw_damage_indicator("asw_damage_indicator", "1", FCVAR_CHEAT, "If set, directional damage indicator is shown");
ConVar asw_marine_server_ragdoll("asw_marine_server_ragdoll", "0", FCVAR_CHEAT, "If set, marines will have server ragdolls instead of clientside ones.");
ConVar asw_marine_death_protection("asw_marine_death_protection", "1", FCVAR_CHEAT, "Prevents marines from dying in one hit, unless on 1 health");
ConVar asw_marine_melee_distance("asw_marine_melee_distance", "50", FCVAR_CHEAT, "How far the marine can kick");
ConVar asw_marine_melee_damage("asw_marine_melee_damage", "20", FCVAR_CHEAT, "How much damage the marine's kick does");
ConVar asw_marine_melee_force("asw_marine_melee_force", "200000", FCVAR_CHEAT, "Marine kick force = this / dist");
ConVar asw_marine_melee_max_force("asw_marine_melee_max_force", "10000", FCVAR_CHEAT, "Maximum force allowed");
ConVar asw_marine_melee_kick_lift("asw_marine_melee_kick_lift", "0.2", FCVAR_CHEAT, "Upwards Z-Force given to kicked objects");
ConVar asw_marine_ai_acceleration("asw_marine_ai_acceleration", "4.0f", FCVAR_CHEAT, "Acceleration boost for marine AI");
ConVar asw_marine_scan_beams("asw_marine_scan_beams", "0", 0, "Draw scan beams for marines holding position");
ConVar asw_debug_marine_damage("asw_debug_marine_damage", "0", 0, "Show damage marines are taking");
ConVar asw_marine_ff("asw_marine_ff", "1", FCVAR_CHEAT, "Marine friendly fire setting (0 = FFGuard, 1 = Normal (based on mission difficulty), 2 = Always max)", true, 0, true, 2);
ConVar asw_marine_ff_guard_time("asw_marine_ff_guard_time", "5.0", FCVAR_CHEAT, "Amount of time firing is disabled for when activating friendly fire guard");
ConVar asw_marine_ff_dmg_base("asw_marine_ff_dmg_base", "1.0", FCVAR_CHEAT, "Amount of friendly fire damage on mission difficulty 5");
ConVar asw_marine_ff_dmg_step("asw_marine_ff_dmg_step", "0.2", FCVAR_CHEAT, "Amount friendly fire damage is modified per mission difficuly level away from 5");
ConVar asw_marine_ff_absorption("asw_marine_ff_absorption", "1", FCVAR_NONE, "Friendly fire absorption style (0=none 1=ramp up 2=ramp down)");
ConVar asw_marine_ff_absorption_decay_rate("asw_marine_ff_absorption_decay_rate", "0.33f", FCVAR_CHEAT, "Rate of FF absorption decay");
ConVar asw_marine_ff_absorption_build_rate("asw_marine_ff_absorption_build_rate", "0.25f", FCVAR_CHEAT, "Rate of FF absorption decay build up when being shot by friendlies");
ConVar asw_marine_burn_time_easy("asw_marine_burn_time_easy", "6", FCVAR_CHEAT, "Amount of time marine burns for when ignited on easy difficulty");
ConVar asw_marine_burn_time_normal("asw_marine_burn_time_normal", "8", FCVAR_CHEAT, "Amount of time marine burns for when ignited on normal difficulty");
ConVar asw_marine_burn_time_hard("asw_marine_burn_time_hard", "12", FCVAR_CHEAT, "Amount of time marine burns for when ignited on hard difficulty");
ConVar asw_marine_burn_time_insane("asw_marine_burn_time_insane", "15", FCVAR_CHEAT, "Amount of time marine burns for when ignited on insane difficulty");
ConVar asw_marine_time_until_ignite("asw_marine_time_until_ignite", "0.7f", FCVAR_CHEAT, "Amount of time before a marine ignites from taking repeated burn damage");
ConVar asw_mad_firing_break("asw_mad_firing_break", "4", 0, "Point at which the mad firing counter triggers the mad firing speech");
ConVar asw_mad_firing_decay("asw_mad_firing_decay", "0.15", 0, "Tick down rate of the mad firing counter");
ConVar asw_marine_special_idle_chatter_chance("asw_marine_special_idle_chatter_chance", "0.25", 0, "Chance of marine doing a special idle chatter");
ConVar asw_force_ai_fire("asw_force_ai_fire", "0", FCVAR_CHEAT, "Forces all AI marines to fire constantly");
ConVar asw_realistic_death_chatter("asw_realistic_death_chatter", "0", FCVAR_NONE, "If true, only 1 nearby marine will shout about marine deaths");
ConVar asw_god( "asw_god", "0", FCVAR_CHEAT, "Set to 1 to make marines invulnerable" );
ConVar asw_movement_direction_tolerance( "asw_movement_direction_tolerance", "30.0", FCVAR_CHEAT );
ConVar asw_movement_direction_interval( "asw_movement_direction_interval", "0.5", FCVAR_CHEAT );
float CASW_Marine::s_fNextMadFiringChatter = 0;
float CASW_Marine::s_fNextIdleChatterTime = 0;
void CASW_Marine::DoAnimationEvent( PlayerAnimEvent_t event )
{
if (gpGlobals->maxClients > 1 &&
(event == PLAYERANIMEVENT_RELOAD || event == PLAYERANIMEVENT_JUMP || event == PLAYERANIMEVENT_WEAPON_SWITCH
|| event == PLAYERANIMEVENT_HEAL || event == PLAYERANIMEVENT_KICK || event == PLAYERANIMEVENT_THROW_GRENADE
|| event == PLAYERANIMEVENT_BAYONET || event == PLAYERANIMEVENT_PICKUP
|| ( event >= PLAYERANIMEVENT_MELEE && event <= PLAYERANIMEVENT_MELEE_LAST ) ) )
{
TE_MarineAnimEventExceptCommander( this, event ); // Send to any clients other than my commander who can see this guy.
}
else
{
TE_MarineAnimEvent( this, event ); // Send to all clients who can see this guy.
}
MDLCACHE_CRITICAL_SECTION();
m_PlayerAnimState->DoAnimationEvent(event);
}
void CASW_Marine::DoAnimationEventToAll( PlayerAnimEvent_t event )
{
TE_MarineAnimEvent( this, event ); // Send to all clients who can see this guy.
m_PlayerAnimState->DoAnimationEvent(event);
Msg("CASW_Marine::DoAnimationEventToAll %d\n", (int) event);
}
void CASW_Marine::HandleAnimEvent( animevent_t *pEvent )
{
int nEvent = pEvent->Event();
if( !IsInhabited() && nEvent == AE_MELEE_DAMAGE )
{
float flYawStart, flYawEnd;
flYawStart = flYawEnd = 0.0f;
const char* options = pEvent->options;
const char *p = options;
char token[256];
if ( options[0] )
{
// Read in yaw start
p = nexttoken( token, p, ' ' );
if( token )
{
flYawStart = atof( token );
}
// Read in yaw end
p = nexttoken( token, p, ' ' );
if( token )
{
flYawEnd = atof( token );
}
}
DoMeleeDamageTrace( flYawStart, flYawEnd );
return;
}
if ( GetCurrentMeleeAttack() )
{
if ( !GetCurrentMeleeAttack()->AllowNormalAnimEvent( this, nEvent ) )
return;
}
if ( nEvent == AE_MARINE_UNFREEZE )
{
Msg("AE_MARINE_UNFREEZE\n");
RemoveFlag(FL_FROZEN);
return;
}
else if ( nEvent == AE_ASW_FOOTSTEP || nEvent == AE_MARINE_FOOTSTEP )
{
// footsteps are played clientside
return;
}
BaseClass::HandleAnimEvent( pEvent );
}
CASW_Marine::CASW_Marine() : m_RecentMeleeHits( 16, 16 )
{
m_flLastEnemyYaw = 0;
m_flLastEnemyYawTime = 0;;
m_flAIYawOffset = 0;
m_flNextYawOffsetTime = 0;
m_bAICrouch = false;
m_MarineResource = NULL;
m_fUnfreezeTime = 0;
m_PlayerAnimState = CreatePlayerAnimState(this, this, LEGANIM_9WAY, false);
UseClientSideAnimation();
m_HackedGunPos = Vector ( 0, 0, ASW_MARINE_GUN_OFFSET_Z );
m_nOldButtons = 0;
m_MarineSpeech = new CASW_MarineSpeech(this);
m_flHealRateScale = 1.0f;
m_fNextSlowHealTick = 0;
m_fLastASWThink = gpGlobals->curtime;
m_fInfestedTime = 0;
m_fInfestedStartTime = 0;
m_iInfestCycle = 0;
m_flFirstBurnTime = 0;
m_flLastBurnTime = 0;
m_flLastBurnSoundTime = 0;
m_fNextPainSoundTime = 0;
m_fStopFacingPointTime = 0;
m_fHoldingYaw = 0;
m_hKnockedOutRagdoll = NULL;
m_fKickTime = 0;
m_fNextMeleeTime = 0;
#ifdef MELEE_CHARGE_ATTACKS
m_flMeleeHeavyKeyHoldStart = 0;
#endif
m_fMadFiringCounter = 0;
m_fUsingEngineeringAura = 0;
m_bDoneOrderChatter = false;
m_szInitialCommanderNetworkID[0] = '\0';
m_bWaitingForWeld = false;
m_flBeginWeldTime = 0.0f;
// ai control of firing
m_bWantsToFire = false;
m_bWantsToFire2 = false;
m_fMarineAimError = 0;
m_fStopMarineTime = 0;
m_flTimeNextScanPing = 0;
m_flPreventLaserSightTime = 0;
m_fLastStuckTime = 0;
m_flFirstStuckTime = 0;
m_fIdleChatterDelay = random->RandomInt(20, 30);
m_fRandomFacing = 0;
m_fNewRandomFacingTime = 0;
m_fCachedIdealSpeed = 300.0f;
m_flNextBreadcrumbTime = 0;
m_flNextAmmoScanTime = 0;
m_flResetAmmoIgnoreListTime = 0;
m_iPowerupType = -1;
m_flPowerupExpireTime = -1;
m_bPowerupExpires = false;
m_flLastSquadEnemyTime = 0.0f;
m_flLastSquadShotAlienTime = 0.0f;
m_flLastHurtAlienTime = 0.0f;
m_flLastGooScanTime = 0.0f;
m_fLastAmmoCheckTime = 0.0f;
m_nFastReloadsInARow = 0;
for ( int i = 0; i < ASW_MARINE_HISTORY_POSITIONS; i++ )
{
m_PositionHistory[ i ].vecPosition = vec3_origin;
m_PositionHistory[ i ].flTime = 0.0f;
}
m_nPositionHistoryTail = -1;
// rappel
m_hLine = NULL;
m_bWaitingToRappel = false;
m_bOnGround = true;
m_vecRopeAnchor = vec3_origin;
}
CASW_Marine::~CASW_Marine()
{
if (GetMarineResource())
GetMarineResource()->SetMarineEntity(NULL);
m_PlayerAnimState->Release();
delete m_MarineSpeech;
}
// create our custom senses class
CAI_Senses *CASW_Marine::CreateSenses()
{
CAI_Senses *pSenses = new CASW_Marine_AI_Senses;
pSenses->SetOuter( this );
return pSenses;
}
void CASW_Marine::SetHeightLook( float flHeightLook )
{
CAI_Senses *pSenses = GetSenses();
Assert(pSenses);
if ( pSenses )
{
CASW_Marine_AI_Senses *pMarineSenses = dynamic_cast<CASW_Marine_AI_Senses*>( GetSenses() );
if ( pMarineSenses )
pMarineSenses->SetHeightLook( flHeightLook );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CASW_Marine::SelectModel()
{
SelectModelFromProfile();
}
void CASW_Marine::UpdateOnRemove( void )
{
BaseClass::UpdateOnRemove();
StopUsing();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CASW_Marine::Spawn( void )
{
Precache();
BaseClass::Spawn();
SelectModel();
SetModel( STRING( GetModelName() ) );
SetHullType(HULL_HUMAN);
SetHullSizeNormal();
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_NOT_STANDABLE );
SetBloodColor( BLOOD_COLOR_RED );
m_flFieldOfView = 0.02;
m_NPCState = NPC_STATE_NONE;
CapabilitiesClear();
CapabilitiesAdd( bits_CAP_MOVE_GROUND );
SetMoveType( MOVETYPE_STEP );
m_HackedGunPos = Vector( 0, 0, ASW_MARINE_GUN_OFFSET_Z );
// Marines collide/moveprobe as players.
m_nAITraceMask = MASK_PLAYERSOLID;
CapabilitiesRemove( bits_CAP_FRIENDLY_DMG_IMMUNE | bits_CAP_NO_HIT_PLAYER );
SetCollisionGroup( COLLISION_GROUP_PLAYER );
AddEFlags( EFL_NO_DISSOLVE | EFL_NO_MEGAPHYSCANNON_RAGDOLL | EFL_NO_PHYSCANNON_INTERACTION );
// join the marines team
ChangeFaction( FACTION_MARINES );
SetHealth( 100 );
NPCInit();
SetInhabited(false);
m_Commander = NULL;
m_ASWOrders = ASW_ORDER_FOLLOW;
m_bWasFollowing = true;
m_flFieldOfView = ASW_HOLD_POSITION_FOV_DOT;
SetDistLook( ASW_HOLD_POSITION_SIGHT_RANGE );
m_flDistTooFar = 1024.0f;
SetAIWalkable(false);
// bias the box south a bit - this feels better for FF collisions with the tilted cam
Vector vecSurroundingMins( -16, -18, 0 );
Vector vecSurroundingMaxs( 16, 14, 70 );
CollisionProp()->SetSurroundingBoundsType( USE_SPECIFIED_BOUNDS, &vecSurroundingMins, &vecSurroundingMaxs );
// make sure his move_x/y pose parameters are at full moving forwards, so the AI follow movement will detect some sequence motion when calculating goal speed
SetPoseParameter( "move_x", 1.0f );
SetPoseParameter( "move_y", 0.0f );
}
void CASW_Marine::NPCInit()
{
BaseClass::NPCInit();
m_LagCompensation.Init(this);
}
unsigned int CASW_Marine::PhysicsSolidMaskForEntity( void ) const
{
return MASK_PLAYERSOLID;
}
void CASW_Marine::Precache()
{
SelectModel();
BaseClass::Precache();
PrecacheSpeech();
PrecacheModel("models/swarm/shouldercone/shouldercone.mdl");
PrecacheModel("models/swarm/shouldercone/lasersight.mdl");
PrecacheModel( "cable/cable.vmt" );
PrecacheScriptSound( "ASW.MarineMeleeAttack" );
PrecacheScriptSound( "ASW.MarineMeleeAttackFP" );
PrecacheScriptSound( "ASW.MarinePowerFistAttack" );
PrecacheScriptSound( "ASW.MarinePowerFistAttackFP" );
PrecacheScriptSound( "ASW_Weapon_Flamer.FlameLoop" );
PrecacheScriptSound( "ASW_Weapon_Flamer.FlameStop" );
PrecacheScriptSound( "ASWFlashlight.FlashlightToggle" );
PrecacheScriptSound( "ASW_Flare.IgniteFlare" );
PrecacheScriptSound( "ASWScanner.Idle1" );
PrecacheScriptSound( "ASWScanner.Idle2" );
PrecacheScriptSound( "ASWScanner.Idle3" );
PrecacheScriptSound( "ASWScanner.Idle4" );
PrecacheScriptSound( "ASWScanner.Idle5" );
PrecacheScriptSound( "ASWScanner.Idle6" );
PrecacheScriptSound( "ASWScanner.Idle7" );
PrecacheScriptSound( "ASWScanner.Idle8" );
PrecacheScriptSound( "ASWScanner.Idle9" );
PrecacheScriptSound( "ASWScanner.Idle10" );
PrecacheScriptSound( "ASWScanner.Idle11" );
PrecacheScriptSound( "ASWScanner.Idle12" );
PrecacheScriptSound( "ASWScanner.Idle13" );
PrecacheScriptSound( "ASWScanner.Warning1" );
PrecacheScriptSound( "ASWScanner.Warning2" );
PrecacheScriptSound( "ASWScanner.Warning3" );
PrecacheScriptSound( "ASWScanner.Warning4" );
PrecacheScriptSound( "ASWScanner.Warning5" );
PrecacheScriptSound( "ASWScanner.Warning6" );
PrecacheScriptSound( "ASWScanner.Warning7" );
PrecacheScriptSound( "ASWScanner.Warning8" );
PrecacheScriptSound( "ASWScanner.Warning9" );
PrecacheScriptSound( "ASWScanner.Drawing" );
PrecacheScriptSound( "ASW_Weapon.Reload3" );
PrecacheScriptSound( "ASWInterface.Button3" );
PrecacheScriptSound( "Marine.DeathBeep" );
PrecacheScriptSound( "ASW.MarineImpactFP" );
PrecacheScriptSound( "ASW.MarineImpact" );
PrecacheScriptSound( "ASW.MarineImpactHeavyFP" );
PrecacheScriptSound( "ASW.MarineImpactHeavy" );
PrecacheScriptSound( "ASW.MarineMeleeAttack" );
PrecacheScriptSound( "ASW_Weapon.LowAmmoClick" );
PrecacheScriptSound( "ASW_ElectrifiedSuit.TurnOn" );
PrecacheScriptSound( "ASW_ElectrifiedSuit.Loop" );
PrecacheScriptSound( "ASW_ElectrifiedSuit.LoopFP" );
PrecacheScriptSound( "ASW_ElectrifiedSuit.OffFP" );
PrecacheScriptSound( "ASW.MarineBurnPain_NoIgnite" );
PrecacheScriptSound( "ASW_Extinguisher.OnLoop" );
PrecacheScriptSound( "ASW_Extinguisher.Stop" );
PrecacheScriptSound( "ASW_JumpJet.Activate" );
PrecacheScriptSound( "ASW_JumpJet.Loop" );
PrecacheScriptSound( "ASW_JumpJet.Impact" );
PrecacheScriptSound( "ASW_Blink.Blink" );
PrecacheScriptSound( "ASW_Blink.Teleport" );
PrecacheScriptSound( "ASW_XP.LevelUp" );
PrecacheScriptSound( "ASW_Weapon.InvalidDestination" );
PrecacheParticleSystem( "smallsplat" ); // shot
PrecacheParticleSystem( "marine_bloodsplat_light" ); // small shot
PrecacheParticleSystem( "marine_bloodsplat_heavy" ); // heavy shot
PrecacheParticleSystem( "marine_hit_blood_ff" );
PrecacheParticleSystem( "marine_hit_blood" );
PrecacheParticleSystem( "thorns_marine_buff" );
PrecacheParticleSystem( "marine_gib" );
PrecacheParticleSystem( "marine_death_ragdoll" );
PrecacheParticleSystem( "piercing_spark" );
PrecacheParticleSystem( "jj_trail_small" );
PrecacheParticleSystem( "jj_ground_pound" );
PrecacheParticleSystem( "invalid_destination" );
PrecacheParticleSystem( "Blink" );
}
void CASW_Marine::PrecacheSpeech()
{
if (m_MarineSpeech && GetMarineResource())
m_MarineSpeech->Precache();
}
void CASW_Marine::PhysicsSimulate( void )
{
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CASW_Player *player = ToASW_Player( UTIL_PlayerByIndex( i ) );
if ( player && player->GetMarine() == this)
{
InhabitedPhysicsSimulate();
return;
}
}
BaseClass::PhysicsSimulate();
CASW_Weapon *pWeapon = GetActiveASWWeapon();
if (pWeapon)
pWeapon->ItemPostFrame();
// check if offhand weapon needs postframe
CASW_Weapon *pExtra = GetASWWeapon(2);
if (pExtra && pExtra != pWeapon && pExtra->m_bShotDelayed)
{
pExtra->ItemPostFrame();
}
}
#define ASW_BREADCRUMB_INTERVAL 4.0f
// think only occurs when uninhabited (in singleplayer at least, not sure about multi)
// this is because we're not calling BaseClass::PhysicsSimulate
void CASW_Marine::Think( void )
{
if (!IsInhabited())
{
BaseClass::Think();
ASWThinkEffects();
m_fCachedIdealSpeed = MaxSpeed();
}
}
CBaseCombatWeapon* CASW_Marine::ASWAnim_GetActiveWeapon()
{
return GetActiveWeapon();
}
CASW_Marine_Profile* CASW_Marine::GetMarineProfile()
{
CASW_Marine_Resource* pMR = GetMarineResource();
if ( !pMR )
{
return NULL;
}
return pMR->GetProfile();
}
bool CASW_Marine::IsCurTaskContinuousMove()
{
const Task_t* pTask = GetTask();
// This bit of logic strikes me funny, but the case does exist. (sjb)
if( !pTask )
return true;
switch( pTask->iTask )
{
case TASK_ASW_WAIT_FOR_FOLLOW_MOVEMENT:
case TASK_ASW_MOVE_TO_GIVE_AMMO:
return true;
break;
default:
return BaseClass::IsCurTaskContinuousMove();
break;
}
}
bool CASW_Marine::ASWAnim_CanMove()
{
return true;
}
// sets which player commands this marine
void CASW_Marine::SetCommander( CASW_Player *player )
{
if ( m_Commander.Get() == player )
{
return;
}
m_Commander = player;
if ( player )
{
player->OnMarineCommanded( this );
}
}
// store ASWNetworkID of first commander
void CASW_Marine::SetInitialCommander(CASW_Player *player)
{
Q_snprintf( m_szInitialCommanderNetworkID, sizeof(m_szInitialCommanderNetworkID), "%s", player ? player->GetASWNetworkID() : "None" );
Msg( " Marine %d:%s SetInitialCommander id to %s\n", entindex(), GetEntityName(), m_szInitialCommanderNetworkID );
}
// called when a player takes direct control of this marine
void CASW_Marine::InhabitedBy(CASW_Player *player)
{
m_vecSmoothedVelocity = vec3_origin;
if (!IsInhabited())
{
m_vecSmoothedVelocity.z = GetAbsVelocity().z;
}
SetInhabited(true);
// stop the AI firing
m_bWantsToFire = m_bWantsToFire2 = false;
m_fMarineAimError = 0;
ClearForcedActionRequest();
GetSquadFormation()->Remove( this, true );
// always interrupt our current task when inhabiting a marine
TaskFail(FAIL_NO_PLAYER);
// set his schedule to holding position
SetSchedule(SCHED_ASW_HOLD_POSITION);
MDLCACHE_CRITICAL_SECTION();
NPCThink();
GetNavigator()->StopMoving( false );
SetPoseParameter( "move_x", 0.0f );
SetPoseParameter( "move_y", 0.0f );
SetMoveType( MOVETYPE_WALK );
Teleport(&GetAbsOrigin(), NULL, &m_vecSmoothedVelocity);
m_iLightLevel = 255; // reset light level - will get set correctly by first usercmd after this marine is inhabited
}
// called when a player stops direct control of this marine
void CASW_Marine::UninhabitedBy(CASW_Player *player)
{
SetInhabited(false);
if (GetActiveWeapon())
OnUpdateShotRegulator();
// clear any forward momentum
Vector vel = GetLocalVelocity();
vel.x *= 0.8f;
vel.y *= 0.8f;
SetLocalVelocity(vel);
// stop the AI firing
m_bWantsToFire = m_bWantsToFire2 = false;
m_fMarineAimError = 0;
// tell the marine to hold position here
OrdersFromPlayer(player, ASW_ORDER_HOLD_POSITION, this, true, GetLocalAngles().y);
//SetCondition( COND_ASW_NEW_ORDERS );
// make sure his move_x/y pose parameters are at full moving fowards, so the AI follow movement will detect some sequence motion when calculating goal speed
MDLCACHE_CRITICAL_SECTION();
SetPoseParameter( "move_x", 1.0f );
SetPoseParameter( "move_y", 0.0f );
// make sure he thinks almost immediately
if (GetHealth() > 0)
{
SetThink ( &CAI_BaseNPC::CallNPCThink );
SetNextThink( gpGlobals->curtime );
}
// set his schedule to holding position
SetSchedule(SCHED_ASW_HOLD_POSITION);
//Teleport(&GetAbsOrigin(), NULL, &vec3_origin);
ClearForcedActionRequest();
SetMoveType( MOVETYPE_STEP );
m_iLightLevel = 255; // reset light level - will get set correctly by first usercmd after this marine is inhabited
m_nLastThinkTick = gpGlobals->tickcount - 1;
}
void CASW_Marine::SetInhabited(bool bInhabited)
{
if (!GetMarineResource())
return;
GetMarineResource()->SetInhabited(bInhabited);
}
void CASW_Marine::SetMarineResource(CASW_Marine_Resource *pMR)
{
if (pMR != m_MarineResource)
{
m_MarineResource = pMR;
PrecacheSpeech();
}
}
void CASW_Marine::DoImpactEffect( trace_t &tr, int nDamageType )
{
// don't do impact effects, they're simulated clientside by the tracer usermessage
return;
BaseClass::DoImpactEffect(tr, nDamageType);
}
void CASW_Marine::DoMuzzleFlash()
{
return; // asw - muzzle flashes are triggered by tracer usermessages instead to save bandwidth
// Our weapon takes our muzzle flash command
CBaseCombatWeapon *pWeapon = GetActiveWeapon();
if ( pWeapon )
{
pWeapon->DoMuzzleFlash();
//NOTENOTE: We do not chain to the base here
//m_nMuzzleFlashParity = (m_nMuzzleFlashParity+1) & ((1 << EF_MUZZLEFLASH_BITS) - 1);
BaseClass::BaseClass::DoMuzzleFlash();
}
else
{
BaseClass::DoMuzzleFlash();
}
}
extern ConVar asw_sentry_friendly_fire_scale;
int CASW_Marine::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
// make marines immune to crush damage
if ( info.GetDamageType() & DMG_CRUSH || asw_god.GetBool() )
{
return 0;
}
CTakeDamageInfo newInfo(info);
if ( asw_debug_marine_damage.GetBool() )
Msg( "Marine taking premodified damage of %f\n", newInfo.GetDamage() );
// scale sentry gun damage
if ( newInfo.GetAttacker() && IsSentryClass( newInfo.GetAttacker()->Classify() ) )
{
if ( asw_sentry_friendly_fire_scale.GetFloat() <= 0 )
return 0;
newInfo.ScaleDamage( asw_sentry_friendly_fire_scale.GetFloat() );
}
// AI marines take much less damage from explosive barrels since they're too dumb to not get near them
if ( !IsInhabited() && info.GetAttacker() && info.GetAttacker()->Classify() == CLASS_ASW_EXPLOSIVE_BARREL )
{
newInfo.ScaleDamage( 0.1f );
if ( asw_debug_marine_damage.GetBool() )
Msg( " Scaled AI taking damage from explosive barrel down to %f\n", newInfo.GetDamage() );
}
// don't allow FF from melee attacks
bool bFriendlyFire = newInfo.GetAttacker() && newInfo.GetAttacker()->Classify() == CLASS_ASW_MARINE;
if ( bFriendlyFire )
{
CASW_Marine *pOtherMarine = dynamic_cast<CASW_Marine*>(newInfo.GetAttacker());
if ( pOtherMarine && pOtherMarine->GetMarineResource() )
{
pOtherMarine->GetMarineResource()->m_iAliensKilledSinceLastFriendlyFireIncident = 0;
}
if ( pOtherMarine && !pOtherMarine->IsInhabited() && !(newInfo.GetDamageType() & DMG_DIRECT) )
{
// don't allow any damage if it's an AI firing: NOTE: This isn't 100% accurate, since the AI could've fired the shot, then a player switched into the marine while the projectile was in the air
if (asw_debug_marine_damage.GetBool())
Msg(" but all ignored, since it's from an AI\n");
return 0;
}
else
{
if (newInfo.GetDamageType() & DMG_CLUB)
{
if (asw_debug_marine_damage.GetBool())
Msg(" but all ignored, since it's FF meleee dmg\n");
return 0;
}
// drop the damage down by our absorption buffer
bool bFlamerDot = !!(newInfo.GetDamageType() & ( DMG_BURN | DMG_DIRECT ) );
if ( newInfo.GetDamage() > 0 && newInfo.GetAttacker() != this && !bFlamerDot )
{
bool bHardcoreMode = ASWGameRules() && ASWGameRules()->IsHardcoreMode();
if ( !bHardcoreMode && asw_marine_ff_absorption.GetInt() != 0 )
{
float flNewDamage = info.GetDamage() * GetFFAbsorptionScale();
newInfo.SetDamage(flNewDamage);
if ( asw_debug_marine_damage.GetBool() )
{
Msg(" FF damage (%f) reduced to %f from FF absorption (%f)\n", newInfo.GetDamage(), flNewDamage, GetFFAbsorptionScale());
}
}
GetMarineSpeech()->QueueChatter( CHATTER_FRIENDLY_FIRE, gpGlobals->curtime + 0.4f, gpGlobals->curtime + 1.0f );
m_fLastFriendlyFireTime = gpGlobals->curtime;
}
}
}
// don't kill the marine in one hit unless he's on 1 health
bool bKillProtection = false;
if (asw_marine_death_protection.GetBool() && !(ASWGameRules() && ASWGameRules()->IsHardcoreMode())) // no 1 hit protection in hardcore mode
{
if (newInfo.GetDamageType() != DMG_CRUSH && newInfo.GetDamageType() != DMG_FALL
&& newInfo.GetDamageType() != DMG_INFEST && GetHealth() > 1)
{
if (newInfo.GetDamage() > GetHealth())
bKillProtection = true;
}
}
if ( newInfo.GetInflictor() && newInfo.GetInflictor()->Classify() == CLASS_ASW_DOOR && ASWGameRules()->GetSkillLevel() < 3 )
{
// Don't crush the player on easier difficulties
Vector vDir = newInfo.GetDamageForce();
VectorNormalize( vDir );
newInfo.SetDamageForce( vDir * 20.0f );
Vector vNewPos = newInfo.GetDamagePosition() + newInfo.GetDamageForce();
vNewPos.z = GetAbsOrigin().z + 15.0f;
Vector vNewVel = vDir * 5.0f;
Teleport( &vNewPos, NULL, &vNewVel );
newInfo.SetDamage( 5.0f );
}
// reduce damage thanks to leadership
// see if we pass the chance
float fChance = MarineSkills()->GetHighestSkillValueNearby(GetAbsOrigin(),
asw_leadership_radius.GetFloat(),
ASW_MARINE_SKILL_LEADERSHIP, ASW_MARINE_SUBSKILL_LEADERSHIP_DAMAGE_RESIST );
static int iLeadershipResCount = 0;
if (random->RandomFloat() < fChance)
{
float fNewDamage = newInfo.GetDamage() * 0.5f;
if (fNewDamage <= 0)
return 0;
newInfo.SetDamage(fNewDamage);
iLeadershipResCount++;
if (asw_debug_marine_damage.GetBool())
{
Msg(" Damage reduced by nearby leadership to %f (leadership resistance applied %d times so far)\n", fNewDamage, iLeadershipResCount);
}
}
if ( newInfo.GetAttacker() )
{
// store FF damage dealt based on adjusted damage
if (newInfo.GetAttacker()->Classify() == CLASS_ASW_MARINE)
{
CASW_Marine *pOtherMarine = dynamic_cast<CASW_Marine*>(newInfo.GetAttacker());
if ( pOtherMarine && pOtherMarine->GetMarineResource() )
{
CASW_Marine_Resource *pMR = pOtherMarine->GetMarineResource();
if ( pMR )
{
pMR->m_fFriendlyFireDamageDealt += newInfo.GetDamage();
pMR->m_TimelineFriendlyFire.RecordValue( newInfo.GetDamage() );
}
}
if ( newInfo.GetAttacker() != this )
{
ASWFailAdvice()->OnFriendlyFire( newInfo.GetDamage() );
}
}
ApplyPassiveArmorEffects( newInfo );
// reduce damage and shock alien if we have electrified armour on
if ( newInfo.GetDamageType() & DMG_SLASH )
{
if ( IsElectrifiedArmorActive() )
{
CASW_Alien *pAlien = dynamic_cast<CASW_Alien*>( newInfo.GetAttacker() );
if ( pAlien )
{
const float flDamageReturn = 20.0f;
Vector vecToTarget = pAlien->WorldSpaceCenter() - WorldSpaceCenter();
vecToTarget.z = 0;
VectorNormalize( vecToTarget );
Vector vecForce = vecToTarget * 20 + Vector( 0, 0, 1 ) * 10;
CTakeDamageInfo returninfo( this, this,
vecForce, newInfo.GetAttacker()->WorldSpaceCenter(), flDamageReturn, DMG_SHOCK | DMG_BLAST );
pAlien->TakeDamage( returninfo );
//pAlien->ElectroShockBig( vecForce, WorldSpaceCenter() );
CRecipientFilter filter;
filter.AddAllPlayers();
UserMessageBegin( filter, "ASWEnemyZappedByThorns" );
WRITE_SHORT( entindex() );
WRITE_SHORT( pAlien->entindex() );
MessageEnd();
newInfo.ScaleDamage( 0.25f );
if (asw_debug_marine_damage.GetBool())
{
Msg(" Damage reduced by electrified armor to %f\n", newInfo.GetDamage() );
}
}
}
else // if ( newInfo.GetAttacker() )
{
if ( !m_bHasBeenMobAttacked )
{
if ( m_fLastMobDamageTime > 0.0f && m_fLastMobDamageTime + 1.5f < gpGlobals->curtime )
{
// It's been a while, reset
m_pRecentAttackers[ 0 ] = newInfo.GetAttacker()->entindex();
for ( int nAttackers = 1; nAttackers < ASW_MOB_VICTIM_SIZE; ++nAttackers )
{
m_pRecentAttackers[ nAttackers ] = 0;
}
}
else
{
int nAttackers;
for ( nAttackers = 0; nAttackers < ASW_MOB_VICTIM_SIZE; ++nAttackers )
{
if ( m_pRecentAttackers[ nAttackers ] == newInfo.GetAttacker()->entindex() )
{
break;
}
if ( m_pRecentAttackers[ nAttackers ] == 0 )
{
m_pRecentAttackers[ nAttackers ] = newInfo.GetAttacker()->entindex();
break;
}
}
if ( nAttackers >= ASW_MOB_VICTIM_SIZE )
{
ASWFailAdvice()->OnMarineMobAttacked();
m_bHasBeenMobAttacked = true;
m_fLastMobDamageTime = 0.0f;
}
}
m_fLastMobDamageTime = gpGlobals->curtime;
}
}
}
}
int iPreDamageHealth = GetHealth();
CASW_GameStats.Event_MarineTookDamage( this, newInfo );
int result = BaseClass::OnTakeDamage_Alive(newInfo);
int iDamageTaken = iPreDamageHealth - GetHealth();
if (asw_debug_marine_damage.GetBool() && result > 0)
Msg(" Marine took final damage: %f of type %d\n", newInfo.GetDamage(), newInfo.GetDamageType());
// notify weapons of damage
if (GetASWWeapon(0))
GetASWWeapon(0)->OnMarineDamage(newInfo);
if (GetASWWeapon(1))
GetASWWeapon(1)->OnMarineDamage(newInfo);
if (GetASWWeapon(2))
GetASWWeapon(2)->OnMarineDamage(newInfo);
if ( ASWDirector() )
ASWDirector()->MarineTookDamage( this, newInfo, bFriendlyFire );
if (m_iHealth <= 0)
{
CASW_Door *pDoor = dynamic_cast<CASW_Door*>(newInfo.GetInflictor());
if (!pDoor) // can't survive damage from a falling door, even with kill protection or die hard
{
if (bKillProtection)
m_iHealth = 1;
}
}
if ( newInfo.GetDamage() > 0 )
{
if ( m_hCurrentHack.Get() )
{
ASWFailAdvice()->OnHackerHurt( newInfo.GetDamage() );
}
bool bShowFFIcon = bFriendlyFire;
if ( newInfo.GetAttacker() )
{
IGameEvent * event = gameeventmanager->CreateEvent( "marine_hurt" );
if ( event )
{
CBasePlayer *pPlayer = GetCommander();
event->SetInt( "userid", ( pPlayer ? pPlayer->GetUserID() : 0 ) );
event->SetInt( "entindex", entindex() );
event->SetFloat( "health", static_cast< float >( MAX( 0.0f, GetHealth() ) ) / GetMaxHealth() );
CBasePlayer *pAttackPlayer = ToBasePlayer( newInfo.GetAttacker() );
if ( !pAttackPlayer )
{
CASW_Marine *pAttackMarine = dynamic_cast< CASW_Marine* >( newInfo.GetAttacker() );
if ( pAttackMarine )
{
pAttackPlayer = pAttackMarine->GetCommander();
if ( pAttackMarine == this )
{
bShowFFIcon = false;
}
}
}
if ( pAttackPlayer )
{
event->SetInt( "attacker", pAttackPlayer->GetUserID() ); // hurt by other player
event->SetInt( "attackerindex", newInfo.GetAttacker()->entindex() ); // hurt by entity
}
else
{
event->SetInt( "attacker", 0 ); // hurt by entity
event->SetInt( "attackerindex", newInfo.GetAttacker()->entindex() ); // hurt by entity
}
gameeventmanager->FireEvent( event );
}
}
if ( IsInhabited() )
{
//Msg("took %f damage\n", info.GetDamage());
CASW_Player *player = GetCommander();
if (player)
{
if ( asw_screenflash.GetInt() > 0 )
{
color32 flash_col = {128,0,0,192};
flash_col.a = asw_screenflash.GetInt();
UTIL_ScreenFade( player, flash_col, 1.0f, 0.1f, FFADE_IN );
}
if ( asw_damage_indicator.GetBool() )
{
// Tell the player's client that he's been hurt.
CSingleUserRecipientFilter user( player );
UserMessageBegin( user, "Damage" );
WRITE_SHORT( clamp( (int)newInfo.GetDamage(), 0, 32000 ) );
WRITE_LONG( newInfo.GetDamageType() );
// Tell the client whether they should show it in the indicator
if ( !(newInfo.GetDamageType() & (DMG_DROWN | DMG_FALL | DMG_BURN | DMG_INFEST | DMG_RADIATION) ) )
{
WRITE_BOOL( true );
WRITE_VEC3COORD( newInfo.GetDamagePosition() );
WRITE_BOOL( bShowFFIcon );
}
else
{
WRITE_BOOL( false );
}
MessageEnd();
}
if (info.GetDamageType() & DMG_BLURPOISON)
{
float duration = asw_buzzer_poison_duration.GetFloat();
// affect duration by mission difficulty
if (ASWGameRules())
{
duration = duration + (duration * (ASWGameRules()->GetMissionDifficulty() / 10.0f));
}
if (duration > 0)
UTIL_ASW_PoisonBlur( player, duration );
}
bool bBurnDamage = ( info.GetDamageType() & ( DMG_BURN | DMG_DIRECT ) ) != 0;
bool bElectrifiedArmorAbsorbed = ( ( info.GetDamageType() & DMG_SLASH ) && IsElectrifiedArmorActive() );
// play a meaty hit sound when attacked by aliens or FF
if ( ( !bBurnDamage && !bElectrifiedArmorAbsorbed ) ) //|| bFriendlyFire )
{
//UTIL_ASW_ScreenShake( GetAbsOrigin(), 4.0f, 30.0f, 0.25f, 128.0f, SHAKE_START );
if ( !info.GetInflictor() )
{
ASW_TransmitShakeEvent( player, 2.0f, 40.0f, 0.2f, SHAKE_START );
}
else
{
ASW_TransmitShakeEvent( player, 20.0f, 1.0f, 0.3f, SHAKE_START, (info.GetInflictor()->GetAbsOrigin() - GetAbsOrigin()).Normalized() );
}
// this is the sound that's played for the local player only
CSingleUserRecipientFilter localfilter( player );
localfilter.MakeReliable();
// this is the sound that's played for all other players, but the local player
CPASAttenuationFilter othersfilter( this, "ASW.MarineImpact" );
othersfilter.RemoveRecipient( player );
// if they take more than 10% damage in one hit or their health is below 20%, play a bigger sound
if ( float(iDamageTaken) / float(GetMaxHealth()) > 0.1 || float(m_iHealth) / float(GetMaxHealth()) < 0.25 )
{
CBaseEntity::EmitSound( localfilter, entindex(), "ASW.MarineImpactHeavyFP" );
CBaseEntity::EmitSound( othersfilter, entindex(), "ASW.MarineImpactHeavy" );
}
else
{
CBaseEntity::EmitSound( localfilter, entindex(), "ASW.MarineImpactFP" );
CBaseEntity::EmitSound( othersfilter, entindex(), "ASW.MarineImpact" );
}
}
}
}
else
{
// AI's being hurt, check he has a weapon (and maybe switch if it's not selected)
CheckAutoWeaponSwitch();
// if they take more than 10% damage in one hit or their health is below 20%, play a bigger sound
if ( float(iDamageTaken) / float(GetMaxHealth()) > 0.1 || float(m_iHealth) / float(GetMaxHealth()) < 0.25 )
{
EmitSound( "ASW.MarineImpactHeavy" );
}
else
{
EmitSound( "ASW.MarineImpact" );
}
}
}
if (result > 0)
{
// update our stats
CASW_Marine_Resource *pMR = GetMarineResource();
if ( pMR )
{
if (newInfo.GetDamage() > 0)
{
pMR->m_bHurt = true;
if ( asw_debug_marine_damage.GetBool() )
{
Msg( "Total damage taken is %f and taking damage %f ", pMR->m_fDamageTaken, newInfo.GetDamage() );
}
pMR->m_fDamageTaken += iDamageTaken;
pMR->m_TimelineHealth.RecordValue( MAX( 0, GetHealth() ) );
if ( asw_debug_marine_damage.GetBool() )
{
Msg( "so new total is %f (%d/%d) %d lost\n", pMR->m_fDamageTaken, GetHealth(), GetMaxHealth(), GetMaxHealth() - GetHealth() );
}
}
if (info.GetAttacker() && info.GetAttacker()->Classify() == CLASS_ASW_MARINE)
m_fFriendlyFireDamage += iDamageTaken;
// check for flagging as wounded
float fWoundDamageThreshold = 0.5f;
if (ASWGameRules())
{
if (ASWGameRules()->GetSkillLevel() == 1)
fWoundDamageThreshold = 0.4f;
if (ASWGameRules()->GetSkillLevel() >= 3)
fWoundDamageThreshold = 0.6f;
}
float fWoundPoint = GetMaxHealth() * fWoundDamageThreshold;
if (m_iHealth < fWoundPoint)
{
pMR->m_bTakenWoundDamage = true;
}
}
if (asw_debug_marine_damage.GetBool())
Msg("marine took damage %f (total taken %f, ff taken %f)\n",
newInfo.GetDamage(), pMR->m_fDamageTaken, m_fFriendlyFireDamage);
// if we take fire damage, catch on fire
float fPainInterval = 0.7f;
if ( info.GetDamageType() & DMG_BURN )
{
ASW_Ignite( 1.0f, 0, newInfo.GetAttacker(), info.GetWeapon() );
}
// short stumbles on damage
if ( !(newInfo.GetDamageType() & (DMG_BURN | DMG_DIRECT | DMG_RADIATION) ) && asw_marine_stumble_on_damage.GetBool() )
{
Stumble( newInfo.GetAttacker(), newInfo.GetDamageForce(), true );
}
// flinch
if (gpGlobals->curtime > m_fNextPainSoundTime)
{
DoAnimationEvent( PLAYERANIMEVENT_FLINCH );
if (info.GetDamage() > 35.0f)
GetMarineSpeech()->PersonalChatter(CHATTER_PAIN_LARGE);
else
GetMarineSpeech()->PersonalChatter(CHATTER_PAIN_SMALL);
m_fNextPainSoundTime = gpGlobals->curtime + fPainInterval;
}
}
return result;
}
// you can assume there is an attacker when this function is called.
void CASW_Marine::ApplyPassiveArmorEffects( CTakeDamageInfo &dmgInfo ) RESTRICT
{
Assert( dmgInfo.GetAttacker() );
if ( dmgInfo.GetDamageType() & (DMG_CRUSH|DMG_FALL|DMG_DROWN|DMG_PARALYZE|DMG_DROWNRECOVER|DMG_DISSOLVE) )
return;
// do I have ordinary (non zappy) armor?
CASW_Weapon_Normal_Armor *pArmor = NULL;
for (int i=0; i<ASW_MAX_MARINE_WEAPONS; ++i)
{
CBaseCombatWeapon *pWep = m_hMyWeapons[i].Get();
if ( pWep && pWep->Classify() == CLASS_ASW_NORMAL_ARMOR )
{
pArmor = assert_cast<CASW_Weapon_Normal_Armor *>(pWep);
break;
}
}
if ( pArmor )
{
dmgInfo.ScaleDamage( pArmor->GetDamageScaleFactor() );
}
}
CASW_Weapon* CASW_Marine::GetActiveASWWeapon( void ) const
{
return dynamic_cast<CASW_Weapon*>(GetActiveWeapon());
}
bool CASW_Marine::IsWounded() const
{
return ( ( float(GetHealth()) / float(GetMaxHealth()) ) < 0.6f );
}
// asw todo: fix this!
bool CASW_Marine::IsAlienNear()
{
/*
CBaseEntity* pEntity = NULL;
while ((pEntity = gEntList.FindEntityByClassname( pEntity, "asw_drone" )) != NULL)
{
CASW_Drone* drone = dynamic_cast<CASW_Drone*>(pEntity);
if ( drone && drone->GetAbsOrigin().DistTo(GetAbsOrigin()) < 1220.0f)
return true;
}*/
int count = AimTarget_ListCount();
if ( count )
{
CBaseEntity **pList = (CBaseEntity **)stackalloc( sizeof(CBaseEntity *) * count );
AimTarget_ListCopy( pList, count );
for ( int i = 0; i < count; i++ )
{
CBaseEntity *pEntity = pList[i];
// Don't shoot yourself
if ( pEntity == this )
continue;
if (!pEntity->IsAlive() || !pEntity->edict() )
continue;
// is it something we dislike?
Disposition_t rel = CBaseCombatCharacter::IRelationType( pEntity );
if ( rel != D_HT && rel != D_FR )
continue;
// if it's nearby then let's do a reload shout
if (pEntity->GetAbsOrigin().DistToSqr(GetAbsOrigin()) < 1440000)
return true;
}
}
return false;
}
void CASW_Marine::HurtJunkItem(CBaseEntity *pEnt, const CTakeDamageInfo &info)
{
// increase our shot timer, so shooting barrels/crates etc doesn't reduce our accuracy
if (!(info.GetDamageType() & DMG_DIRECT)) // ignore flame DoT
{
m_fLastShotJunkTime = gpGlobals->curtime;
}
}
void CASW_Marine::HurtAlien(CBaseEntity *pAlien, const CTakeDamageInfo &info)
{
bool bMeleeDamage = ( info.GetDamageType() & DMG_CLUB ) != 0;
if ( !bMeleeDamage )
{
if ( GetMarineResource() )
{
GetMarineResource()->m_bDealtNonMeleeDamage = true;
}
}
m_flLastHurtAlienTime = gpGlobals->curtime;
CASW_Weapon *pWeapon = GetActiveASWWeapon();
if ( pWeapon && pAlien )
{
IASW_Spawnable_NPC *pNPC = dynamic_cast<IASW_Spawnable_NPC*>(pAlien);
if ( pNPC && !(info.GetDamageType() & (DMG_BURN | DMG_BLAST | DMG_SHOCK | DMG_DIRECT) ) )
{
// TODO: Make sure flamer and stun grenades still work
/*
float flIgniteChance = 0;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flIgniteChance, mod_ignite );
if ( RandomFloat() < flIgniteChance )
{
pNPC->ASW_Ignite(5.0f, 0, info.GetAttacker());
}
float flElectroChance = 0;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flElectroChance, mod_electro_stun );
if ( RandomFloat() < flElectroChance )
{
pNPC->ElectroStun( 5.0f );
}
*/
}
}
// don't do any chatter effects if this alien is being hurt by a burn DoT
CASW_Burning* pBurning = dynamic_cast<CASW_Burning*>(info.GetInflictor());
if (pBurning)
return;
if (!(info.GetDamageType() & DMG_DIRECT)) // ignore flame DoT
{
m_fLastShotAlienTime = gpGlobals->curtime;
}
// don't do any hurt alien affects against the little grubs or eggs
if (pAlien &&
(pAlien->Classify() == CLASS_ASW_GRUB ||
pAlien->Classify()== CLASS_ASW_ALIEN_GOO ||
pAlien->Classify() == CLASS_ASW_EGG ))
return;
bool bMadFiring = false;
if (gpGlobals->curtime > s_fNextMadFiringChatter)
{
if (!(info.GetDamageType() & (DMG_BURN | DMG_BLAST | DMG_SHOCK)))
{
if (pWeapon)
{
//Msg("Alien hurt by a %s\n", pWeapon->GetClassname());
m_fMadFiringCounter += pWeapon->GetMadFiringBias() * (pWeapon->GetFireRate() / pWeapon->GetNumPellets()); // add more per shot for slower weapons
if (m_fMadFiringCounter >= asw_mad_firing_break.GetInt())
{
bMadFiring = true;
m_fMadFiringCounter = 0;
//s_fNextMadFiringChatter = gpGlobals->curtime + // need this?
}
}
}
}
if (bMadFiring)
{
// check for autogun kill convos
bool bSkipChatter = false;
bool bAutogun = false;
if (GetMarineProfile())
{
if ( GetMarineProfile()->m_VoiceType == ASW_VOICE_WILDCAT || GetMarineProfile()->m_VoiceType == ASW_VOICE_WOLFE ) // wildcat or wolfe
{
// check we're using an autogun
bAutogun = (dynamic_cast<CASW_Weapon_Autogun*>(GetActiveASWWeapon()) != NULL);
if (bAutogun)
{
if (CASW_MarineSpeech::StartConversation(CONV_AUTOGUN, this))
bSkipChatter = true;
if (GetMarineResource())
GetMarineResource()->m_iMadFiringAutogun++;
}
}
}
if (!bSkipChatter)
{
GetMarineSpeech()->Chatter(CHATTER_MAD_FIRING);
if (GetMarineResource() && !bAutogun)
GetMarineResource()->m_iMadFiring++;
}
}
else
GetMarineSpeech()->Chatter(CHATTER_FIRING_AT_ALIEN);
if (info.GetDamageType() & DMG_CLUB && GetMarineResource())
{
GetMarineResource()->m_iAliensKicked++;
if ( IsInhabited() && GetCommander() && GetMarineResource()->m_iAliensKicked > asw_medal_melee_hits.GetInt() )
{
GetCommander()->AwardAchievement( ACHIEVEMENT_ASW_MELEE_KILLS );
}
}
}
/*
// don't send angles when this marine is inhabited
void SendProxy_Angles( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID )
{
if (IsInhabited())
return NULL;
return BaseClass::SendProxy_Angles(pProp, pStruct, pData, pOut, iElement, objectID);
}
*/
void CASW_Marine::InhabitedPhysicsSimulate()
{
BaseClass::InhabitedPhysicsSimulate();
// check for deleting this
if ( m_pfnThink == (BASEPTR)&CBaseEntity::SUB_Remove )
{
if (GetNextThink() > 0 && GetNextThink() < gpGlobals->curtime)
{
SUB_Remove();
}
}
}
// post think only happens when inhabited
void CASW_Marine::PostThink()
{
//Msg("[S] Marine Postthink, sl=%d amount=%d tick=%f\n",
//m_bSlowHeal, m_iSlowHealAmount, m_fNextSlowHealTick);
BaseClass::PostThink();
DispatchAnimEvents( this );
// is this correct here? should happen during/before think, not after?
m_PlayerAnimState->Update( GetAbsAngles()[YAW], GetAbsAngles()[PITCH] );
if (IsInhabited())
{
StudioFrameAdvance();
}
ASWThinkEffects();
if ( NeedToUpdateSquad() )
{
GetSquadFormation()->UpdateFollowPositions();
}
// check for pushing out phys props jammed inside us
if ( VPhysicsGetObject() )
{
#ifdef ASW_MARINE_ALWAYS_VPHYSICS
VPhysicsGetObject()->UpdateShadow( GetAbsOrigin(), vec3_angle, false, gpGlobals->frametime );
#else
//if ( !VectorCompare( oldOrigin, GetAbsOrigin() ) )
if (gpGlobals->curtime <= m_fLastStuckTime + 1.0f) // if we were stuck in the last second, make sure our shadow is on
{
VPhysicsGetObject()->SetVelocity( &vec3_origin, NULL );
VPhysicsGetObject()->SetVelocityInstantaneous( &vec3_origin, &vec3_origin );
//IPhysicsShadowController *pController = VPhysicsGetObject()->GetShadowController();
//float teleport_dist = pController ? VPhysicsGetObject()->GetTeleportDistance() : 0;
//if (pController)
//VPhysicsGetObject()->SetTeleportDistance(0.1f); // make sure the shadow teleports to its new position
// move the marine's vphys shadow to our current position
VPhysicsGetObject()->SetPosition( GetAbsOrigin(), vec3_angle, true );
//VPhysicsGetObject()->UpdateShadow( GetAbsOrigin(), vec3_angle, false, gpGlobals->frametime );
VPhysicsGetObject()->EnableCollisions(true);
// clear its velocity, so the marine doesn't wake up phys objects - doesn't work :/
VPhysicsGetObject()->SetVelocityInstantaneous( &vec3_origin, &vec3_origin );
//if (pController)
//VPhysicsGetObject()->SetTeleportDistance(teleport_dist);
}
else // no vphysics shadow enabled if we're not stuck
{
VPhysicsGetObject()->EnableCollisions(false);
}
#endif
}
if ( m_bCheckContacts )
{
CheckPhysicsContacts();
}
}
void CASW_Marine::ASWThinkEffects()
{
float fDeltaTime = gpGlobals->curtime - m_fLastASWThink;
if ( gpGlobals->curtime > m_flNextPositionHistoryTime )
{
CASW_Marine_Resource *pMR = GetMarineResource();
if ( pMR )
{
pMR->m_TimelinePosX.RecordValue( GetAbsOrigin().x );
pMR->m_TimelinePosY.RecordValue( GetAbsOrigin().y );
}
AddPositionHistory();
m_flNextPositionHistoryTime = gpGlobals->curtime + asw_movement_direction_interval.GetFloat();
}
if ( gpGlobals->maxClients > 1 )
{
m_LagCompensation.StorePositionHistory();
}
UpdatePowerupDuration();
UpdateCombatStatus();
// general timer for healing/infestation
if ( (m_bSlowHeal || IsInfested()) && GetHealth() > 0 )
{
while (gpGlobals->curtime >= m_fNextSlowHealTick)
{
if ( m_fNextSlowHealTick == 0 )
{
m_fNextSlowHealTick = gpGlobals->curtime;
}
m_fNextSlowHealTick += ( ASW_MARINE_HEALTICK_RATE * ( 1.0f / m_flHealRateScale ) );
// check slow heal isn't over out cap
if (m_bSlowHeal)
{
//m_iSlowHealAmount = GetMaxHealth() - GetHealth();
if ( GetHealth() >= GetMaxHealth() && !IsInfested() ) // clear all slow healing once we're at max health
{
ASWFailAdvice()->OnMarineOverhealed( m_iSlowHealAmount );
m_iSlowHealAmount = 0; // (and not infested - infestation means we'll be constantly dropping health, so we can keep the heal around)
}
int amount = MIN(4, m_iSlowHealAmount);
if (GetHealth() + amount > GetMaxHealth())
amount = GetMaxHealth() - GetHealth();
if (asw_debug_marine_damage.GetBool())
Msg("SH %f: marine applied slow heal of %d\n", gpGlobals->curtime, amount);
// change the health
SetHealth(GetHealth() + amount);
if ( GetMarineResource() )
{
GetMarineResource()->m_TimelineHealth.RecordValue( GetHealth() );
}
m_iSlowHealAmount -= amount;
if (m_iSlowHealAmount <= 0)
{
m_bSlowHeal = false;
}
}
if ( IsInfested() )
{
m_iInfestCycle++;
if ( m_iInfestCycle >= 3 ) // only do the infest damage once per second
{
float DamagePerTick = ASWGameRules()->TotalInfestDamage() / 20.0f; // this is also damage per second (based on standard 20 second infest time, slow heal interval of 0.33f and us only applying this every 1 in 3)
if ( asw_debug_marine_damage.GetBool() )
Msg("SH %f: Infest DamagePerTick %f (infest time left = %f)\n", gpGlobals->curtime, DamagePerTick, m_fInfestedTime);
CTakeDamageInfo info(NULL, NULL, Vector(0,0,0), GetAbsOrigin(), DamagePerTick, DMG_INFEST);
TakeDamage( info );
if ( IsElectrifiedArmorActive() )
{
// Do some serious hurt to that bug each time he bites!
CureInfestation( NULL, 0.4f );
}
m_iInfestCycle = 0;
m_fInfestedTime -= 1.0f;
if ( m_fInfestedTime <= 0 )
{
m_fInfestedTime = 0;
if ( !IsInhabited() )
{
DoEmote( 2 );
}
GetMarineResource()->SetInfested(false);
if (!m_bPlayedCureScream) // play some effects of the parasite dying
{
m_bPlayedCureScream = true;
CSoundParameters params;
if ( CBaseEntity::GetParametersForSound( "ASW_Parasite.Death", params, NULL ) )
{
Vector vecOrigin = WorldSpaceCenter();
CPASAttenuationFilter filter( vecOrigin, params.soundlevel );
EmitSound_t ep;
ep.m_nChannel = CHAN_AUTO;
ep.m_pSoundName = params.soundname;
ep.m_flVolume = params.volume;
ep.m_SoundLevel = params.soundlevel;
ep.m_nPitch = params.pitch;
ep.m_pOrigin = &vecOrigin;
CBaseEntity::EmitSound( filter, 0 /*sound.entityIndex*/, ep );
}
UTIL_ASW_DroneBleed( WorldSpaceCenter(), Vector(0, 0, 1), 4 );
}
if (m_hInfestationCurer.Get() && m_hInfestationCurer->GetMarineResource())
{
if ( m_hInfestationCurer->GetCommander() && m_hInfestationCurer->IsInhabited() )
{
m_hInfestationCurer->GetCommander()->AwardAchievement( ACHIEVEMENT_ASW_INFESTATION_CURING );
}
m_hInfestationCurer->GetMarineResource()->m_iCuredInfestation++;
m_hInfestationCurer = NULL;
}
IGameEvent * event = gameeventmanager->CreateEvent( "marine_infested_cured" );
if ( event )
{
CASW_Player *pPlayer = NULL;
if ( m_hInfestationCurer.Get() )
{
pPlayer = m_hInfestationCurer->GetCommander();
}
event->SetInt( "entindex", entindex() );
event->SetInt( "userid", ( pPlayer ? pPlayer->GetUserID() : 0 ) );
gameeventmanager->FireEvent( event );
}
}
}
}
}
}
// check for FFGuard time running out
if (m_fFFGuardTime != 0 && gpGlobals->curtime > m_fFFGuardTime)
{
// power up weapons again (play a sound?)
}
if (m_hUsingEntity.Get())
{
IASW_Server_Usable_Entity* pUsable = dynamic_cast<IASW_Server_Usable_Entity*>(m_hUsingEntity.Get());
if (pUsable)
{
if (!pUsable->IsUsable(this))
{
StopUsing();
}
else
{
pUsable->MarineUsing(this, fDeltaTime);
}
}
}
if (m_vecFacingPointFromServer.Get()!=vec3_origin && gpGlobals->curtime > m_fStopFacingPointTime)
{
m_vecFacingPointFromServer = vec3_origin;
}
// update emotes
TickEmotes(fDeltaTime);
// update this marine's resource
if (GetMarineResource() && GetActiveASWWeapon())
{
//Msg("Updating firing for %s\n", GetMarineResource()->GetProfile()->m_ShortName);
if (GetActiveASWWeapon()->IsFiring())
{
if (GetActiveASWWeapon()->IsRapidFire())
GetMarineResource()->SetFiring(1);
else
GetMarineResource()->SetFiring(2);
}
else
{
GetMarineResource()->SetFiring(0);
}
}
else if (GetMarineResource())
{
GetMarineResource()->SetFiring(0);
}
// unfreeze the marine sometime after he's started getting up
if ((GetFlags() & FL_FROZEN) && m_fUnfreezeTime != 0)
{
if (gpGlobals->curtime >= m_fUnfreezeTime)
{
m_fUnfreezeTime = 0;
RemoveFlag(FL_FROZEN);
}
}
// check for kicking
if (m_fKickTime !=0 && gpGlobals->curtime >= m_fKickTime)
{
m_fKickTime = 0;
//DoKickEffect();
}
if ( gpGlobals->curtime > m_fLastFriendlyFireTime + 2.0f )
{
m_fFriendlyFireAbsorptionTime = MAX( 0, m_fFriendlyFireAbsorptionTime - fDeltaTime * asw_marine_ff_absorption_decay_rate.GetFloat() );
}
else
{
m_fFriendlyFireAbsorptionTime = MIN( 1.0f, m_fFriendlyFireAbsorptionTime + fDeltaTime * asw_marine_ff_absorption_build_rate.GetFloat() );
}
if ( gpGlobals->curtime > m_fLastAmmoCheckTime + 2.0f )
{
CheckAndRequestAmmo();
}
if (m_fMadFiringCounter > 0 && GetActiveASWWeapon() && !GetActiveASWWeapon()->IsReloading()) // don't tick down the mad firing counter while you're reloading
{
m_fMadFiringCounter -= fDeltaTime * asw_mad_firing_decay.GetFloat();
if (asw_debug_marine_chatter.GetBool())
{
float fFraction = m_fMadFiringCounter / asw_mad_firing_break.GetFloat();
//char buffer[256];
//Q_snprintf(buffer, sizeof(buffer), );
engine->Con_NPrintf( 1, "MadFiringCounter: (%f) %f/%f", fFraction,
m_fMadFiringCounter, asw_mad_firing_break.GetFloat() );
}
}
//if (GetAbsVelocity() != vec3_origin || (GetMarineResource() && GetMarineResource()->IsFiring())
bool bMoving = IsInhabited() ? GetAbsVelocity() != vec3_origin : GetSmoothedVelocity().Length()>1.0f;
if (bMoving || (GetMarineResource() && GetMarineResource()->IsFiring())
|| m_hUsingEntity.Get())
{
m_fLastStillTime = gpGlobals->curtime;
}
else
{
if (gpGlobals->curtime > m_fLastStillTime + m_fIdleChatterDelay && m_fLastStillTime != 0)
{
if (asw_debug_marine_chatter.GetBool())
Msg("%s trying to idle chatter (cur=%f snextidle=%f idlechatdelay=%f(%f)\n",
GetMarineProfile()->m_ShortName,
gpGlobals->curtime, s_fNextIdleChatterTime, m_fIdleChatterDelay, m_fLastStillTime + m_fIdleChatterDelay
);
if (gpGlobals->curtime > s_fNextIdleChatterTime && GetMarineSpeech()->AllowCalmConversations(-1)) // check no-one else idle chatted recently
{
if (asw_debug_marine_chatter.GetBool())
Msg(" and there's a free gap, woot!\n");
bool bDidIdle = false;
// do a special idle?
if (random->RandomFloat() < asw_marine_special_idle_chatter_chance.GetFloat())
{
int iTryConversation = CONV_NONE;
if (GetMarineProfile()->m_VoiceType == ASW_VOICE_SARGE)
{
if (random->RandomFloat() < 0.5f)
iTryConversation = CONV_SARGE_IDLE;
else
iTryConversation = CONV_SARGE_JAEGER_CONV1;
}
else if (GetMarineProfile()->m_VoiceType == ASW_VOICE_JAEGER)
{
if (random->RandomFloat() < 0.5f)
iTryConversation = CONV_STILL_BREATHING;
else
iTryConversation = CONV_SARGE_JAEGER_CONV2;
}
else if (GetMarineProfile()->m_VoiceType == ASW_VOICE_CRASH)
{
if (random->RandomFloat() < 0.5f)
iTryConversation = CONV_CRASH_COMPLAIN;
else
iTryConversation = CONV_CRASH_IDLE;
}
else if (GetMarineProfile()->m_VoiceType == ASW_VOICE_WOLFE)
{
iTryConversation = CONV_WOLFE_BEST;
}
else if (GetMarineProfile()->m_VoiceType == ASW_VOICE_VEGAS)
{
iTryConversation = CONV_TEQUILA;
}
if (iTryConversation != CONV_NONE && CASW_MarineSpeech::StartConversation(iTryConversation, this))
bDidIdle = true;
else if (GetMarineSpeech()->Chatter(CHATTER_IDLE)) // fall back to regular idle if the conversation failed to start
bDidIdle = true;
}
else if (GetMarineSpeech()->Chatter(CHATTER_IDLE))
bDidIdle = true;
if (bDidIdle)
s_fNextIdleChatterTime = gpGlobals->curtime + random->RandomInt(15, 25);
//s_fNextIdleChatterTime = gpGlobals->curtime + random->RandomInt(30, 60);
//m_fIdleChatterDelay = random->RandomInt(10, 20);
m_fIdleChatterDelay = random->RandomInt(25, 40);
}
else
{
if (asw_debug_marine_chatter.GetBool())
Msg(" but we can't cos someone else did an idle chat recently\n");
//m_fIdleChatterDelay = random->RandomInt(5, 10);
m_fIdleChatterDelay = random->RandomInt(20, 35);
}
m_fLastStillTime = gpGlobals->curtime;
}
}
GetMarineSpeech()->Update();
if (asw_debug_medals.GetBool() && IsInhabited() && gpGlobals->maxClients <= 1)
{
GetMarineResource()->DebugMedalStatsOnScreen();
}
// network down if we're applying our engineering aura
if (GetMarineResource())
GetMarineResource()->m_bUsingEngineeringAura = (m_fUsingEngineeringAura >= gpGlobals->curtime - 0.2f);
if (!IsInhabited())
{
// uninhabited ticking of the hacking puzzles
if (m_hCurrentHack.Get())
{
CUserCmd ucmd;
m_hCurrentHack->ASWPostThink(NULL, this, &ucmd, fDeltaTime); // todo send deltatime parameter
}
// uninhabited post frame for offhand equip
CASW_Weapon *pExtra = GetASWWeapon(2);
if (pExtra && pExtra != GetActiveWeapon() && pExtra->WantsOffhandPostFrame() )
{
float flSavedFrameTime = gpGlobals->frametime;
gpGlobals->frametime = fDeltaTime;
pExtra->ItemPostFrame();
gpGlobals->frametime = flSavedFrameTime;
}
}
if ( gpGlobals->curtime > m_flNextBreadcrumbTime )
{
CASW_GameStats.Event_MarineBreadcrumb( this );
m_flNextBreadcrumbTime = gpGlobals->curtime + ASW_BREADCRUMB_INTERVAL;
}
// we've been burned relatively recently
if ( m_flFirstBurnTime > 0 )
{
float flGraceTime = asw_marine_time_until_ignite.GetFloat();
// if we haven't been burned in the last chunk of the total time-to-ignite, reset the timer
// additionally, if our initial burn time is over the time-to-ignite time, reset
if ( (gpGlobals->curtime - m_flFirstBurnTime) > flGraceTime + 1.0f )
m_flFirstBurnTime = 0;
}
m_fLastASWThink = gpGlobals->curtime;
}
/*
void CASW_Marine::Activate( void )
{
BaseClass::Activate();
// Find all drones
CBaseEntity *pObject = NULL;
while ( ( pObject = gEntList.FindEntityByClassname( pObject, "asw_drone" ) ) != NULL )
{
// Tell the AI sensing list that we want to consider this
g_AI_SensedObjectsManager.AddEntity( pObject );
}
}
*/
bool CASW_Marine::AIWantsToFire()
{
return m_bWantsToFire || (asw_force_ai_fire.GetBool());
}
bool CASW_Marine::AIWantsToFire2()
{
return m_bWantsToFire2;
}
bool CASW_Marine::AIWantsToReload()
{
return false;
}
void CASW_Marine::FlashlightToggle()
{
if (IsEffectActive( EF_DIMLIGHT ))
FlashlightTurnOff();
else
FlashlightTurnOn();
}
void CASW_Marine::FlashlightTurnOn( void )
{
if (!IsEffectActive( EF_DIMLIGHT ))
{
AddEffects( EF_DIMLIGHT );
EmitSound( "ASWFlashlight.FlashlightToggle" );
}
}
void CASW_Marine::FlashlightTurnOff( void )
{
if (IsEffectActive( EF_DIMLIGHT ))
{
EmitSound( "ASWFlashlight.FlashlightToggle");
RemoveEffects( EF_DIMLIGHT );
}
}
bool CASW_Marine::HasFlashlight()
{
for (int i=0; i<MAX_WEAPONS; ++i)
{
CASW_Weapon_Flashlight *pFlashlight = dynamic_cast<CASW_Weapon_Flashlight*>(m_hMyWeapons[i].Get());
if (pFlashlight)
return true;
}
return false;
}
// player (and player controlled marines) always avoid marines
bool CASW_Marine::ShouldPlayerAvoid( void )
{
return true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// as basecombat char, but we don't allow picking up of ammo unless we are
// holding a gun that uses it
// also allow double the max if we're carrying two guns of that type
int CASW_Marine::GiveAmmo( int iCount, int iAmmoIndex, bool bSuppressSound)
{
int iGuns = GetNumberOfWeaponsUsingAmmo(iAmmoIndex);
if (iGuns <= 0)
return 0;
if (iCount <= 0)
return 0;
//if ( !g_pGameRules->CanHaveAmmo( this, iAmmoIndex ) )
//{
// game rules say I can't have any more of this ammo type.
//return 0;
//}
if ( iAmmoIndex < 0 || iAmmoIndex >= MAX_AMMO_SLOTS )
return 0;
int iMax = GetAmmoDef()->MaxCarry(iAmmoIndex, this) * iGuns;
int iAdd = MIN( iCount, iMax - m_iAmmo[iAmmoIndex] );
if ( iAdd < 1 )
return 0;
// Ammo pickup sound
if ( !bSuppressSound )
{
EmitSound( "BaseCombatCharacter.AmmoPickup" );
}
m_iAmmo.Set( iAmmoIndex, m_iAmmo[iAmmoIndex] + iAdd );
return iAdd;
}
int CASW_Marine::GiveAmmoToAmmoBag( int iCount, int iAmmoIndex, bool bSuppressSound)
{
if (iCount <= 0)
return 0;
//if ( !g_pGameRules->CanHaveAmmo( this, iAmmoIndex ) )
//{
// game rules say I can't have any more of this ammo type.
// return 0;
//}
if ( iAmmoIndex < 0 || iAmmoIndex >= MAX_AMMO_SLOTS )
return 0;
CASW_Weapon_Ammo_Bag *pBag = dynamic_cast<CASW_Weapon_Ammo_Bag*>(GetWeapon(0));
if (!pBag || !pBag->HasRoomForAmmo(iAmmoIndex))
{
pBag = dynamic_cast<CASW_Weapon_Ammo_Bag*>(GetWeapon(1));
if (!pBag || !pBag->HasRoomForAmmo(iAmmoIndex))
return 0;
}
// Ammo pickup sound
if ( !bSuppressSound )
{
EmitSound( "BaseCombatCharacter.AmmoPickup" );
}
int iAdd = pBag->AddAmmo(iCount, iAmmoIndex);
return iAdd;
}
bool CASW_Marine::CanGiveAmmoTo( CASW_Marine* pMarine )
{
// iterate over my weapons to find ammo bag(s)
for ( int iWeapon = 0; iWeapon < ASW_NUM_INVENTORY_SLOTS; iWeapon++ )
{
CASW_Weapon_Ammo_Bag *pAmmoBag = dynamic_cast<CASW_Weapon_Ammo_Bag*>( GetASWWeapon( iWeapon ) );
if (pAmmoBag)
{
// see if the ammo bag can give ammo for any weapons the recipient has
for ( int iRecipientWeapon = 0; iRecipientWeapon < ASW_NUM_INVENTORY_SLOTS; iRecipientWeapon++ )
{
CASW_Weapon *pRecipientWeapon = pMarine->GetASWWeapon( iRecipientWeapon );
if (pAmmoBag->CanGiveAmmoToWeapon(pRecipientWeapon))
return true;
}
}
}
return false;
}
bool CASW_Marine::CarryingAGunThatUsesAmmo( int iAmmoIndex)
{
int n = WeaponCount();
for (int i=0;i<n;i++)
{
CBaseCombatWeapon* pWeapon = GetWeapon(i);
if (!pWeapon)
continue;
if (pWeapon->GetPrimaryAmmoType() == iAmmoIndex
|| pWeapon->GetSecondaryAmmoType() == iAmmoIndex)
return true;
}
return false;
}
void CASW_Marine::Weapon_Equip( CBaseCombatWeapon *pWeapon )
{
// Add the weapon to my weapon inventory
for (int i=0;i<MAX_WEAPONS;i++)
{
if (!m_hMyWeapons[i])
{
m_hMyWeapons.Set( i, pWeapon );
break;
}
}
Weapon_Equip_Post(pWeapon);
}
void CASW_Marine::Weapon_Equip_In_Index( CBaseCombatWeapon *pWeapon, int index )
{
if (GetWeapon(index)==NULL)
{
m_hMyWeapons.Set(index, pWeapon);
Weapon_Equip_Post(pWeapon);
}
}
// some things to do on the weapon after it's been put into the array
void CASW_Marine::Weapon_Equip_Post( CBaseCombatWeapon *pWeapon)
{
// Weapon is now on my team
pWeapon->ChangeTeam( GetTeamNumber() );
// ----------------------
// Give Primary Ammo
// ----------------------
// If gun doesn't use clips, just give ammo
if (pWeapon->GetMaxClip1() == -1)
{
GiveAmmo(pWeapon->GetDefaultClip1(), pWeapon->m_iPrimaryAmmoType);
}
// If default ammo given is greater than clip
// size, fill clips and give extra ammo
else if (pWeapon->GetDefaultClip1() > pWeapon->GetMaxClip1() )
{
pWeapon->m_iClip1 = pWeapon->GetMaxClip1();
GiveAmmo( (pWeapon->GetDefaultClip1() - pWeapon->GetMaxClip1()), pWeapon->m_iPrimaryAmmoType);
}
// ----------------------
// Give Secondary Ammo
// ----------------------
// If gun doesn't use clips, just give ammo
if (pWeapon->GetMaxClip2() == -1)
{
GiveAmmo(pWeapon->GetDefaultClip2(), pWeapon->m_iSecondaryAmmoType);
}
// If default ammo given is greater than clip
// size, fill clips and give extra ammo
else if ( pWeapon->GetDefaultClip2() > pWeapon->GetMaxClip2() )
{
pWeapon->m_iClip2 = pWeapon->GetMaxClip2();
GiveAmmo( (pWeapon->GetDefaultClip2() - pWeapon->GetMaxClip2()), pWeapon->m_iSecondaryAmmoType);
}
pWeapon->Equip( this );
// Gotta do this *after* Equip because it may whack maxRange
if ( IsPlayer() == false )
{
// If SF_NPC_LONG_RANGE spawn flags is set let weapon work from any distance
if ( HasSpawnFlags(SF_NPC_LONG_RANGE) )
{
m_hActiveWeapon->m_fMaxRange1 = 999999999;
m_hActiveWeapon->m_fMaxRange2 = 999999999;
}
}
WeaponProficiency_t proficiency;
proficiency = CalcWeaponProficiency( pWeapon );
if( weapon_showproficiency.GetBool() != 0 )
{
Msg("%s equipped with %s, proficiency is %s\n", GetClassname(), pWeapon->GetClassname(), GetWeaponProficiencyName( proficiency ) );
}
SetCurrentWeaponProficiency( proficiency );
// Pass the lighting origin over to the weapon if we have one
pWeapon->SetLightingOrigin( GetLightingOrigin() );
}
// all marines will send all their weapons to everyone
// since it's only 3 weapons per marine and knowing the other players' stuff will be handy
void CASW_Marine::SetTransmit( CCheckTransmitInfo *pInfo, bool bAlways )
{
// Skip this work if we're already marked for transmission.
if ( pInfo->m_pTransmitEdict->Get( entindex() ) )
return;
BaseClass::SetTransmit( pInfo, bAlways );
for ( int i=0; i < MAX_WEAPONS; i++ )
{
CBaseCombatWeapon *pWeapon = m_hMyWeapons[i];
if ( !pWeapon )
continue;
// The local player is sent all of his weapons.
pWeapon->SetTransmit( pInfo, bAlways );
}
}
void CASW_Marine::TookAmmoPickup( CBaseEntity* pAmmoPickup )
{
//DoAnimationEvent(PLAYERANIMEVENT_PICKUP);
CASW_GameStats.Event_MarineTookPickup( this, pAmmoPickup, NULL );
}
bool CASW_Marine::TakeWeaponPickup( CASW_Weapon *pWeapon )
{
if ( !pWeapon )
return false;
// find the index this weapon is meant to go in
int index = GetWeaponPositionForPickup(pWeapon->GetClassname());
// is there already a weapon in this slot?
CASW_Weapon* pOldWeapon = GetASWWeapon(index);
// check we're allowed to take this item
bool bAllowed = true;
if (pOldWeapon) // we're swapping with an existing weapon
bAllowed = ASWGameRules()->MarineCanPickup(GetMarineResource(), pWeapon->GetClassname(), pOldWeapon->GetClassname());
else // we're putting it into an empty slot
bAllowed = ASWGameRules()->MarineCanPickup(GetMarineResource(), pWeapon->GetClassname());
if (!bAllowed)
return false;
CASW_GameStats.Event_MarineTookPickup( this, pWeapon, pOldWeapon );
bool bReplace = ( pOldWeapon != NULL );
// if we're swapping with a current weapon, drop it
if ( bReplace )
{
if (!DropWeapon(index, true)) // todo: set the pickup denial error
return false;
}
// If I have a name, make my weapon match it with "_weapon" appended
if ( GetEntityName() != NULL_STRING )
{
const char* weapon_name = UTIL_VarArgs("%s_weapon", STRING(GetEntityName()));
pWeapon->SetName( AllocPooledString(weapon_name) );
}
IGameEvent * event = gameeventmanager->CreateEvent( "item_pickup" );
if ( event )
{
CASW_Player *pPlayer = GetCommander();
event->SetInt( "userid", ( pPlayer ? pPlayer->GetUserID() : 0 ) );
event->SetInt( "entindex", pWeapon->entindex() );
event->SetString( "classname", pWeapon->GetWeaponInfo()->szClassName );
event->SetInt( "slot", index );
event->SetBool( "replace", bReplace );
event->SetBool( "offhand", pWeapon->GetWeaponInfo()->m_bOffhandActivate );
gameeventmanager->FireEvent( event );
}
// equip the weapon
Weapon_Equip_In_Index( pWeapon, index );
// set the number of clips
if (pWeapon->GetPrimaryAmmoType()!=-1)
GiveAmmo(pWeapon->GetPrimaryAmmoCount(), pWeapon->GetPrimaryAmmoType());
//maybe switch to this weapon, if current is none
if (GetActiveWeapon()==NULL)
{
Weapon_Switch( pWeapon );
}
else
{
pWeapon->SetWeaponVisible(false);
}
CheckAndRequestAmmo();
GetMarineResource()->UpdateWeaponIndices();
return true;
}
bool CASW_Marine::TakeWeaponPickup(CASW_Pickup_Weapon* pPickup)
{
// find the index this weapon is meant to go in
int index = GetWeaponPositionForPickup(pPickup->GetWeaponClass());
// is there already a weapon in this slot?
CASW_Weapon* pWeapon = GetASWWeapon( index );
// check we're allowed to take this item
bool bAllowed = true;
if ( pWeapon ) // we're swapping with an existing weapon
{
bAllowed = ASWGameRules()->MarineCanPickup( GetMarineResource(), pPickup->GetWeaponClass(), pWeapon->GetClassname() );
}
else // we're putting it into an empty slot
{
bAllowed = ASWGameRules()->MarineCanPickup( GetMarineResource(), pPickup->GetWeaponClass() );
}
if ( !bAllowed )
{
return false;
}
CASW_GameStats.Event_MarineTookPickup( this, pPickup, pWeapon );
// if we're swapping with a current weapon, drop it
bool bReplace = ( pWeapon != NULL );
if ( bReplace )
{
if ( !DropWeapon( index, true ) ) // todo: set the pickup denial error
{
return false;
}
}
// give ourselves this weapon, in the right slot
//Msg("CASW_Marine::TakeWeaponPickup calling Weapon_Create %s\n", pPickup->GetWeaponClass());
pWeapon = dynamic_cast<CASW_Weapon*>(Weapon_Create(pPickup->GetWeaponClass()));
if ( pWeapon )
{
// If I have a name, make my weapon match it with "_weapon" appended
if ( GetEntityName() != NULL_STRING )
{
const char* weapon_name = UTIL_VarArgs("%s_weapon", STRING(GetEntityName()));
pWeapon->SetName( AllocPooledString(weapon_name) );
}
// set + take ammo accordingly
pPickup->InitWeapon(this, pWeapon);
//maybe switch to this weapon, if current is none
if ( GetActiveWeapon() == NULL )
{
Weapon_Switch( pWeapon );
}
else
{
pWeapon->SetWeaponVisible(false);
}
IGameEvent * event = gameeventmanager->CreateEvent( "item_pickup" );
if ( event )
{
CASW_Player *pPlayer = GetCommander();
event->SetInt( "userid", ( pPlayer ? pPlayer->GetUserID() : 0 ) );
event->SetInt( "entindex", pWeapon->entindex() );
event->SetString( "classname", pWeapon->GetWeaponInfo()->szClassName );
event->SetInt( "slot", index );
event->SetBool( "replace", bReplace );
event->SetBool( "offhand", pWeapon->GetWeaponInfo()->m_bOffhandActivate );
gameeventmanager->FireEvent( event );
}
// destroy the pickup
pPickup->Remove();
GetMarineResource()->UpdateWeaponIndices();
CheckAndRequestAmmo();
return true;
}
if ( !GetASWWeapon( index ) )
{
SwitchToNextBestWeapon( NULL );
}
return false; // todo: clear the pickup denial error
}
bool CASW_Marine::DropWeapon(int iWeaponIndex, bool bNoSwap)
{
CASW_Weapon* pWeapon = GetASWWeapon(iWeaponIndex);
if (!pWeapon)
return false;
RemoveWeaponPowerup( pWeapon );
return DropWeapon(pWeapon, bNoSwap);
}
bool CASW_Marine::DropWeapon(CASW_Weapon* pWeapon, bool bNoSwap, const Vector *pvecTarget /* = NULL */, const Vector *pVelocity /* = NULL */ )
{
RemoveWeaponPowerup( pWeapon );
// dropping the weapon entity itself
// set clips in the dropped weapon
int iAmmoIndex = pWeapon->GetPrimaryAmmoType();
int bullets_on_player = GetAmmoCount(iAmmoIndex);
int iClips = bullets_on_player / pWeapon->GetMaxClip1();
if (GetNumberOfWeaponsUsingAmmo(iAmmoIndex) > 1)
{
// need to leave at least X clips with the marine, since he has a gun using this ammo
int iMax = GetAmmoDef()->MaxCarry(iAmmoIndex, this);
int iKeep = MAX(0, (bullets_on_player - iMax));
iClips = iKeep / pWeapon->GetMaxClip1();
}
pWeapon->SetPrimaryAmmoCount( iClips * pWeapon->GetMaxClip1() );
// remove ammo from the marine correspondingly
if (iAmmoIndex != -1)
{
int current_bullets = GetAmmoCount(pWeapon->GetPrimaryAmmoType());
current_bullets -= pWeapon->GetPrimaryAmmoCount();
if (current_bullets < 0)
current_bullets = 0;
SetAmmoCount(current_bullets, pWeapon->GetPrimaryAmmoType());
}
// throw the weapon a bit
Vector vecForward = BodyDirection2D();
QAngle gunAngles;
VectorAngles( vecForward, gunAngles );
//=========================================
// Teleport the weapon to the player's hand
//=========================================
int iBIndex = -1;
int iWeaponBoneIndex = -1;
MDLCACHE_CRITICAL_SECTION();
CStudioHdr *hdr = pWeapon->GetModelPtr();
// If I have a hand, set the weapon position to my hand bone position.
if ( hdr && hdr->numbones() > 0 )
{
// Assume bone zero is the root
for ( iWeaponBoneIndex = 0; iWeaponBoneIndex < hdr->numbones(); ++iWeaponBoneIndex )
{
iBIndex = LookupBone( hdr->pBone( iWeaponBoneIndex )->pszName() );
// Found one!
if ( iBIndex != -1 )
{
break;
}
}
if ( iBIndex == -1 )
{
iBIndex = LookupBone( "ValveBiped.bip01_R_Hand" );
}
}
else
{
iBIndex = LookupBone( "ValveBiped.bip01_R_Hand" );
}
if ( iBIndex != -1)
{
Vector origin;
QAngle angles;
matrix3x4_t transform;
// Get the transform for the weapon bonetoworldspace in the NPC
GetBoneTransform( iBIndex, transform );
// find offset of root bone from origin in local space
// Make sure we're detached from hierarchy before doing this!!!
pWeapon->StopFollowingEntity();
pWeapon->SetAbsOrigin( Vector( 0, 0, 0 ) );
pWeapon->SetAbsAngles( QAngle( 0, 0, 0 ) );
pWeapon->InvalidateBoneCache();
matrix3x4_t rootLocal;
if ( iWeaponBoneIndex < hdr->numbones() )
{
pWeapon->GetBoneTransform( iWeaponBoneIndex, rootLocal );
}
else
{
SetIdentityMatrix( rootLocal );
}
// invert it
matrix3x4_t rootInvLocal;
MatrixInvert( rootLocal, rootInvLocal );
matrix3x4_t weaponMatrix;
ConcatTransforms( transform, rootInvLocal, weaponMatrix );
MatrixAngles( weaponMatrix, angles, origin );
// Ensure this position isn't through a wall.
Vector vMarineCenter = WorldSpaceCenter();
trace_t tr;
Ray_t ray;
ray.Init( vMarineCenter, origin, pWeapon->ScriptGetBoundingMins(), pWeapon->ScriptGetBoundingMaxs() );
UTIL_TraceRay( ray, MASK_SOLID, this, COLLISION_GROUP_WEAPON, &tr );
if ( tr.DidHit() )
{
// We hit something... shove it back toward the marine
Vector vTraceDir = origin - vMarineCenter;
float fLength = VectorNormalize( vTraceDir );
origin = GetAbsOrigin() + vTraceDir * fLength * tr.fraction - vTraceDir * 0.5f * pWeapon->ScriptGetBoundingMaxs().DistTo( pWeapon->ScriptGetBoundingMins() );
}
if ( origin.z < vMarineCenter.z )
{
// Prevent stuff falling out of the world when the marines hands are very low (they're doing a bending down anim)
origin.z = vMarineCenter.z;
}
pWeapon->Teleport( &origin, &angles, NULL );
//Have to teleport the physics object as well
IPhysicsObject *pWeaponPhys = pWeapon->VPhysicsGetObject();
if( pWeaponPhys )
{
Vector vPos;
QAngle vAngles;
pWeaponPhys->GetPosition( &vPos, &vAngles );
pWeaponPhys->SetPosition( vPos, angles, true );
AngularImpulse angImp(0,0,0);
Vector vecAdd = GetAbsVelocity();
pWeaponPhys->AddVelocity( &vecAdd, &angImp );
}
}
else
{
pWeapon->SetAbsOrigin( GetAbsOrigin() + vecForward * 80.0f );
}
Vector vecThrow;
ThrowDirForWeaponStrip( pWeapon, vecForward, &vecThrow );
// apply the desired velocity, if any
if ( pvecTarget )
{
// I've been told to throw it somewhere specific.
vecThrow = VecCheckToss( this, pWeapon->GetAbsOrigin(), *pvecTarget, 0.2, 1.0, false );
}
else
{
if ( pVelocity )
{
vecThrow = *pVelocity;
float flLen = vecThrow.Length();
if ( flLen > 400 )
{
VectorNormalize( vecThrow );
vecThrow *= 400;
}
}
else
{
// Nowhere in particular; just drop it.
float throwForce = ( IsPlayer() ) ? 400.0f : random->RandomInt( 64, 128 );
vecThrow = BodyDirection3D() * throwForce;
}
}
pWeapon->Drop( vecThrow );
pWeapon->MarineDropped( this );
Weapon_Detach( pWeapon );
// switch to the next weapon, if any
if ( !bNoSwap )
{
if ( SwitchToNextBestWeapon( NULL ) )
{
// explicitly tell this client to play the weapon switch anim, since he didn't predict this change
TE_MarineAnimEventJustCommander(this, PLAYERANIMEVENT_WEAPON_SWITCH);
}
}
GetMarineResource()->UpdateWeaponIndices();
return true;
}
void CASW_Marine::Weapon_Drop( CBaseCombatWeapon *pWeapon, const Vector *pvecTarget /* = NULL */, const Vector *pVelocity /* = NULL */ )
{
CASW_Weapon* pASWWeapon = dynamic_cast<CASW_Weapon*>(pWeapon);
if (!pASWWeapon)
return;
DropWeapon(pASWWeapon, false, pvecTarget, pVelocity);
}
// healing
void CASW_Marine::AddSlowHeal( int iHealAmount, float flHealRateScale, CASW_Marine *pMedic, CBaseEntity* pHealingWeapon /*= NULL */ )
{
if ( GetHealth() <= 0 )
return;
if (iHealAmount > 0)
{
m_flHealRateScale = flHealRateScale;
if (!m_bSlowHeal)
{
m_bSlowHeal = true;
m_fNextSlowHealTick = gpGlobals->curtime + ( ASW_MARINE_HEALTICK_RATE * ( 1.0f / m_flHealRateScale ) );
}
m_iSlowHealAmount += iHealAmount;
//if (!m_bSlowHeal)
//{
// m_bSlowHeal = true;
// m_fNextSlowHealTick = gpGlobals->curtime + 0.33f;
//}
//m_iSlowHealAmount += iHealAmount;
// subtract FF from the amount healed, before storing it in the medic's healing stats
int iMedicMedalHealed = iHealAmount;
// don't give credit for healing more than the marine's max health
if (GetHealth() + iHealAmount > GetMaxHealth())
{
iMedicMedalHealed = GetMaxHealth() - GetHealth();
//Msg(" healing more than we have health for, so cutting down to %d\n", iMedicMedalHealed);
}
//Msg("healing marine for %d, ff damage is %f\n", iMedicMedalHealed, m_fFriendlyFireDamage);
if (m_fFriendlyFireDamage > 0)
{
iMedicMedalHealed -= m_fFriendlyFireDamage;
m_fFriendlyFireDamage -= iHealAmount;
if (m_fFriendlyFireDamage < 0)
m_fFriendlyFireDamage = 0;
//Msg(" So new medic medal healed is %d and new m_fFriendlyFireDamage is %f\n", iMedicMedalHealed, m_fFriendlyFireDamage);
}
if (iMedicMedalHealed > 0 && pMedic != this && pMedic && pMedic->GetMarineResource())
{
pMedic->GetMarineResource()->m_iMedicHealing += iMedicMedalHealed;
}
// healing puts out fires
if (IsOnFire())
{
Extinguish();
/*
CEntityFlame *pFireChild = dynamic_cast<CEntityFlame *>( GetEffectEntity() );
if ( pFireChild )
{
SetEffectEntity( NULL );
UTIL_Remove( pFireChild );
Extinguish();
}
*/
}
// count heal for stats
if (GetMarineResource())
GetMarineResource()->m_iHealCount++;
// Fire heal event for stat tracking
CASW_GameStats.Event_MarineHealed( this , iHealAmount, pHealingWeapon );
}
}
// using entities over time
bool CASW_Marine::StartUsing( CBaseEntity* pEntity )
{
if ( GetHealth() <= 0 )
return false;
IASW_Server_Usable_Entity* pUsable = dynamic_cast< IASW_Server_Usable_Entity* >( pEntity );
if ( pUsable )
{
if ( !pUsable->IsUsable( this ) )
return false;
if ( !pUsable->RequirementsMet( this ) )
return false;
pUsable->MarineStartedUsing( this );
m_hUsingEntity = pEntity;
return true;
}
return false;
}
void CASW_Marine::StopUsing()
{
if (!m_hUsingEntity)
return;
IASW_Server_Usable_Entity* pUsable = dynamic_cast<IASW_Server_Usable_Entity*>(m_hUsingEntity.Get());
if (pUsable)
{
pUsable->MarineStoppedUsing(this);
}
m_hUsingEntity = NULL;
m_hAreaToUse = NULL; // FIXME: This might accidently clear new orders if the marine was just ordered to a new area!
}
// marine has been hit by a melee attack
void CASW_Marine::MeleeBleed(CTakeDamageInfo* info)
{
Vector vecDir = vec3_origin;
if (info->GetAttacker())
{
// don't bleed from melee coming from other marines, as they can't hurt us
if (info->GetAttacker()->Classify() == CLASS_ASW_MARINE)
return;
vecDir = info->GetAttacker()->GetAbsOrigin() - GetAbsOrigin();
VectorNormalize(vecDir);
}
else
{
vecDir = RandomVector(-1, 1);
}
//UTIL_ASW_BloodDrips( GetAbsOrigin()+Vector(0,0,60)+vecDir*3, vecDir, BloodColor(), 5 );
Vector vecInflictorPos = info->GetDamagePosition();
if ( info->GetInflictor() )
{
vecInflictorPos = info->GetInflictor()->GetAbsOrigin();
}
CRecipientFilter filter;
filter.AddAllPlayers();
UserMessageBegin( filter, "ASWMarineHitByMelee" );
WRITE_SHORT( entindex() );
WRITE_FLOAT( vecInflictorPos.x );
WRITE_FLOAT( vecInflictorPos.y );
WRITE_FLOAT( vecInflictorPos.z );
MessageEnd();
}
/// issue any special effects or sounds on resurrection
void CASW_Marine::PerformResurrectionEffect( void ) RESTRICT
{
DispatchParticleEffect( "marine_resurrection", PATTACH_ABSORIGIN_FOLLOW, this );
this->EmitSound( "Marine.Resurrect" );
}
void CASW_Marine::BecomeInfested(CASW_Alien* pAlien)
{
if ( !GetMarineResource() )
return;
m_fInfestedTime = 20.0f;
GetMarineSpeech()->ForceChatter( CHATTER_INFESTED, ASW_CHATTER_TIMER_TEAM );
if ( !IsInfested() )
{
// do some damage to us immediately (unless we were already infested)
float DamagePerTick = ASWGameRules()->TotalInfestDamage() / 20.0f;
if ( asw_debug_marine_damage.GetBool() )
{
Msg("%f: Infest DamagePerTick %f (infest time left = %f)\n", gpGlobals->curtime, DamagePerTick, m_fInfestedTime);
}
CTakeDamageInfo info( NULL, NULL, Vector(0,0,0), GetAbsOrigin(), DamagePerTick, DMG_INFEST );
TakeDamage( info );
m_fInfestedStartTime = gpGlobals->curtime;
// Give them 3 free cycles (.9 seconds) to panic before we do the first real bite!
m_iInfestCycle = -3;
GetMarineResource()->SetInfested( true );
ASWFailAdvice()->OnMarineInfested();
IGameEvent * event = gameeventmanager->CreateEvent( "marine_infested" );
if ( event )
{
event->SetInt( "entindex", entindex() );
gameeventmanager->FireEvent( event );
}
if ( !IsInhabited() )
{
DoEmote( 0 );
}
}
if ( m_fNextSlowHealTick < gpGlobals->curtime )
{
m_fNextSlowHealTick = gpGlobals->curtime + 0.33f;
}
m_bPlayedCureScream = false;
}
void CASW_Marine::CureInfestation(CASW_Marine *pHealer, float fCureFraction)
{
if ( !GetMarineResource() )
return;
if ( m_fInfestedTime != 0 )
{
m_fInfestedTime = m_fInfestedTime * fCureFraction;
if ( pHealer )
m_hInfestationCurer = pHealer;
if ( m_fInfestedTime < 0.0f )
{
m_fInfestedTime = 0.0f;
if ( !IsInhabited() )
{
DoEmote( 2 );
}
}
}
}
// if we died from infestation, then gib
bool CASW_Marine::ShouldGib( const CTakeDamageInfo &info )
{
if (info.GetDamageType() & DMG_INFEST)
return true;
return BaseClass::ShouldGib(info);
}
bool CASW_Marine::CorpseGib( const CTakeDamageInfo &info )
{
EmitSound( "BaseCombatCharacter.CorpseGib" );
QAngle vecAngles;
VectorAngles( -info.GetDamageForce(), vecAngles );
CBaseEntity *pHelpHelpImBeingSupressed = (CBaseEntity*) te->GetSuppressHost();
te->SetSuppressHost( NULL );
DispatchParticleEffect( "marine_gib", PATTACH_ABSORIGIN_FOLLOW, this );
te->SetSuppressHost( pHelpHelpImBeingSupressed );
return true;
}
// if we gibbed from infestation damage, spawn some parasites
bool CASW_Marine::Event_Gibbed( const CTakeDamageInfo &info )
{
if ( info.GetDamageType() & DMG_INFEST )
{
if ( asw_debug_marine_damage.GetBool() )
{
Msg("marine infest gibbed at loc %f, %f, %f\n", GetAbsOrigin().x, GetAbsOrigin().y, GetAbsOrigin().z);
}
if ( asw_debug_marine_damage.GetBool())
{
NDebugOverlay::EntityBounds(this, 255,0,0, 255, 15.0f);
}
ASWFailAdvice()->OnMarineInfestedGibbed();
int iNumParasites = 3 + RandomInt(0,2);
QAngle angParasiteFacing[5];
float fJumpDistance[5];
// for some reason if we calculate these inside the loop, the random numbers all come out the same. Worrying.
angParasiteFacing[0] = GetAbsAngles(); angParasiteFacing[0].y = RandomFloat( -180.0f, 180.0f );
angParasiteFacing[1] = GetAbsAngles(); angParasiteFacing[1].y = RandomFloat( -180.0f, 180.0f );
angParasiteFacing[2] = GetAbsAngles(); angParasiteFacing[2].y = RandomFloat( -180.0f, 180.0f );
angParasiteFacing[3] = GetAbsAngles(); angParasiteFacing[3].y = RandomFloat( -180.0f, 180.0f );
angParasiteFacing[4] = GetAbsAngles(); angParasiteFacing[4].y = RandomFloat( -180.0f, 180.0f );
fJumpDistance[0] = RandomFloat( 30.0f, 70.0f );
fJumpDistance[1] = RandomFloat( 30.0f, 70.0f );
fJumpDistance[2] = RandomFloat( 30.0f, 70.0f );
fJumpDistance[3] = RandomFloat( 30.0f, 70.0f );
fJumpDistance[4] = RandomFloat( 30.0f, 70.0f );
for ( int i = 0; i < iNumParasites; i++ )
{
bool bBlocked = true;
int k = 0;
Vector vecSpawnPos = GetAbsOrigin();
float fCircleDegree = ( static_cast< float >( i ) / iNumParasites ) * 2.0f * M_PI;
vecSpawnPos.x += sinf( fCircleDegree ) * RandomFloat( 3.0f, 20.0f );
vecSpawnPos.y += cosf( fCircleDegree ) * RandomFloat( 3.0f, 20.0f );
vecSpawnPos.z += RandomFloat( 20.0f, 40.0f );
while ( bBlocked && k < 6 )
{
if ( k > 0 )
{
// Scooch it up
vecSpawnPos.z += NAI_Hull::Maxs( HULL_TINY ).z - NAI_Hull::Mins( HULL_TINY ).z;
}
// check if there's room at this position
trace_t tr;
UTIL_TraceHull( vecSpawnPos, vecSpawnPos + Vector( 0.0f, 0.0f, 1.0f ),
NAI_Hull::Mins(HULL_TINY) + Vector( -4.0f, -4.0f, -4.0f ),NAI_Hull::Maxs(HULL_TINY) + Vector( 4.0f, 4.0f, 4.0f ),
MASK_NPCSOLID, this, ASW_COLLISION_GROUP_PARASITE, &tr );
if ( asw_debug_marine_damage.GetBool() )
{
NDebugOverlay::Box(vecSpawnPos, NAI_Hull::Mins(HULL_TINY),NAI_Hull::Maxs(HULL_TINY), 255,255,0,255,15.0f);
}
if ( tr.fraction == 1.0 )
{
bBlocked = false;
}
k++;
}
if (bBlocked)
continue; // couldn't find room for parasites
if ( asw_debug_marine_damage.GetBool() )
{
Msg("Found an unblocked pos for this entity, trying to spawn it there %f, %f, %f\n", vecSpawnPos.x,
vecSpawnPos.y, vecSpawnPos.z);
}
CASW_Parasite *pParasite = dynamic_cast< CASW_Parasite* >( CreateNoSpawn( "asw_parasite",
vecSpawnPos, angParasiteFacing[i], this));
if ( pParasite )
{
PhysDisableEntityCollisions( pParasite, this );
DispatchSpawn( pParasite );
pParasite->SetSleepState(AISS_WAITING_FOR_INPUT);
pParasite->SetJumpFromEgg(true, fJumpDistance[i]);
pParasite->Wake();
}
}
}
AddEffects( EF_NODRAW ); // make the model invisible.
SetSolid( SOLID_NONE );
SetNextThink( gpGlobals->curtime + 2.0f );
SetThink( &CASW_Marine::SUB_Remove );
return CorpseGib( info );
}
float CASW_Marine::GetIdealSpeed() const
{
return m_fCachedIdealSpeed;
}
CRagdollProp* CASW_Marine::GetRagdollProp()
{
return dynamic_cast<CRagdollProp*>(m_hKnockedOutRagdoll.Get());
}
void CASW_Marine::Event_Killed( const CTakeDamageInfo &info )
{
bool bAllDead = false;
if ( ASWGameRules() && ASWGameRules()->GetMissionManager() )
{
bAllDead = ASWGameRules()->GetMissionManager()->AllMarinesDead();
}
CASW_GameStats.Event_MarineKilled( this, info );
ASWFailAdvice()->OnMarineKilled();
float flPosition = -1.0f;
UTIL_ASW_NearestMarine( this, flPosition );
if ( !bAllDead )
{
if ( flPosition != -1.0f && flPosition > 1000.0f )
{
ASWFailAdvice()->OnMarineKilledAlone();
}
if ( m_hCurrentHack.Get() )
{
ASWFailAdvice()->OnHackerDied();
}
CASW_Player *pPlayer = GetCommander();
if ( pPlayer && pPlayer->GetMarine() == this )
{
if ( UTIL_ASW_NumCommandedMarines( pPlayer ) >= 1 )
{
IGameEvent * event = gameeventmanager->CreateEvent( "player_should_switch" );
if ( event )
{
event->SetInt( "userid", pPlayer->GetUserID() );
gameeventmanager->FireEvent( event );
}
}
}
if ( IsInfested() )
{
IGameEvent * event = gameeventmanager->CreateEvent( "marine_infested_killed" );
if ( event )
{
event->SetInt( "userid", pPlayer ? pPlayer->GetUserID() : 0 );
event->SetInt( "marine", entindex() );
gameeventmanager->FireEvent( event );
}
}
}
if ( ASWGameRules() )
{
ASWGameRules()->MarineKilled( this, info );
// Start up the death cam
ASWGameRules()->m_fMarineDeathTime = gpGlobals->curtime;
ASWGameRules()->m_vMarineDeathPos = GetAbsOrigin();
ASWGameRules()->m_nMarineForDeathCam = ASWGameResource()->GetMarineResourceIndex( GetMarineResource() ); // TODO: Is this ok!?
// Check mission status
if ( ASWGameRules()->GetMissionManager() )
{
ASWGameRules()->GetMissionManager()->MarineKilled( this );
}
}
if ( m_hUsingEntity.Get() )
{
StopUsing();
}
// store off our death position
CASW_Marine_Resource *pMR = GetMarineResource();
if ( pMR )
{
pMR->m_vecDeathPosition = GetAbsOrigin();
pMR->m_fDeathTime = gpGlobals->curtime;
pMR->SetFiring( 0 );
pMR->m_TimelineAmmo.RecordValue( 0.0f );
pMR->m_TimelineHealth.RecordValue( 0.0f );
}
// drop all of our equipment
// Calculate death force
Vector forceVector = CalcDeathForceVector( info );
float flMagnitude = forceVector.Length();
if ( flMagnitude > 20000 )
{
forceVector *= 20000 / flMagnitude;
}
for ( int i = 0; i < ASW_MAX_MARINE_WEAPONS; i++ )
{
CBaseCombatWeapon *pDroppedWeapon = GetWeapon( i );
if ( pDroppedWeapon )
{
// Drop any weapon that I own
if ( VPhysicsGetObject() )
{
Vector weaponForce = forceVector * VPhysicsGetObject()->GetInvMass();
Weapon_Drop( pDroppedWeapon, NULL, &weaponForce );
}
else
{
Weapon_Drop( pDroppedWeapon, NULL, &forceVector );
}
}
}
// see if any other marines are nearby to shout out about us
if ( ASWGameResource() )
{
CASW_Game_Resource *pGameResource = ASWGameResource();
if (pGameResource)
{
if ( asw_realistic_death_chatter.GetBool() )
{
int iNumNearby = 0;
for (int i=0;i<pGameResource->GetMaxMarineResources();i++)
{
CASW_Marine_Resource *pMR = pGameResource->GetMarineResource(i);
CASW_Marine *pOtherMarine = pMR ? pMR->GetMarineEntity() : NULL;
if (pOtherMarine && pOtherMarine != this
&& pOtherMarine->GetHealth() > 0
&& GetAbsOrigin().DistTo(pOtherMarine->GetAbsOrigin()) < 800)
iNumNearby++;
}
if (iNumNearby > 0)
{
int iChosen = random->RandomInt(1, iNumNearby);
for (int i=0;i<pGameResource->GetMaxMarineResources() && iChosen > 0;i++)
{
CASW_Marine_Resource *pMR = pGameResource->GetMarineResource(i);
CASW_Marine *pOtherMarine = pMR ? pMR->GetMarineEntity() : NULL;
if (pOtherMarine && pOtherMarine != this
&& pOtherMarine->GetHealth() > 0
&& GetAbsOrigin().DistTo(pOtherMarine->GetAbsOrigin()) < 800)
{
iChosen--;
if (iChosen <= 0)
{
if (asw_debug_marine_chatter.GetBool())
Msg("making marine CHATTER_MARINE_DOWN %s\n", pOtherMarine->GetMarineProfile()->m_ShortName);
pOtherMarine->GetMarineSpeech()->QueueChatter(CHATTER_MARINE_DOWN, gpGlobals->curtime+0.5f, gpGlobals->curtime+1.50f);
}
}
}
}
}
else
{
// pick one marine for each player to shout about the marine death
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CASW_Player* pOtherPlayer = dynamic_cast<CASW_Player*>(UTIL_PlayerByIndex(i));
if ( !pOtherPlayer)
continue;
Vector vecPlayerPos = vec3_origin;
if ( pOtherPlayer->GetMarine() )
{
vecPlayerPos = pOtherPlayer->GetMarine()->GetAbsOrigin();
}
// tell all other marines to shout about this death
CASW_Marine *pChosenMarine = NULL;
// count how many marines this player has
int iNumMarines = 0;
for (int i=0;i<pGameResource->GetMaxMarineResources();i++)
{
CASW_Marine_Resource *pMR = pGameResource->GetMarineResource(i);
CASW_Marine *pOtherMarine = pMR ? pMR->GetMarineEntity() : NULL;
if (pOtherMarine && pOtherMarine != this
&& pOtherMarine->GetHealth() > 0
&& ( vecPlayerPos == vec3_origin || pOtherMarine->GetAbsOrigin().DistTo( vecPlayerPos ) < 800 ) )
{
iNumMarines++;
}
}
// now choose one to play the sound
int iChosen = random->RandomInt(1, iNumMarines);
for (int i=0;i<pGameResource->GetMaxMarineResources();i++)
{
CASW_Marine_Resource *pMR = pGameResource->GetMarineResource(i);
CASW_Marine *pOtherMarine = pMR ? pMR->GetMarineEntity() : NULL;
if (pOtherMarine && pOtherMarine != this
&& pOtherMarine->GetHealth() > 0
&& ( vecPlayerPos == vec3_origin || pOtherMarine->GetAbsOrigin().DistTo( vecPlayerPos ) < 800 ) )
{
iChosen--;
if ( iChosen <= 0 )
{
pChosenMarine = pOtherMarine;
break;
}
}
}
if ( pChosenMarine )
{
// do private full volume chatter
pChosenMarine->GetMarineSpeech()->QueueChatter(CHATTER_MARINE_DOWN, gpGlobals->curtime+0.5f, gpGlobals->curtime+1.50f, pOtherPlayer);
}
}
}
}
}
BaseClass::Event_Killed(info);
if (asw_debug_marine_chatter.GetBool())
Msg("making marine CHATTER_DIE %s\n", GetMarineProfile()->m_ShortName);
GetMarineSpeech()->ForceChatter(CHATTER_DIE, ASW_CHATTER_TIMER_NONE);
if ( IsInhabited() && GetCommander() )
{
// play death beep to the person controlling this marine
GetCommander()->EmitPrivateSound( "Marine.DeathBeep" );
}
// check if this mission has a tech req
if (ASWGameRules() && ASWGameRules()->m_bMissionRequiresTech)
{
CASW_Game_Resource *pGameResource = ASWGameResource();
if ( pGameResource )
{
// count number of live techs
bool bTech = false;
for (int i=0;i<pGameResource->GetMaxMarineResources();i++)
{
CASW_Marine_Resource *pMR = pGameResource->GetMarineResource(i);
if (pMR && pMR->GetHealthPercent() > 0 && pMR->GetProfile() && pMR->GetProfile()->CanHack())
{
bTech = true;
break;
}
}
if ( !bTech && pGameResource->CountAllAliveMarines() > 0 )
{
ASWGameRules()->ScheduleTechFailureRestart( gpGlobals->curtime + 1.5f );
}
}
}
// print a message if marine was killed by another marine
if (info.GetAttacker() && info.GetAttacker()->Classify() == CLASS_ASW_MARINE )
{
CASW_Marine *pOtherMarine = dynamic_cast< CASW_Marine* >( info.GetAttacker() );
if ( pOtherMarine && GetMarineProfile() && pOtherMarine->GetMarineProfile() )
{
CASW_Marine_Resource *pMR = GetMarineResource();
if ( pMR )
{
char szName[ 256 ];
pMR->GetDisplayName( szName, sizeof( szName ) );
if ( pOtherMarine == this )
{
if ( GetMarineProfile()->m_bFemale )
UTIL_ClientPrintAll( ASW_HUD_PRINTTALKANDCONSOLE, "#asw_suicide_female", szName );
else
UTIL_ClientPrintAll( ASW_HUD_PRINTTALKANDCONSOLE, "#asw_suicide_male", GetMarineProfile()->m_ShortName );
}
else
{
CASW_Marine_Resource *pMROther = pOtherMarine->GetMarineResource();
if ( pMROther )
{
char szNameOther[ 256 ];
pMROther->GetDisplayName( szNameOther, sizeof( szNameOther ) );
UTIL_ClientPrintAll( ASW_HUD_PRINTTALKANDCONSOLE, "#asw_team_killed", szName, szNameOther );
}
}
}
}
}
m_bSlowHeal = false; // no healing if we're dead!
}
void CASW_Marine::AimGun()
{
BaseClass::AimGun();
if (!IsInhabited())
{
m_fAIPitch = GetPoseParameter( "aim_pitch" );
}
}
void CASW_Marine::DoEmote(int iEmote)
{
if (GetFlags() & FL_FROZEN || !GetMarineSpeech()) // don't allow this if the marine is frozen
return;
switch (iEmote)
{
case 0:
{
GetMarineSpeech()->Chatter(CHATTER_MEDIC);
bEmoteMedic = true;
break;
}
case 1:
{
GetMarineSpeech()->Chatter(CHATTER_NEED_AMMO);
bEmoteAmmo = true;
break;
}
case 2:
{
bEmoteSmile = true;
break;
}
case 3:
{
GetMarineSpeech()->Chatter(CHATTER_HOLD_POSITION);
DoAnimationEvent(PLAYERANIMEVENT_HALT);
bEmoteStop = true;
break;
}
case 4:
{
GetMarineSpeech()->Chatter(CHATTER_FOLLOW_ME);
DoAnimationEvent(PLAYERANIMEVENT_GO);
bEmoteGo = true;
break;
}
case 5:
{
GetMarineSpeech()->Chatter(CHATTER_WATCH_OUT);
bEmoteExclaim = true;
break;
}
case 7:
{
GetMarineSpeech()->Chatter(CHATTER_QUESTION);
bEmoteQuestion = true;
break;
}
default:
{
bEmoteAnimeSmile = true;
break;
}
}
}
bool CASW_Marine::IsPlayerAlly( CBasePlayer *pPlayer )
{
return true;
}
IASW_Vehicle* CASW_Marine::GetASWVehicle()
{
//IASW_Vehicle* pEnt = m_hASWVehicle.Get();
//return dynamic_cast<IASW_Vehicle*>(pEnt);
return dynamic_cast<IASW_Vehicle*>(m_hASWVehicle.Get());
}
// make the marine start driving a particular vehicle
void CASW_Marine::StartDriving(IASW_Vehicle* pVehicle)
{
if (!pVehicle || IsDriving() || IsInVehicle() || pVehicle->ASWGetDriver()!=NULL)
return;
CBaseEntity* pEnt = pVehicle->GetEntity();
if (!pEnt)
return;
//Must be able to stow our weapon
CBaseCombatWeapon *pWeapon = GetActiveWeapon();
if ( ( pWeapon != NULL ) && ( pWeapon->Holster( NULL ) == false ) )
return;
pVehicle->ASWSetDriver(this);
pVehicle->ASWStartEngine();
m_bDriving = true;
m_bIsInVehicle = true;
m_hASWVehicle = pEnt;
AddEffects( EF_NODRAW );
SetCollisionGroup( COLLISION_GROUP_IN_VEHICLE );
m_takedamage = DAMAGE_NO;
}
void CASW_Marine::StopDriving(IASW_Vehicle* pVehicle)
{
if (!pVehicle || !IsDriving())
return;
CBaseEntity* pEnt = pVehicle->GetEntity();
if (!pEnt)
return;
// try and place the marine outside the vehicle
Vector v = pEnt->GetAbsOrigin() - UTIL_YawToVector(pEnt->GetAbsAngles().y) * 50;
trace_t tr;
Ray_t ray;
ray.Init( v + Vector(0,0,1), v, CollisionProp()->OBBMins(), CollisionProp()->OBBMaxs() );
UTIL_TraceRay( ray, MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &tr );
if ( tr.fraction < 1.0 )
return; // blocked
SetAbsOrigin(v);
// todo: get weapon out again?
pVehicle->ASWStopEngine();
pVehicle->ASWSetDriver(NULL);
m_bDriving = false;
m_bIsInVehicle = false;
m_hASWVehicle = NULL;
RemoveEffects( EF_NODRAW );
SetCollisionGroup( COLLISION_GROUP_PLAYER );
m_takedamage = DAMAGE_YES;
}
int CASW_Marine::UpdateTransmitState()
{
// always call ShouldTransmit() for maines
//return SetTransmitState( FL_EDICT_FULLCHECK );
return SetTransmitState( FL_EDICT_ALWAYS );
}
int CASW_Marine::ShouldTransmit( const CCheckTransmitInfo *pInfo )
{
// asw temp
return FL_EDICT_ALWAYS;
// always transmit if we're inhabited by the target client
if ( GetCommander() && IsInhabited() && pInfo->m_pClientEnt == GetCommander()->edict() )
{
return FL_EDICT_ALWAYS;
}
return BaseClass::ShouldTransmit( pInfo );
}
void CASW_Marine::PhysicsShove()
{
Vector forward, up, right;
AngleVectors( EyeAngles(), &forward, &right, &up );
trace_t tr;
// Search for objects in a sphere (tests for entities that are not solid, yet still useable)
Vector searchCenter = WorldSpaceCenter();
UTIL_TraceLine( searchCenter, searchCenter + forward * 96.0f, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
if (!tr.m_pEnt)
{
UTIL_TraceLine( GetAbsOrigin() + Vector(0,0,25), searchCenter + forward * 96.0f, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
}
//UTIL_AddDebugLine(searchCenter, searchCenter + forward * 96.0f, false, false);
// try the hit entity if there is one, or the ground entity if there isn't.
CBaseEntity *entity = tr.m_pEnt;
if (entity && entity->VPhysicsGetObject() )
{
IPhysicsObject *pObj = entity->VPhysicsGetObject();
Vector vPushAway = (entity->WorldSpaceCenter() - WorldSpaceCenter());
vPushAway.z = 0;
float flDist = VectorNormalize( vPushAway );
flDist = MAX( flDist, 1 );
float flForce = MarineSkills()->GetSkillBasedValueByMarine(this, ASW_MARINE_SKILL_MELEE, ASW_MARINE_SUBSKILL_MELEE_FORCE);
//flForce /= flDist;
flForce = MIN( flForce, asw_marine_melee_max_force.GetFloat() );
if (asw_debug_marine_damage.GetBool())
{
Msg(" Kicking with force %f\n", flForce);
}
pObj->ApplyForceOffset( vPushAway * flForce, WorldSpaceCenter() );
}
}
CASW_Marine_Resource* CASW_Marine::GetMarineResource() const
{
return dynamic_cast<CASW_Marine_Resource*>(m_MarineResource.Get());
}
void CASW_Marine::Suicide()
{
if (GetFlags() & FL_FROZEN) // don't allow this if the marine is frozen
return;
m_iHealth = 1;
if (IsInfested())
{
CTakeDamageInfo info(this, this, Vector(0,0,0), GetAbsOrigin(), 100,
DMG_INFEST);
TakeDamage(info);
}
else
{
CTakeDamageInfo info(this, this, Vector(0,0,0), GetAbsOrigin(), 100,
DMG_NEVERGIB);
TakeDamage(info);
}
SetThink(&CBaseEntity::SUB_Remove);
SetNextThink(gpGlobals->curtime + 2.0f);
}
bool CASW_Marine::BecomeRagdollOnClient( const Vector &force )
{
if ( !CanBecomeRagdoll() )
return false;
// Become server-side ragdoll if we're flagged to do it
//if ( m_spawnflags & SF_ANTLIONGUARD_SERVERSIDE_RAGDOLL )
if (asw_marine_server_ragdoll.GetBool())
{
CTakeDamageInfo info;
// Fake the info
info.SetDamageType( DMG_GENERIC );
info.SetDamageForce( force );
info.SetDamagePosition( WorldSpaceCenter() );
IPhysicsObject *pPhysics = VPhysicsGetObject();
if ( pPhysics )
{
VPhysicsDestroyObject();
}
CBaseEntity *pRagdoll = CreateServerRagdoll( this, m_nForceBone, info, COLLISION_GROUP_INTERACTIVE_DEBRIS, true );
FixupBurningServerRagdoll( pRagdoll );
PhysSetEntityGameFlags( pRagdoll, FVPHYSICS_NO_SELF_COLLISIONS );
//CBaseEntity *pRagdoll = CreateServerRagdoll( this, 0, info, COLLISION_GROUP_NONE );
// Transfer our name to the new ragdoll
pRagdoll->SetName( GetEntityName() );
//pRagdoll->SetCollisionGroup( COLLISION_GROUP_DEBRIS );
// Get rid of our old body
//UTIL_Remove(this);
RemoveDeferred();
return true;
}
return BaseClass::BecomeRagdollOnClient( force );
}
void CASW_Marine::SelectModelFromProfile()
{
CASW_Marine_Profile *pProfile = GetMarineProfile();
if (pProfile)
{
SetModelName(MAKE_STRING(pProfile->m_ModelName));
m_nSkin = pProfile->m_SkinNum;
//Msg("%s Setting skin number to %d\n", pProfile->m_ShortName, m_nSkin);
}
else
{
SetModelName( AllocPooledString( ASW_DEFAULT_MARINE_MODEL ) );
//Msg("Warning (SelectModelFromProfile) couldn't get model from profile as profile doesn't exist yet\n");
}
}
void CASW_Marine::SetModelFromProfile()
{
CASW_Marine_Profile *pProfile = GetMarineProfile();
if (pProfile)
{
SetModelName(MAKE_STRING(pProfile->m_ModelName));
SetModel(pProfile->m_ModelName);
m_nSkin = pProfile->m_SkinNum;
//set the backpack bodygroup
SetBodygroup ( 1, m_nSkin );
//Msg("%s Setting skin number to %d\n", pProfile->m_ShortName, m_nSkin);
}
else
{
SetModelName( AllocPooledString( ASW_DEFAULT_MARINE_MODEL ) );
SetModel(ASW_DEFAULT_MARINE_MODEL);
Msg("Warning (SetModelFromProfile) couldn't get model from profile as profile doesn't exist yet\n");
}
}
void CASW_Marine::SetKnockedOut(bool bKnockedOut)
{
if (m_bKnockedOut == bKnockedOut)
return;
m_bKnockedOut = bKnockedOut;
if (m_bKnockedOut) // make the marine fall over
{
FlashlightTurnOff();
InvalidateBoneCache();
AddSolidFlags( FSOLID_NOT_SOLID );
CTakeDamageInfo info;
info.SetDamageType( DMG_GENERIC );
info.SetDamageForce( vec3_origin );
info.SetDamagePosition( WorldSpaceCenter() );
m_hKnockedOutRagdoll = (CRagdollProp*) CreateServerRagdoll( this, 0, info, COLLISION_GROUP_NONE );
if ( GetRagdollProp() )
{
GetRagdollProp()->DisableAutoFade();
GetRagdollProp()->SetThink( NULL );
GetRagdollProp()->SetUnragdoll( this );
}
AddEffects( EF_NODRAW );
AddFlag( FL_FROZEN );
Msg("%s has been knocked unconcious!\n", GetMarineProfile() ? GetMarineProfile()->m_ShortName : "UnknownMarine");
}
else // marine is already knocked out, let's make him get up again
{
Assert(IsEffectActive(EF_NODRAW));
Assert(GetRagdollProp());
SetStopTime(gpGlobals->curtime + 2.0f); // make sure he can't move for a while
DoAnimationEvent(PLAYERANIMEVENT_GETUP); // animate him standing up
//Calcs the diff between ragdoll worldspace center and victim worldspace center, moves the victim by this diff.
//Sets the victim's angles to 0, ragdoll yaw, 0
QAngle newAngles( 0, GetRagdollProp()->GetAbsAngles()[YAW], 0 );
Vector centerDelta = GetRagdollProp()->WorldSpaceCenter() - WorldSpaceCenter();
centerDelta.z = 0; // don't put us in the floor
Vector newOrigin = GetAbsOrigin() + centerDelta;
SetAbsOrigin( newOrigin );
SetAbsAngles( newAngles );
//GetRagdollProp()->AddEffects( EF_NODRAW );
RemoveEffects( EF_NODRAW );
RemoveSolidFlags( FSOLID_NOT_SOLID );
if (HasFlashlight())
FlashlightTurnOn();
m_fUnfreezeTime = gpGlobals->curtime + 3.0f;
UTIL_Remove( GetRagdollProp() );
m_hKnockedOutRagdoll = NULL;
Msg("%s has got back up.\n", GetMarineProfile() ? GetMarineProfile()->m_ShortName : "UnknownMarine");
}
}
/*
void CASW_Marine::DoKickEffect()
{
//Msg("CASW_Marine::DoKickEffect\n");
bool bHasBayonet = false;
// bayonet disabled at this time
//GetActiveASWWeapon() && GetActiveASWWeapon()->SupportsBayonet() &&
//(MarineSkills()->GetSkillBasedValueByMarine(this, ASW_MARINE_SKILL_EDGED) > 0);
//CBaseEntity *pHurt =
float flForce = MarineSkills()->GetSkillBasedValueByMarine(this, ASW_MARINE_SKILL_MELEE, ASW_MARINE_SUBSKILL_MELEE_FORCE);
// add a bit of randomness
// flForce *= random->RandomFloat(0.8f, 1.2f);
int iDamage = 1;
if (bHasBayonet)
{
// bayonet disabled at this time
//int iDamage = MarineSkills()->GetSkillBasedValueByMarine(this, ASW_MARINE_SKILL_EDGED);
}
else
{
iDamage = MarineSkills()->GetSkillBasedValueByMarine(this, ASW_MARINE_SKILL_MELEE, ASW_MARINE_SUBSKILL_MELEE_DMG);
}
const CBaseEntity * ent = NULL;
if ( g_pGameRules->IsMultiplayer() )
{
// temp remove suppress host
ent = te->GetSuppressHost();
te->SetSuppressHost( NULL );
}
CheckTraceHullAttack( asw_marine_melee_distance.GetFloat(), -Vector(16,16,32), Vector(16,16,32), iDamage, DMG_CLUB, flForce, true );
if ( g_pGameRules->IsMultiplayer() )
{
te->SetSuppressHost( (CBaseEntity *) ent );
}
}
CBaseEntity *CASW_Marine::CheckTraceHullAttack( float flDist, const Vector &mins, const Vector &maxs, int iDamage, int iDmgType, float forceScale, bool bDamageAnyNPC )
{
// If only a length is given assume we want to trace in our facing direction
Vector forward;
AngleVectors( GetAbsAngles(), &forward );
Vector vStart = GetAbsOrigin();
// The ideal place to start the trace is in the center of the attacker's bounding box.
// however, we need to make sure there's enough clearance. Some of the smaller monsters aren't
// as big as the hull we try to trace with. (SJB)
float flVerticalOffset = WorldAlignSize().z * 0.5;
if( flVerticalOffset < maxs.z )
{
// There isn't enough room to trace this hull, it's going to drag the ground.
// so make the vertical offset just enough to clear the ground.
flVerticalOffset = maxs.z + 1.0;
}
vStart.z += flVerticalOffset;
Vector vEnd = vStart + (forward * flDist );
// asw - make melee attacks trace below us too, so it's possible hard to hit things just below you on a slope
Vector low_mins = mins;
low_mins.z -= 30;
return CheckTraceHullAttack( vStart, vEnd, low_mins, maxs, iDamage, iDmgType, forceScale, bDamageAnyNPC );
}
// asw note: same as CBaseCombatCharacter version, but we use our custom melee trace filter so the victim can bleed and we can kick our own grenades
CBaseEntity *CASW_Marine::CheckTraceHullAttack( const Vector &vStart, const Vector &vEnd, const Vector &mins, const Vector &maxs, int iDamage, int iDmgType, float flForceScale, bool bDamageAnyNPC )
{
// Handy debuging tool to visualize HullAttack trace
if ( ai_show_hull_attacks.GetBool() )
{
float length = (vEnd - vStart ).Length();
Vector direction = (vEnd - vStart );
VectorNormalize( direction );
Vector hullMaxs = maxs;
hullMaxs.x = length + hullMaxs.x;
NDebugOverlay::BoxDirection(vStart, mins, hullMaxs, direction, 100,255,255,20,1.0);
NDebugOverlay::BoxDirection(vStart, mins, maxs, direction, 255,0,0,20,1.0);
}
CTakeDamageInfo dmgInfo( this, this, iDamage, iDmgType );
CASW_Trace_Filter_Melee traceFilter( this, COLLISION_GROUP_NONE, &dmgInfo, flForceScale, bDamageAnyNPC );
Ray_t ray;
ray.Init( vStart, vEnd, mins, maxs );
trace_t tr;
enginetrace->TraceRay( ray, MASK_SHOT_HULL, &traceFilter, &tr );
CBaseEntity *pEntity = traceFilter.m_pHit;
// do an impact effect for kicking some things
if (traceFilter.m_hBestHit.Get())
{
trace_t tr;
UTIL_TraceLine(WorldSpaceCenter(), traceFilter.m_hBestHit->WorldSpaceCenter(), // check center to center
MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);
if (tr.DidHit())
{
CASW_Door *pDoor = dynamic_cast<CASW_Door*>(tr.m_pEnt); // doors make their own bash sounds, so skip an impact trace vs them
if (!pDoor && !traceFilter.m_hBestHit->IsNPC())
UTIL_ImpactTrace( &tr, iDmgType );
}
}
else // didn't hit anything, just do a general trace
{
Vector forward, right, up, v;
v = GetAbsOrigin();
QAngle ang = GetAbsAngles();
AngleVectors( ang, &forward, &right, &up );
v = v + up * 45;
Vector vecKickSrc = v
- forward * 1
+ right * 1;
trace_t tr;
UTIL_TraceLine(vecKickSrc, vecKickSrc + forward * 50,
MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);
if (tr.DidHit())
{
CASW_Door *pDoor = dynamic_cast<CASW_Door*>(tr.m_pEnt); // doors make their own bash sounds, so skip an impact trace vs them
if (!pDoor && !tr.m_pEnt->IsNPC())
UTIL_ImpactTrace( &tr, iDmgType );
}
}
return pEntity;
}*/
// marines always move efficiently`
void CASW_Marine::UpdateEfficiency( bool bInPVS )
{
// Sleeping NPCs always dormant
if ( GetSleepState() != AISS_AWAKE )
{
SetEfficiency( AIE_DORMANT );
return;
}
SetEfficiency( AIE_NORMAL );
SetMoveEfficiency( AIME_NORMAL );
}
float CASW_Marine::GetIdealAccel( ) const
{
return GetIdealSpeed() * asw_marine_ai_acceleration.GetFloat();
}
float CASW_Marine::MaxYawSpeed( void )
{
if ( GetEnemy() )
return 45.0f;
if ( m_vecFacingPointFromServer.Get() != vec3_origin || m_hUsingEntity.Get() )
return 24.0f;
return 8.0f;
}
#define GROUNDTURRET_VIEWCONE 60.0f
#define GROUNDTURRET_BEAM_SPRITE "materials/effects/bluelaser2.vmt"
void CASW_Marine::Scan()
{
if (IsInhabited() || GetASWOrders() != ASW_ORDER_HOLD_POSITION || !asw_marine_scan_beams.GetBool())
return;
if( gpGlobals->curtime >= m_flTimeNextScanPing )
{
m_flTimeNextScanPing = gpGlobals->curtime + 1.0f;
}
QAngle scanAngle;
Vector forward;
Vector vecEye = GetAbsOrigin();// + m_vecLightOffset;
// Draw the outer extents
scanAngle = GetAbsAngles();
scanAngle.y += (GROUNDTURRET_VIEWCONE / 2.0f);
AngleVectors( scanAngle, &forward, NULL, NULL );
ProjectBeam( vecEye, forward, 1, 30, 0.1 );
scanAngle = GetAbsAngles();
scanAngle.y -= (GROUNDTURRET_VIEWCONE / 2.0f);
AngleVectors( scanAngle, &forward, NULL, NULL );
ProjectBeam( vecEye, forward, 1, 30, 0.1 );
// Draw a sweeping beam
scanAngle = GetAbsAngles();
scanAngle.y += (GROUNDTURRET_VIEWCONE / 2.0f) * sin( gpGlobals->curtime * 3.0f );
AngleVectors( scanAngle, &forward, NULL, NULL );
ProjectBeam( vecEye, forward, 1, 30, 0.3 );
}
void CASW_Marine::ProjectBeam( const Vector &vecStart, const Vector &vecDir, int width, int brightness, float duration )
{
CBeam *pBeam;
pBeam = CBeam::BeamCreate( GROUNDTURRET_BEAM_SPRITE, width );
if ( !pBeam )
return;
trace_t tr;
AI_TraceLine( vecStart, vecStart + vecDir * 768.0f, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
pBeam->SetStartPos( tr.endpos );
pBeam->SetEndPos( tr.startpos );
pBeam->SetWidth( width );
pBeam->SetEndWidth( 0.1 );
pBeam->SetFadeLength( 16 );
pBeam->SetBrightness( brightness );
pBeam->SetColor( 0, 145+random->RandomInt( -16, 16 ), 255 );
pBeam->RelinkBeam();
pBeam->LiveForTime( duration );
}
void CASW_Marine::ASW_Ignite( float flFlameLifetime, float flSize, CBaseEntity *pAttacker, CBaseEntity *pDamagingWeapon /*= NULL */ )
{
if (!ASWGameRules())
return;
// set flame life time by the game difficulty
int iDiff = ASWGameRules()->GetSkillLevel();
if (iDiff == 1)
flFlameLifetime *= asw_marine_burn_time_easy.GetFloat();
else if (iDiff == 2)
flFlameLifetime *= asw_marine_burn_time_normal.GetFloat();
else if (iDiff == 3)
flFlameLifetime *= asw_marine_burn_time_hard.GetFloat();
else if (iDiff == 4)
flFlameLifetime *= asw_marine_burn_time_insane.GetFloat();
if ( m_flFirstBurnTime == 0 )
m_flFirstBurnTime = gpGlobals->curtime;
// if this is an env_fire trying to burn us, ignore the grace period that the AllowedToIgnite function does
// we want env_fires to always ignite the marine immediately so they can be used as dangerous blockers in levels
CFire *pFire = dynamic_cast<CFire*>(pAttacker);
if ( AllowedToIgnite() || pFire )
{
if( IsOnFire() )
return;
// scream about being on fire
GetMarineSpeech()->PersonalChatter(CHATTER_ON_FIRE);
AddFlag( FL_ONFIRE );
m_bOnFire = true;
if ( ASWBurning() )
{
ASWBurning()->BurnEntity(this, pAttacker, flFlameLifetime, 0.4f, 10.0f * 0.4f, pDamagingWeapon ); // 10 dps, applied every 0.4 seconds
}
IGameEvent * event = gameeventmanager->CreateEvent( "marine_ignited" );
if ( event )
{
event->SetInt( "entindex", entindex() );
gameeventmanager->FireEvent( event );
}
m_OnIgnite.FireOutput( this, this );
}
m_flLastBurnTime = gpGlobals->curtime;
}
void CASW_Marine::Ignite( float flFlameLifetime, bool bNPCOnly, float flSize, bool bCalledByLevelDesigner )
{
return; // use ASW_Ignite instead;
}
void CASW_Marine::Extinguish()
{
if ( m_bOnFire )
{
IGameEvent * event = gameeventmanager->CreateEvent( "marine_extinguished" );
if ( event )
{
event->SetInt( "entindex", entindex() );
gameeventmanager->FireEvent( event );
}
}
m_bOnFire = false;
if ( ASWBurning() )
{
ASWBurning()->Extinguish(this);
}
RemoveFlag( FL_ONFIRE );
}
bool CASW_Marine::AllowedToIgnite( void )
{
if ( m_iJumpJetting.Get() != 0 )
return false;
if ( m_flFirstBurnTime > 0 && (gpGlobals->curtime - m_flFirstBurnTime) >= asw_marine_time_until_ignite.GetFloat() )
return true;
// don't ignite, but play a flesh burn sound if we aren't on fire already
if ( !m_bOnFire && (gpGlobals->curtime - m_flLastBurnSoundTime) > 1.0f )
{
CASW_Player *player = GetCommander();
if ( player )
{
CSingleUserRecipientFilter localfilter( player );
localfilter.MakeReliable();
CBaseEntity::EmitSound( localfilter, entindex(), "ASW.MarineBurnPain_NoIgnite" );
m_flLastBurnSoundTime = gpGlobals->curtime;
}
}
return false;
}
int CASW_Marine::DrawDebugTextOverlays()
{
int text_offset = BaseClass::DrawDebugTextOverlays();
if (m_debugOverlays & OVERLAY_TEXT_BIT)
{
char buffer[256];
Q_snprintf(buffer, sizeof(buffer), "Using: %d (%s)\n",
m_hUsingEntity.Get(), m_hUsingEntity.Get() ? m_hUsingEntity->GetClassname() : " ");
NDebugOverlay::EntityText(entindex(),text_offset,buffer,0);
text_offset++;
if (GetASWOrders() == ASW_ORDER_HOLD_POSITION)
Q_snprintf(buffer, sizeof(buffer), "ASWOrders: ASW_ORDER_HOLD_POSITION\n");
else if (GetASWOrders() == ASW_ORDER_FOLLOW)
Q_snprintf(buffer, sizeof(buffer), "ASWOrders: ASW_ORDER_FOLLOW\n");
else if (GetASWOrders() == ASW_ORDER_MOVE_TO)
Q_snprintf(buffer, sizeof(buffer), "ASWOrders: ASW_ORDER_MOVE_TO\n");
else if (GetASWOrders() == ASW_ORDER_USE_OFFHAND_ITEM)
Q_snprintf(buffer, sizeof(buffer), "ASWOrders: ASW_ORDER_USE_OFFHAND_ITEM\n");
else
Q_snprintf(buffer, sizeof(buffer), "ASWOrders: Unknown\n");
NDebugOverlay::EntityText(entindex(),text_offset,buffer,0);
text_offset++;
Q_snprintf(buffer, sizeof(buffer), "FF scale: %f\n",m_fFriendlyFireAbsorptionTime);
NDebugOverlay::EntityText(entindex(),text_offset,buffer,0);
text_offset++;
}
return text_offset;
}
float CASW_Marine::GetReceivedDamageScale( CBaseEntity *pAttacker )
{
float flScale = 1;
// if we've been shot by another marine...
if (pAttacker && pAttacker->Classify() == CLASS_ASW_MARINE)
{
CASW_Marine *pMarine = CASW_Marine::AsMarine( pAttacker );
if (pMarine)
{
if (ASWGameRules() && ASWGameRules()->IsHardcoreMode())
{
// full damage in hardcore mode
flScale = 1;
}
else if (asw_marine_ff.GetInt() == 0) // FF Guard
{
flScale = 0.01f;
pMarine->ActivateFriendlyFireGuard(this);
}
else if (asw_marine_ff.GetInt() == 1) // normal
{
// allow friendly fire through based on difficulty level
int diff = ASWGameRules()->GetMissionDifficulty() - 5;
flScale = (asw_marine_ff_dmg_base.GetFloat() + asw_marine_ff_dmg_step.GetFloat() * diff);
}
else // full
{
// allow max friendly fire damage through, as though on mission difficulty +5
flScale = (asw_marine_ff_dmg_base.GetFloat() + asw_marine_ff_dmg_step.GetFloat() * 5.0f);
}
}
}
return flScale * BaseClass::GetReceivedDamageScale(pAttacker);
}
void CASW_Marine::ActivateFriendlyFireGuard(CASW_Marine *pVictim)
{
// stops the marine from being able to fire
// todo: make wepaons check this time isn't 0, to prevent firing
m_fFFGuardTime = gpGlobals->curtime + asw_marine_ff_guard_time.GetFloat();
// todo: play a sound warning the player of FF
}
int CASW_Marine::GetAlienMeleeFlinch()
{
return MarineSkills()->GetSkillBasedValueByMarine(this, ASW_MARINE_SKILL_MELEE, ASW_MARINE_SUBSKILL_MELEE_FLINCH);
}
// POWERUPS!
void CASW_Marine::AddPowerup( int iType, float flExpireTime )
{
RemoveAllPowerups();
// if a powerup doesn't expire, we tell the current weapon that it has the powerup
// if we want powerups that don't expire and aren't tied to a weapon's clip, we'll need to rethink this
if ( flExpireTime > gpGlobals->curtime )
{
m_bPowerupExpires = true;
m_flPowerupExpireTime = flExpireTime;
}
else
{
CASW_Weapon* pWeapon = GetActiveASWWeapon();
if ( !pWeapon )
return;
pWeapon->MakePoweredUp( true );
}
m_iPowerupType = iType;
}
bool CASW_Marine::HasPowerup( int iType )
{
if ( m_iPowerupType == iType )
return true;
return false;
}
void CASW_Marine::RemoveWeaponPowerup( CASW_Weapon* pWeapon )
{
if ( !pWeapon )
return;
if ( pWeapon->m_bPoweredUp )
{
m_bPowerupExpires = false;
pWeapon->MakePoweredUp( false );
m_iPowerupType = -1;
}
}
void CASW_Marine::RemoveAllPowerups( void )
{
m_bPowerupExpires = false;
m_iPowerupType = -1;
m_flPowerupExpireTime = -1;
for ( int i = 0; i < 3; i++ )
{
CASW_Weapon* pWeapon = GetASWWeapon(i);
if ( !pWeapon )
continue;
pWeapon->MakePoweredUp( false );
}
}
void CASW_Marine::UpdatePowerupDuration( void )
{
if ( m_iPowerupType >= 0 )
{
if ( m_bPowerupExpires && m_flPowerupExpireTime <= gpGlobals->curtime )
{
RemoveAllPowerups();
}
}
}
// test: always avoid..
void CASW_Marine::SetPlayerAvoidState()
{
m_bPlayerAvoidState = ShouldPlayerAvoid();
m_bPerformAvoidance = true;
}
void CASW_Marine::CheckAndRequestAmmo()
{
m_fLastAmmoCheckTime = gpGlobals->curtime;
bool bAllWeaponsOutOfAmmo = true;
CASW_Marine *pClosestAmmoBagSquadmate = NULL;
CASW_Marine *pActiveWpnAmmoBagSquadmate = NULL; // send high-priority message to player that can resupply active
for ( int iWeapon = 0; iWeapon < ASW_NUM_INVENTORY_SLOTS; iWeapon++ )
{
CASW_Weapon *pWeapon = GetASWWeapon(iWeapon);
if ( !pWeapon || !pWeapon->IsOffensiveWeapon() )
continue;
bool bWeaponHasAmmo = ( pWeapon->Clip1() > 0 || GetAmmoCount ( pWeapon->GetPrimaryAmmoType() ) > 0 );
bool bWeaponLowOnAmmo = ( pWeapon->Clip1() == 0 && GetAmmoCount ( pWeapon->GetPrimaryAmmoType() ) <= 1) ||
( GetAmmoCount ( pWeapon->GetPrimaryAmmoType() ) == 0 );
bool bActiveWeapon = ( GetActiveASWWeapon() == pWeapon );
if ( bWeaponHasAmmo )
{
bAllWeaponsOutOfAmmo = false;
}
// if we have some ammo, only request it if marine is player controlled, the weapon is active, and we're low on ammo
if ( bWeaponHasAmmo && ( !IsInhabited() || !bActiveWeapon || !bWeaponLowOnAmmo ) )
{
continue;
}
float fClosestAmmoBagDistSqr = FLT_MAX;
// find the closest marine who can resupply this weapon
CASW_Game_Resource *pGameResource = ASWGameResource();
for ( int i=0; i<pGameResource->GetMaxMarineResources(); i++ )
{
CASW_Marine_Resource *pMarineResource = pGameResource->GetMarineResource(i);
if ( !pMarineResource )
continue;
CASW_Marine *pSquadmate = pMarineResource->GetMarineEntity();
if ( !pSquadmate || ( pSquadmate == this ) )
continue;
if ( pSquadmate->CanGiveAmmoTo( this ) )
{
float fAmmoBagDistSqr = pSquadmate->GetAbsOrigin().DistToSqr( GetAbsOrigin() );
if ( fAmmoBagDistSqr < fClosestAmmoBagDistSqr )
{
fClosestAmmoBagDistSqr = fAmmoBagDistSqr;
pClosestAmmoBagSquadmate = pSquadmate; // need to save for later use
}
}
}
if ( pClosestAmmoBagSquadmate )
{
// if player controlled, we NEED ammo rather than simply wanting it
pClosestAmmoBagSquadmate->SetCondition( IsInhabited() ? COND_SQUADMATE_NEEDS_AMMO : COND_SQUADMATE_WANTS_AMMO );
if ( bActiveWeapon )
pActiveWpnAmmoBagSquadmate = pClosestAmmoBagSquadmate;
}
}
if ( pActiveWpnAmmoBagSquadmate )
{
// if anyone can resupply our active weapon, they get the higher priority NEED condition
pActiveWpnAmmoBagSquadmate->SetCondition( COND_SQUADMATE_NEEDS_AMMO );
}
else if ( pClosestAmmoBagSquadmate && bAllWeaponsOutOfAmmo )
{
// otherwise, if we're all out of ammo, send a higher priority NEED request
pClosestAmmoBagSquadmate->SetCondition( COND_SQUADMATE_NEEDS_AMMO );
}
}
bool CASW_Marine::IsOutOfAmmo()
{
for ( int iWeapon = 0; iWeapon < ASW_NUM_INVENTORY_SLOTS; iWeapon++ )
{
CASW_Weapon *pWeapon = GetASWWeapon(iWeapon);
if (pWeapon && pWeapon->IsOffensiveWeapon() && (pWeapon->Clip1() > 0 || GetAmmoCount(pWeapon->GetPrimaryAmmoType()) > 0))
{
return false;
}
}
return true;
}
void CASW_Marine::OnWeaponOutOfAmmo(bool bChatter)
{
if (bChatter && GetMarineSpeech())
{
GetMarineSpeech()->Chatter(CHATTER_NO_AMMO);
bEmoteAmmo = true;
CASW_Marine_Resource *pMR = GetMarineResource();
if ( pMR )
{
char szName[ 256 ];
pMR->GetDisplayName( szName, sizeof( szName ) );
UTIL_ClientPrintAll( ASW_HUD_PRINTTALKANDCONSOLE, "#asw_out_of_ammo", szName );
}
}
CheckAndRequestAmmo();
// check to see if completely out of ammo on all weapons
if ( !IsOutOfAmmo() )
return;
IGameEvent * event = gameeventmanager->CreateEvent( "marine_no_ammo" );
if ( event )
{
CASW_Player *pPlayer = GetCommander();
event->SetInt( "userid", ( pPlayer ? pPlayer->GetUserID() : 0 ) );
event->SetInt( "entindex", entindex() );
event->SetInt( "count", ( pPlayer ? UTIL_ASW_NumCommandedMarines( pPlayer ) : 0 ) );
gameeventmanager->FireEvent( event );
}
ASWFailAdvice()->OnMarineOutOfAmmo();
// if marine has no ammo in any offensive weapon, log the position for stats
if ( GetMarineResource() )
{
GetMarineResource()->m_vecOutOfAmmoSpot = GetAbsOrigin();
}
}
void CASW_Marine::PhysicsLandedOnGround( float fFallSpeed )
{
float fFallVel = fabs(fFallSpeed) * 1.17f; // add 17% onto the fall speed - this makes the fall speeds of AI roughly match up with the ones done by player movement
if ( GetGroundEntity() != NULL && GetHealth() > 0 && fFallVel >= PLAYER_FALL_PUNCH_THRESHOLD )
{
bool bAlive = true;
float fvol = 0.5;
if ( GetWaterLevel() > 0 )
{
// They landed in water.
}
else
{
// Scale it down if we landed on something that's floating...
if ( GetGroundEntity()->IsFloating() )
{
fFallVel -= PLAYER_LAND_ON_FLOATING_OBJECT;
}
// They hit the ground.
if ( fFallVel > PLAYER_MAX_SAFE_FALL_SPEED )
{
// If they hit the ground going this fast they may take damage (and die).
//bAlive = MoveHelper( )->PlayerFallingDamage();
#ifndef CLIENT_DLL
float fFallVelMod = fFallVel;
fFallVelMod -= PLAYER_MAX_SAFE_FALL_SPEED;
float flFallDamage = fFallVelMod * DAMAGE_FOR_FALL_SPEED;
//Msg("Marine fell with speed %f modded to %f damage is %f\n", fFallVel, fFallVelMod, flFallDamage);
if ( flFallDamage > 0 )
{
TakeDamage( CTakeDamageInfo( GetContainingEntity(INDEXENT(0)), GetContainingEntity(INDEXENT(0)), flFallDamage, DMG_FALL ) );
CRecipientFilter filter;
filter.AddRecipientsByPAS( GetAbsOrigin() );
CBaseEntity::EmitSound( filter, entindex(), "Player.FallDamage" );
}
bAlive = GetHealth() > 0;
#endif
fvol = 1.0;
}
else if ( fFallVel > PLAYER_MAX_SAFE_FALL_SPEED / 2 )
{
fvol = 0.85;
}
else if ( fFallVel < PLAYER_MIN_BOUNCE_SPEED )
{
fvol = 0;
}
}
if ( fvol > 0.0 )
{
// asw todo?
// Play landing sound right away.
//player->m_flStepSoundTime = 400;
// Play step sound for current texture.
//PlayStepSound( mv->m_vecAbsOrigin, m_pSurfaceData, fvol, true );
}
}
}
float CASW_Marine::GetFFAbsorptionScale()
{
float fScale = 1.0f;
if ( asw_marine_ff_absorption.GetInt() == 1 ) // ramp damage up over time
{
fScale = m_fFriendlyFireAbsorptionTime * m_fFriendlyFireAbsorptionTime;
}
else if ( asw_marine_ff_absorption.GetInt() == 2 ) // ramp damage down over time
{
fScale = 1.0f - ( m_fFriendlyFireAbsorptionTime * m_fFriendlyFireAbsorptionTime );
}
fScale = 0.05f + 0.95f * fScale; // always do a minimum % damage
return fScale;
}
void CASW_Marine::Stumble( CBaseEntity *pSource, const Vector &vecStumbleDir, bool bShort )
{
if ( !pSource || GetForcedActionRequest() != 0 )
return;
if ( pSource->Classify() == CLASS_ASW_SHIELDBUG ) // don't stumble from shieldbugs, they do knockdowns instead
return;
if ( pSource->Classify() == CLASS_ASW_MARINE ) // don't stumble from friendly fire
return;
if ( gpGlobals->curtime < m_flNextStumbleTime )
return;
//vecStumbleDir.z = 0;
//vecStumbleDir.NormalizeInPlace();
QAngle staggerAngles;
VectorAngles( vecStumbleDir, staggerAngles );
float yawDelta = AngleNormalize( GetAbsAngles()[YAW] - staggerAngles[YAW] );
if ( yawDelta <= 45 && yawDelta >= -45 )
m_iForcedActionRequest = bShort ? FORCED_ACTION_STUMBLE_SHORT_FORWARD : FORCED_ACTION_STUMBLE_FORWARD;
else if ( yawDelta > 45 && yawDelta < 135 )
m_iForcedActionRequest = bShort ? FORCED_ACTION_STUMBLE_SHORT_RIGHT : FORCED_ACTION_STUMBLE_RIGHT;
else if ( yawDelta < -45 && yawDelta > -135 )
m_iForcedActionRequest = bShort ? FORCED_ACTION_STUMBLE_SHORT_LEFT : FORCED_ACTION_STUMBLE_LEFT;
else
m_iForcedActionRequest = bShort ? FORCED_ACTION_STUMBLE_SHORT_BACKWARD : FORCED_ACTION_STUMBLE_BACKWARD;
SetNextStumbleTime( gpGlobals->curtime + asw_stumble_interval.GetFloat() );
}
void CASW_Marine::Knockdown( CBaseEntity *pSource, const Vector &vecImpulse, bool bForce )
{
if ( !pSource )
return;
// already knocked down
if ( GetForcedActionRequest() >= FORCED_ACTION_KNOCKDOWN_FORWARD && GetForcedActionRequest() <= FORCED_ACTION_KNOCKDOWN_BACKWARD )
return;
if ( gpGlobals->curtime < m_flNextStumbleTime && !bForce )
return;
Vector vecKnockdownDir = vecImpulse.Normalized();
QAngle staggerAngles;
VectorAngles( vecKnockdownDir, staggerAngles );
float yawDelta = AngleNormalize( GetAbsAngles()[YAW] - staggerAngles[YAW] );
//Msg( "yawDelta = %f marine angles = %f staggerangles = %f\n", yawDelta, GetAbsAngles()[YAW], staggerAngles[YAW] );
if ( yawDelta <= 90 && yawDelta >= -90 )
m_iForcedActionRequest = FORCED_ACTION_KNOCKDOWN_FORWARD;
else
m_iForcedActionRequest = FORCED_ACTION_KNOCKDOWN_BACKWARD;
ApplyAbsVelocityImpulse( vecImpulse );
m_flKnockdownYaw = UTIL_VecToYaw( vecKnockdownDir );
SetNextStumbleTime( gpGlobals->curtime + asw_knockdown_interval.GetFloat() );
}
void CASW_Marine::ModifyOrAppendCriteria( AI_CriteriaSet& set )
{
BaseClass::ModifyOrAppendCriteria(set);
set.AppendCriteria( "who", GetResponseRulesName() );
}
const char * CASW_Marine::GetResponseRulesName()
{
// a little roundabout for now because we amateurishly
// have to store criteria values as strings (argh)
return AI_CriteriaSet::SymbolToStr(GetMarineProfile()->m_nResponseRulesName);
}
CASW_Marine * CASW_Marine::GetSquadLeader()
{
CASW_SquadFormation * RESTRICT psquad = GetSquadFormation();
return ( psquad ? psquad->Leader() : NULL );
}
void CASW_Marine::OnWeaponFired( const CBaseEntity *pWeapon, int nShotsFired, bool bIsSecondary /*= false */ )
{
if( !pWeapon )
return;
// Fire weapon fired event for gamestats
CASW_GameStats.Event_MarineWeaponFired( pWeapon, this, nShotsFired, bIsSecondary );
}
ConVar asw_marine_debug_movement( "asw_marine_debug_movement", "0", FCVAR_CHEAT, "Debug overall marine movement direction" );
void CASW_Marine::AddPositionHistory()
{
const float flToleranceSqr = asw_movement_direction_tolerance.GetFloat() * asw_movement_direction_tolerance.GetFloat();
// check we don't have an entry for this spot already
for ( int i = 0; i < ASW_MARINE_HISTORY_POSITIONS; i++ )
{
if ( m_PositionHistory[ i ].flTime != 0.0f && m_PositionHistory[ i ].vecPosition.DistToSqr( GetAbsOrigin() ) < flToleranceSqr )
{
if ( asw_marine_debug_movement.GetBool() )
{
Msg( "too near pos history %d distsq %f\n", i, m_PositionHistory[ i ].vecPosition.DistToSqr( GetAbsOrigin() ) );
float flMoveYaw = GetOverallMovementDirection();
NDebugOverlay::YawArrow( GetAbsOrigin() + Vector( 0, 0, 10 ), flMoveYaw, 64, 16, 255, 255, 64, 0, true, asw_movement_direction_interval.GetFloat() );
Msg( "Moveyaw = %f\n", flMoveYaw );
}
return;
}
}
m_nPositionHistoryTail++;
if ( m_nPositionHistoryTail >= ASW_MARINE_HISTORY_POSITIONS )
{
m_nPositionHistoryTail = 0;
}
m_PositionHistory[ m_nPositionHistoryTail ].vecPosition = GetAbsOrigin();
m_PositionHistory[ m_nPositionHistoryTail ].flTime = gpGlobals->curtime;
if ( asw_marine_debug_movement.GetBool() )
{
Msg( "Stored positioned [%d] = %f %f %f\n", m_nPositionHistoryTail, VectorExpand( GetAbsOrigin() ) );
NDebugOverlay::Cross( GetAbsOrigin(), 10, 255, 255, 0, false, asw_movement_direction_interval.GetFloat() * 5.0f );
float flMoveYaw = GetOverallMovementDirection();
NDebugOverlay::YawArrow( GetAbsOrigin() + Vector( 0, 0, 10 ), flMoveYaw, 64, 16, 255, 255, 64, 0, true, asw_movement_direction_interval.GetFloat() );
Msg( "Moveyaw = %f\n", flMoveYaw );
}
}
float CASW_Marine::GetOverallMovementDirection()
{
// take average of position histories
int nCount = 0;
Vector vecPos = vec3_origin;
for ( int i = 0; i < ASW_MARINE_HISTORY_POSITIONS; i++ )
{
if ( m_PositionHistory[ i ].flTime != 0.0f )
{
vecPos += m_PositionHistory[ i ].vecPosition;
nCount++;
}
}
if ( nCount == 0 )
{
return 90.0f;
}
Vector vecSmoothedPosition = vecPos / (float) nCount;
if ( asw_marine_debug_movement.GetBool() )
{
Msg( "Found %d positions in history. total vec = %f %f %f\n", nCount, VectorExpand( vecPos ) );
NDebugOverlay::Line( WorldSpaceCenter(), vecSmoothedPosition, 255, 0, 0, false, 1.0f );
}
return UTIL_VecToYaw( ( GetAbsOrigin() - vecSmoothedPosition ).Normalized() );
}
bool CASW_Marine::TeleportStuckMarine()
{
// Aim in the direction of the last saved position
Vector vToPrev = m_PositionHistory[ m_nPositionHistoryTail ].vecPosition - GetAbsOrigin();
VectorNormalize( vToPrev );
// Add some upward push
vToPrev.z = 1.0f;
VectorNormalize( vToPrev );
Vector vOldPos = GetAbsOrigin();
bool bSuccess = UTIL_FindClosestPassableSpace( this, vToPrev, MASK_PLAYERSOLID, NULL, FL_AXIS_DIRECTION_NZ );
if ( bSuccess )
{
DevMsg( "Unstuck marine from (%.2f %.2f %.2f) to (%.2f %.2f %.2f).\n", vOldPos.x, vOldPos.y, vOldPos.z, GetAbsOrigin().x, GetAbsOrigin().y, GetAbsOrigin().z );
}
trace_t tr;
Ray_t ray;
ray.Init( GetAbsOrigin(), GetAbsOrigin(), CollisionProp()->OBBMins(), CollisionProp()->OBBMaxs() );
UTIL_TraceRay( ray, MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &tr );
if ( ( tr.contents & MASK_PLAYERSOLID ) && tr.m_pEnt )
{
// still stuck
return TeleportToFreeNode();
}
return bSuccess;
}
bool CASW_Marine::TeleportToFreeNode()
{
// now find the nearest clear info node
CAI_Node *pNode = NULL;
CAI_Node *pNearest = NULL;
float fNearestDist = -1;
for (int i=0;i<GetNavigator()->GetNetwork()->NumNodes();i++)
{
pNode = GetNavigator()->GetNetwork()->GetNode(i);
if (!pNode)
continue;
float dist = GetAbsOrigin().DistTo(pNode->GetOrigin());
if (dist < fNearestDist || fNearestDist == -1)
{
// check the spot is clear
Vector vecPos = pNode->GetOrigin();
trace_t tr;
UTIL_TraceHull( vecPos,
vecPos + Vector( 0, 0, 1 ),
CollisionProp()->OBBMins(),
CollisionProp()->OBBMaxs(),
MASK_PLAYERSOLID,
this,
COLLISION_GROUP_NONE,
&tr );
if( tr.fraction == 1.0 )
{
fNearestDist = dist;
pNearest = pNode;
}
}
}
// found a valid node, teleport there
if (pNearest)
{
Vector vecPos = pNearest->GetOrigin();
Teleport( &vecPos, NULL, &vec3_origin );
return true;
}
return false;
}
CBaseTrigger* CASW_Marine::IsInEscapeVolume()
{
for ( int i = 0; i < g_aEscapeObjectives.Count(); i++ )
{
CBaseTrigger *pTrigger = g_aEscapeObjectives[ i ]->GetTrigger();
if ( pTrigger && pTrigger->IsTouching( this ) )
{
return pTrigger;
}
}
return NULL;
}
Reference in New Issue View Git Blame Copy Permalink