codemp/game/g_combat.c File Reference

#include "b_local.h"
#include "bg_saga.h"
#include "../namespace_begin.h"
#include "../namespace_end.h"

Go to the source code of this file.

Defines
#define	DEATH_ALERT_RADIUS   512
#define	DEATH_ALERT_SOUND_RADIUS   512
Functions
int	G_ShipSurfaceForSurfName (const char *surfaceName)
qboolean	G_FlyVehicleDestroySurface (gentity_t *veh, int surface)
void	G_VehicleSetDamageLocFlags (gentity_t *veh, int impactDir, int deathPoint)
void	G_VehUpdateShields (gentity_t *targ)
void	G_LetGoOfWall (gentity_t *ent)
void	BG_ClearRocketLock (playerState_t *ps)
void	BotDamageNotification (gclient_t *bot, gentity_t *attacker)
void	ThrowSaberToAttacker (gentity_t *self, gentity_t *attacker)
void	ObjectDie (gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath)
qboolean	G_HeavyMelee (gentity_t *attacker)
int	G_GetHitLocation (gentity_t *target, vec3_t ppoint)
void	ExplodeDeath (gentity_t *self)
void	ScorePlum (gentity_t *ent, vec3_t origin, int score)
void	AddScore (gentity_t *ent, vec3_t origin, int score)
void	TossClientWeapon (gentity_t *self, vec3_t direction, float speed)
void	TossClientItems (gentity_t *self)
void	LookAtKiller (gentity_t *self, gentity_t *inflictor, gentity_t *attacker)
void	GibEntity (gentity_t *self, int killer)
void	BodyRid (gentity_t *ent)
void	body_die (gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath)
void	CheckAlmostCapture (gentity_t *self, gentity_t *attacker)
qboolean	G_InKnockDown (playerState_t *ps)
int	G_PickDeathAnim (gentity_t *self, vec3_t point, int damage, int mod, int hitLoc)
gentity_t *	G_GetJediMaster (void)
void	G_AlertTeam (gentity_t *victim, gentity_t *attacker, float radius, float soundDist)
void	G_DeathAlert (gentity_t *victim, gentity_t *attacker)
void	DeathFX (gentity_t *ent)
void	G_CheckVictoryScript (gentity_t *self)
void	G_AddPowerDuelScore (int team, int score)
void	G_AddPowerDuelLoserScore (int team, int score)
void	AI_DeleteSelfFromGroup (gentity_t *self)
void	AI_GroupMemberKilled (gentity_t *self)
void	Boba_FlyStop (gentity_t *self)
qboolean	Jedi_WaitingAmbush (gentity_t *self)
void	CheckExitRules (void)
void	Rancor_DropVictim (gentity_t *self)
void	player_die (gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath)
int	CheckArmor (gentity_t *ent, int damage, int dflags)
void	G_ApplyKnockback (gentity_t *targ, vec3_t newDir, float knockback)
int	RaySphereIntersections (vec3_t origin, float radius, vec3_t point, vec3_t dir, vec3_t intersections[2])
void	G_GetDismemberLoc (gentity_t *self, vec3_t boltPoint, int limbType)
void	G_GetDismemberBolt (gentity_t *self, vec3_t boltPoint, int limbType)
void	LimbTouch (gentity_t *self, gentity_t *other, trace_t *trace)
void	LimbThink (gentity_t *ent)
qboolean	BG_GetRootSurfNameWithVariant (void *ghoul2, const char *rootSurfName, char *returnSurfName, int returnSize)
void	G_Dismember (gentity_t *ent, gentity_t *enemy, vec3_t point, int limbType, float limbRollBase, float limbPitchBase, int deathAnim, qboolean postDeath)
void	DismembermentTest (gentity_t *self)
void	DismembermentByNum (gentity_t *self, int num)
int	G_GetHitQuad (gentity_t *self, vec3_t hitloc)
void	UpdateClientRenderBolts (gentity_t *self, vec3_t renderOrigin, vec3_t renderAngles)
qboolean	G_GetHitLocFromSurfName (gentity_t *ent, const char *surfName, int *hitLoc, vec3_t point, vec3_t dir, vec3_t bladeDir, int mod)
void	G_CheckForDismemberment (gentity_t *ent, gentity_t *enemy, vec3_t point, int damage, int deathAnim, qboolean postDeath)
void	G_LocationBasedDamageModifier (gentity_t *ent, vec3_t point, int mod, int dflags, int *damage)
qboolean	G_ThereIsAMaster (void)
void	G_Knockdown (gentity_t *victim)
void	G_Damage (gentity_t *targ, gentity_t *inflictor, gentity_t *attacker, vec3_t dir, vec3_t point, int damage, int dflags, int mod)
qboolean	CanDamage (gentity_t *targ, vec3_t origin)
qboolean	G_RadiusDamage (vec3_t origin, gentity_t *attacker, float damage, float radius, gentity_t *ignore, gentity_t *missile, int mod)
Variables
qboolean	g_dontPenalizeTeam
char *	modNames [MOD_MAX]
stringID_table_t	animTable [MAX_ANIMATIONS+1]
qboolean	g_dontFrickinCheck
qboolean	g_endPDuel
qboolean	g_noPDuelCheck
char *	hitLocName [HL_MAX]
int	gGAvoidDismember = 0
qboolean	gSiegeRoundBegun
int	gPainMOD = 0
int	gPainHitLoc = -1
vec3_t	gPainPoint

---

Define Documentation

#define DEATH_ALERT_RADIUS   512

Definition at line 1865 of file g_combat.c. Referenced by G_DeathAlert().

#define DEATH_ALERT_SOUND_RADIUS   512

Definition at line 1866 of file g_combat.c. Referenced by G_DeathAlert().

---

Function Documentation

void AddScore (  gentity_t *  ent, vec3_t  origin, int  score )

Definition at line 436 of file g_combat.c. References CalculateRanks(), gentity_s::client, g_dontPenalizeTeam, g_gametype, gentity_t, GT_TEAM, vmCvar_t::integer, level, PERS_SCORE, PERS_TEAM, playerState_s::persistant, gclient_s::ps, level_locals_t::teamScores, vec3_t, and level_locals_t::warmupTime. Referenced by AddSiegeWinningTeamPoints(), BroadcastObjectiveCompletion(), player_die(), Team_FragBonuses(), Team_TouchEnemyFlag(), Team_TouchOurFlag(), Use_Target_Escapetrig(), and Use_Target_Score(). { /* if (g_gametype.integer == GT_SIEGE) { //no scoring in this gametype at all. return; } */ if ( !ent->client ) { return; } // no scoring during pre-match warmup if ( level.warmupTime ) { return; } // show score plum //ScorePlum(ent, origin, score); // ent->client->ps.persistant[PERS_SCORE] += score; if ( g_gametype.integer == GT_TEAM && !g_dontPenalizeTeam ) level.teamScores[ ent->client->ps.persistant[PERS_TEAM] ] += score; CalculateRanks(); }

void AI_DeleteSelfFromGroup (  gentity_t *  self  )

Definition at line 602 of file NPC_AI_Utils.c. References AI_DeleteGroupMember(), gentity_t, gNPC_t::group, AIGroupInfo_s::member, gentity_s::NPC, AIGroupMember_s::number, entityState_s::number, AIGroupInfo_s::numGroup, and gentity_s::s. Referenced by player_die(). { int i; //FIXME: if killed, keep track of how many in group killed? To affect morale? for ( i = 0; i < self->NPC->group->numGroup; i++ ) { if ( self->NPC->group->member[i].number == self->s.number ) { AI_DeleteGroupMember( self->NPC->group, i ); return; } } }

void AI_GroupMemberKilled (  gentity_t *  self  )

Definition at line 620 of file NPC_AI_Utils.c. References AEL_DANGER_GREAT, AIGroupInfo_t, AIGroupInfo_s::commander, gNPC_t::currentAim, entityShared_t::currentOrigin, AIGroupInfo_s::enemy, g_entities, gentity_t, gNPC_t::group, AIGroupInfo_s::member, AIGroupInfo_s::moraleAdjust, gentity_s::NPC, AIGroupMember_s::number, AIGroupInfo_s::numGroup, Q_irand(), qboolean, qfalse, qtrue, gentity_s::r, gNPC_t::rank, RANK_ENSIGN, AIGroupInfo_s::speechDebounceTime, ST_AggressionAdjust(), ST_MarkToCover(), and ST_StartFlee(). Referenced by player_die(). { AIGroupInfo_t *group = self->NPC->group; gentity_t *member; qboolean noflee = qfalse; int i; if ( !group ) {//what group? return; } if ( !self || !self->NPC || self->NPC->rank < RANK_ENSIGN ) {//I'm not an officer, let's not really care for now return; } //temporarily drop group morale for a few seconds group->moraleAdjust -= self->NPC->rank; //go through and drop aggression on my teammates (more cover, worse aim) for ( i = 0; i < group->numGroup; i++ ) { member = &g_entities[group->member[i].number]; if ( member == self ) { continue; } if ( member->NPC->rank > RANK_ENSIGN ) {//officers do not panic noflee = qtrue; } else { ST_AggressionAdjust( member, -1 ); member->NPC->currentAim -= Q_irand( 0, 10 );//Q_irand( 0, 2);//drop their aim accuracy } } //okay, if I'm the group commander, make everyone else flee if ( group->commander != self ) {//I'm not the commander... hmm, should maybe a couple flee... maybe those near me? return; } //now see if there is another of sufficient rank to keep them from fleeing if ( !noflee ) { self->NPC->group->speechDebounceTime = 0; for ( i = 0; i < group->numGroup; i++ ) { member = &g_entities[group->member[i].number]; if ( member == self ) { continue; } if ( member->NPC->rank < RANK_ENSIGN ) {//grunt if ( group->enemy && DistanceSquared( member->r.currentOrigin, group->enemy->r.currentOrigin ) < 65536/*256*256*/ ) {//those close to enemy run away! ST_StartFlee( member, group->enemy, member->r.currentOrigin, AEL_DANGER_GREAT, 3000, 5000 ); } else if ( DistanceSquared( member->r.currentOrigin, self->r.currentOrigin ) < 65536/*256*256*/ ) {//those close to me run away! ST_StartFlee( member, group->enemy, member->r.currentOrigin, AEL_DANGER_GREAT, 3000, 5000 ); } else {//else, maybe just a random chance if ( Q_irand( 0, self->NPC->rank ) > member->NPC->rank ) {//lower rank they are, higher rank I am, more likely they are to flee ST_StartFlee( member, group->enemy, member->r.currentOrigin, AEL_DANGER_GREAT, 3000, 5000 ); } else { ST_MarkToCover( member ); } } member->NPC->currentAim -= Q_irand( 1, 15 ); //Q_irand( 1, 3 );//drop their aim accuracy even more } member->NPC->currentAim -= Q_irand( 1, 15 ); //Q_irand( 1, 3 );//drop their aim accuracy even more } } }

void BG_ClearRocketLock (  playerState_t *  ps  )

Definition at line 5751 of file bg_pmove.c. References ENTITYNUM_NONE, playerState_t, playerState_s::rocketLastValidTime, playerState_s::rocketLockIndex, playerState_s::rocketLockTime, and playerState_s::rocketTargetTime. Referenced by player_die(), and PM_BeginWeaponChange(). { if ( ps ) { ps->rocketLockIndex = ENTITYNUM_NONE; ps->rocketLastValidTime = 0; ps->rocketLockTime = -1; ps->rocketTargetTime = 0; } }

qboolean BG_GetRootSurfNameWithVariant (  void *  ghoul2, const char *  rootSurfName, char *  returnSurfName, int  returnSize )

Definition at line 101 of file bg_g2_utils.c. References Com_sprintf(), MAX_VARIANTS, Q_strncpyz(), qboolean, qfalse, qtrue, and trap_G2API_GetSurfaceRenderStatus(). Referenced by G_Dismember(). { if ( !ghoul2 || !trap_G2API_GetSurfaceRenderStatus( ghoul2, 0, rootSurfName ) ) {//see if the basic name without variants is on Q_strncpyz( returnSurfName, rootSurfName, returnSize ); return qtrue; } else {//check variants int i; for ( i = 0; i < MAX_VARIANTS; i++ ) { Com_sprintf( returnSurfName, returnSize, "%s%c", rootSurfName, 'a'+i ); if ( !trap_G2API_GetSurfaceRenderStatus( ghoul2, 0, returnSurfName ) ) { return qtrue; } } } Q_strncpyz( returnSurfName, rootSurfName, returnSize ); return qfalse; }

void Boba_FlyStop (  gentity_t *  self  )

Definition at line 367 of file NPC_AI_Jedi.c. { self->client->ps.gravity = g_gravity.value; if ( self->NPC ) { self->NPC->aiFlags &= ~NPCAI_CUSTOM_GRAVITY; } self->client->ps.eFlags2 &= ~EF2_FLYING; self->client->jetPackTime = 0; //stop jet loop sound self->s.loopSound = 0; if ( self->NPC ) { self->count = 0; // SEEKER shot ammo count TIMER_Set( self, "jetRecharge", Q_irand( 1000, 5000 ) ); TIMER_Set( self, "jumpChaseDebounce", Q_irand( 500, 2000 ) ); } }

void body_die (  gentity_t *  self, gentity_t *  inflictor, gentity_t *  attacker, int  damage, int  meansOfDeath )

Definition at line 685 of file g_combat.c. References BodyRid(), gentity_s::client, entityShared_t::currentOrigin, EF_DISINTEGRATION, playerState_s::eFlags, entityState_s::eFlags, ET_NPC, entityState_s::eType, G_FreeEntity(), gentity_t, GIB_HEALTH, gentity_s::health, playerState_s::lastHitLoc, level, MOD_CRUSH, MOD_FALLING, MOD_LAVA, MOD_SLIME, MOD_SUICIDE, MOD_TARGET_LASER, MOD_TELEFRAG, MOD_TRIGGER_HURT, MOD_UNKNOWN, MOD_WATER, gentity_s::nextthink, playerState_s::origin, entityState_s::origin2, gclient_s::ps, qboolean, qfalse, qtrue, gentity_s::r, gclient_s::respawnTime, gentity_s::s, gentity_s::think, level_locals_t::time, playerState_s::torsoTimer, and VectorCopy. Referenced by player_die(). { // NOTENOTE No gibbing right now, this is star wars. qboolean doDisint = qfalse; if (self->s.eType == ET_NPC) { //well, just rem it then, so long as it's done with its death anim and it's not a standard weapon. if ( self->client && self->client->ps.torsoTimer <= 0 && (meansOfDeath == MOD_UNKNOWN || meansOfDeath == MOD_WATER || meansOfDeath == MOD_SLIME || meansOfDeath == MOD_LAVA || meansOfDeath == MOD_CRUSH || meansOfDeath == MOD_TELEFRAG || meansOfDeath == MOD_FALLING || meansOfDeath == MOD_SUICIDE || meansOfDeath == MOD_TARGET_LASER || meansOfDeath == MOD_TRIGGER_HURT) ) { self->think = G_FreeEntity; self->nextthink = level.time; } return; } if (self->health < (GIB_HEALTH+1)) { self->health = GIB_HEALTH+1; if (self->client && (level.time - self->client->respawnTime) < 2000) { doDisint = qfalse; } else { doDisint = qtrue; } } if (self->client && (self->client->ps.eFlags & EF_DISINTEGRATION)) { return; } else if (self->s.eFlags & EF_DISINTEGRATION) { return; } if (doDisint) { if (self->client) { self->client->ps.eFlags |= EF_DISINTEGRATION; VectorCopy(self->client->ps.origin, self->client->ps.lastHitLoc); } else { self->s.eFlags |= EF_DISINTEGRATION; VectorCopy(self->r.currentOrigin, self->s.origin2); //since it's the corpse entity, tell it to "remove" itself self->think = BodyRid; self->nextthink = level.time + 1000; } return; } }

void BodyRid (  gentity_t *  ent  )

Definition at line 674 of file g_combat.c. References gentity_t, gentity_s::physicsObject, qfalse, and trap_UnlinkEntity(). Referenced by body_die(). { trap_UnlinkEntity( ent ); ent->physicsObject = qfalse; }

void BotDamageNotification (  gclient_t *  bot, gentity_t *  attacker )

Definition at line 1861 of file ai_main.c. References bot_state_t, botstates, bot_state_s::client, gentity_s::client, playerState_s::clientNum, bot_state_s::currentEnemy, ENEMY_FORGET_MS, bot_state_s::enemySeenTime, g_entities, gclient_t, gentity_t, bot_state_s::lastAttacked, bot_state_s::lastHurt, level, MAX_CLIENTS, NULL, entityState_s::number, PassLovedOneCheck(), PassStandardEnemyChecks(), gclient_s::ps, gentity_s::s, and level_locals_t::time. Referenced by G_Damage(). { bot_state_t *bs; bot_state_t *bs_a; int i; if (!bot || !attacker || !attacker->client) { return; } if (bot->ps.clientNum >= MAX_CLIENTS) { //an NPC.. do nothing for them. return; } if (attacker->s.number >= MAX_CLIENTS) { //if attacker is an npc also don't care I suppose. return; } bs_a = botstates[attacker->s.number]; if (bs_a) { //if the client attacking us is a bot as well bs_a->lastAttacked = &g_entities[bot->ps.clientNum]; i = 0; while (i < MAX_CLIENTS) { if (botstates[i] && i != bs_a->client && botstates[i]->lastAttacked == &g_entities[bot->ps.clientNum]) { botstates[i]->lastAttacked = NULL; } i++; } } else //got attacked by a real client, so no one gets rights to lastAttacked { i = 0; while (i < MAX_CLIENTS) { if (botstates[i] && botstates[i]->lastAttacked == &g_entities[bot->ps.clientNum]) { botstates[i]->lastAttacked = NULL; } i++; } } bs = botstates[bot->ps.clientNum]; if (!bs) { return; } bs->lastHurt = attacker; if (bs->currentEnemy) { //we don't care about the guy attacking us if we have an enemy already return; } if (!PassStandardEnemyChecks(bs, attacker)) { //the person that hurt us is not a valid enemy return; } if (PassLovedOneCheck(bs, attacker)) { //the person that hurt us is the one we love! bs->currentEnemy = attacker; bs->enemySeenTime = level.time + ENEMY_FORGET_MS; } }

qboolean CanDamage (  gentity_t *  targ, vec3_t  origin )

Definition at line 5510 of file g_combat.c. References entityShared_t::absmax, entityShared_t::absmin, trace_t::entityNum, ENTITYNUM_NONE, trace_t::fraction, gentity_t, MASK_SOLID, entityState_s::number, qboolean, qfalse, qtrue, gentity_s::r, gentity_s::s, trap_Trace(), vec3_origin, vec3_t, VectorAdd, VectorCopy, and VectorScale. Referenced by G_RadiusDamage(). { vec3_t dest; trace_t tr; vec3_t midpoint; // use the midpoint of the bounds instead of the origin, because // bmodels may have their origin is 0,0,0 VectorAdd (targ->r.absmin, targ->r.absmax, midpoint); VectorScale (midpoint, 0.5, midpoint); VectorCopy (midpoint, dest); trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID); if (tr.fraction == 1.0 || tr.entityNum == targ->s.number) return qtrue; // this should probably check in the plane of projection, // rather than in world coordinate, and also include Z VectorCopy (midpoint, dest); dest[0] += 15.0; dest[1] += 15.0; trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID); if (tr.fraction == 1.0) return qtrue; VectorCopy (midpoint, dest); dest[0] += 15.0; dest[1] -= 15.0; trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID); if (tr.fraction == 1.0) return qtrue; VectorCopy (midpoint, dest); dest[0] -= 15.0; dest[1] += 15.0; trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID); if (tr.fraction == 1.0) return qtrue; VectorCopy (midpoint, dest); dest[0] -= 15.0; dest[1] -= 15.0; trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID); if (tr.fraction == 1.0) return qtrue; return qfalse; }

void CheckAlmostCapture (  gentity_t *  self, gentity_t *  attacker )

Definition at line 805 of file g_combat.c. References gentity_s::client, FL_DROPPED_ITEM, gentity_s::flags, FOFS, G_Find(), g_gametype, gentity_t, GT_CTF, GT_CTY, vmCvar_t::integer, NULL, entityState_s::origin, playerState_s::origin, PERS_PLAYEREVENTS, playerState_s::persistant, playerState_s::powerups, gclient_s::ps, PW_BLUEFLAG, PW_NEUTRALFLAG, PW_REDFLAG, gentity_s::r, gentity_s::s, gclient_s::sess, clientSession_t::sessionTeam, SVF_NOCLIENT, entityShared_t::svFlags, TEAM_BLUE, vec3_t, and VectorSubtract. Referenced by player_die(). { #if 0 gentity_t *ent; vec3_t dir; char *classname; // if this player was carrying a flag if ( self->client->ps.powerups[PW_REDFLAG] || self->client->ps.powerups[PW_BLUEFLAG] || self->client->ps.powerups[PW_NEUTRALFLAG] ) { // get the goal flag this player should have been going for if ( g_gametype.integer == GT_CTF || g_gametype.integer == GT_CTY ) { if ( self->client->sess.sessionTeam == TEAM_BLUE ) { classname = "team_CTF_blueflag"; } else { classname = "team_CTF_redflag"; } } else { if ( self->client->sess.sessionTeam == TEAM_BLUE ) { classname = "team_CTF_redflag"; } else { classname = "team_CTF_blueflag"; } } ent = NULL; do { ent = G_Find(ent, FOFS(classname), classname); } while (ent && (ent->flags & FL_DROPPED_ITEM)); // if we found the destination flag and it's not picked up if (ent && !(ent->r.svFlags & SVF_NOCLIENT) ) { // if the player was *very* close VectorSubtract( self->client->ps.origin, ent->s.origin, dir ); if ( VectorLength(dir) < 200 ) { self->client->ps.persistant[PERS_PLAYEREVENTS] ^= PLAYEREVENT_HOLYSHIT; if ( attacker->client ) { attacker->client->ps.persistant[PERS_PLAYEREVENTS] ^= PLAYEREVENT_HOLYSHIT; } } } } #endif }

int CheckArmor (  gentity_t *  ent, int  damage, int  dflags )

Definition at line 2894 of file g_combat.c. References ARMOR_PROTECTION, ARMOR_REDUCTION_FACTOR, ceil(), CLASS_VEHICLE, gentity_s::client, client, DAMAGE_HALF_ABSORB, DAMAGE_HALF_ARMOR_REDUCTION, DAMAGE_NO_ARMOR, playerState_s::electrifyTime, gclient_t, gentity_t, level, gentity_s::m_pVehicle, gclient_s::NPC_class, gclient_s::ps, STAT_ARMOR, playerState_s::stats, and level_locals_t::time. Referenced by G_Damage(). { gclient_t *client; int save; int count; if (!damage) return 0; client = ent->client; if (!client) return 0; if (dflags & DAMAGE_NO_ARMOR) return 0; if ( client->NPC_class == CLASS_VEHICLE && ent->m_pVehicle && ent->client->ps.electrifyTime > level.time ) {//ion-cannon has disabled this ship's shields, take damage on hull! return 0; } // armor count = client->ps.stats[STAT_ARMOR]; if (dflags & DAMAGE_HALF_ABSORB) { // Half the damage gets absorbed by the shields, rather than 100% save = ceil( damage * ARMOR_PROTECTION ); } else { // All the damage gets absorbed by the shields. save = damage; } // save is the most damage that the armor is elibigle to protect, of course, but it's limited by the total armor. if (save >= count) save = count; if (!save) return 0; if (dflags & DAMAGE_HALF_ARMOR_REDUCTION) // Armor isn't whittled so easily by sniper shots. { client->ps.stats[STAT_ARMOR] -= (int)(save*ARMOR_REDUCTION_FACTOR); } else { client->ps.stats[STAT_ARMOR] -= save; } return save; }

void CheckExitRules (  void   )

Definition at line 2572 of file g_main.c. References BeginIntermission(), CheckIntermissionExit(), gentity_s::client, level_locals_t::clients, Com_Printf(), CON_CONNECTED, clientPersistant_t::connected, d_powerDuelPrint, g_capturelimit, g_duel_fraglimit, g_endPDuel, g_entities, g_fraglimit, g_gametype, G_GetStringEdString(), g_maxclients, g_timelimit, gclient_t, gDoSlowMoDuel, gDuelExit, gEscapeTime, gEscaping, GT_CTF, GT_DUEL, GT_POWERDUEL, GT_SIEGE, gentity_s::health, vmCvar_t::integer, INTERMISSION_DELAY_TIME, level_locals_t::intermissionQueued, level_locals_t::intermissiontime, gentity_s::inuse, level, LogExit(), MAX_CLIENTS, clientPersistant_t::netname, level_locals_t::numPlayingClients, gclient_s::pers, PERS_SCORE, playerState_s::persistant, playerState_s::pm_flags, PMF_FOLLOW, gclient_s::ps, qboolean, qfalse, qtrue, S_COLOR_WHITE, ScoreIsTied(), gclient_s::sess, clientSession_t::sessionTeam, level_locals_t::startTime, TEAM_BLUE, TEAM_FREE, TEAM_RED, TEAM_SPECTATOR, level_locals_t::teamScores, level_locals_t::time, trap_SendServerCommand(), va(), level_locals_t::warmupTime, and clientSession_t::wins. Referenced by CalculateRanks(), G_RunFrame(), and player_die(). { int i; gclient_t *cl; char *sKillLimit; qboolean printLimit = qtrue; // if at the intermission, wait for all non-bots to // signal ready, then go to next level if ( level.intermissiontime ) { CheckIntermissionExit (); return; } if (gDoSlowMoDuel) { //don't go to intermission while in slow motion return; } if (gEscaping) { int i = 0; int numLiveClients = 0; while (i < MAX_CLIENTS) { if (g_entities[i].inuse && g_entities[i].client && g_entities[i].health > 0) { if (g_entities[i].client->sess.sessionTeam != TEAM_SPECTATOR && !(g_entities[i].client->ps.pm_flags & PMF_FOLLOW)) { numLiveClients++; } } i++; } if (gEscapeTime < level.time) { gEscaping = qfalse; LogExit( "Escape time ended." ); return; } if (!numLiveClients) { gEscaping = qfalse; LogExit( "Everyone failed to escape." ); return; } } if ( level.intermissionQueued ) { //int time = (g_singlePlayer.integer) ? SP_INTERMISSION_DELAY_TIME : INTERMISSION_DELAY_TIME; int time = INTERMISSION_DELAY_TIME; if ( level.time - level.intermissionQueued >= time ) { level.intermissionQueued = 0; BeginIntermission(); } return; } /* if (g_gametype.integer == GT_POWERDUEL) { if (level.numPlayingClients < 3) { if (!level.intermissiontime) { if (d_powerDuelPrint.integer) { Com_Printf("POWERDUEL WIN CONDITION: Duel forfeit (1)\n"); } LogExit("Duel forfeit."); return; } } } */ // check for sudden death if (g_gametype.integer != GT_SIEGE) { if ( ScoreIsTied() ) { // always wait for sudden death if ((g_gametype.integer != GT_DUEL) || !g_timelimit.integer) { if (g_gametype.integer != GT_POWERDUEL) { return; } } } } if (g_gametype.integer != GT_SIEGE) { if ( g_timelimit.integer && !level.warmupTime ) { if ( level.time - level.startTime >= g_timelimit.integer*60000 ) { // trap_SendServerCommand( -1, "print \"Timelimit hit.\n\""); trap_SendServerCommand( -1, va("print \"%s.\n\"",G_GetStringEdString("MP_SVGAME", "TIMELIMIT_HIT"))); if (d_powerDuelPrint.integer) { Com_Printf("POWERDUEL WIN CONDITION: Timelimit hit (1)\n"); } LogExit( "Timelimit hit." ); return; } } } if (g_gametype.integer == GT_POWERDUEL && level.numPlayingClients >= 3) { if (g_endPDuel) { g_endPDuel = qfalse; LogExit("Powerduel ended."); } //yeah, this stuff was completely insane. /* int duelists[3]; duelists[0] = level.sortedClients[0]; duelists[1] = level.sortedClients[1]; duelists[2] = level.sortedClients[2]; if (duelists[0] != -1 && duelists[1] != -1 && duelists[2] != -1) { if (!g_entities[duelists[0]].inuse || !g_entities[duelists[0]].client || g_entities[duelists[0]].client->ps.stats[STAT_HEALTH] <= 0 || g_entities[duelists[0]].client->sess.sessionTeam != TEAM_FREE) { //The lone duelist lost, give the other two wins (if applicable) and him a loss if (g_entities[duelists[0]].inuse && g_entities[duelists[0]].client) { g_entities[duelists[0]].client->sess.losses++; ClientUserinfoChanged(duelists[0]); } if (g_entities[duelists[1]].inuse && g_entities[duelists[1]].client) { if (g_entities[duelists[1]].client->ps.stats[STAT_HEALTH] > 0 && g_entities[duelists[1]].client->sess.sessionTeam == TEAM_FREE) { g_entities[duelists[1]].client->sess.wins++; } else { g_entities[duelists[1]].client->sess.losses++; } ClientUserinfoChanged(duelists[1]); } if (g_entities[duelists[2]].inuse && g_entities[duelists[2]].client) { if (g_entities[duelists[2]].client->ps.stats[STAT_HEALTH] > 0 && g_entities[duelists[2]].client->sess.sessionTeam == TEAM_FREE) { g_entities[duelists[2]].client->sess.wins++; } else { g_entities[duelists[2]].client->sess.losses++; } ClientUserinfoChanged(duelists[2]); } //Will want to parse indecies for two out at some point probably trap_SetConfigstring ( CS_CLIENT_DUELWINNER, va("%i", duelists[1] ) ); if (d_powerDuelPrint.integer) { Com_Printf("POWERDUEL WIN CONDITION: Coupled duelists won (1)\n"); } LogExit( "Coupled duelists won." ); gDuelExit = qfalse; } else if ((!g_entities[duelists[1]].inuse || !g_entities[duelists[1]].client || g_entities[duelists[1]].client->sess.sessionTeam != TEAM_FREE || g_entities[duelists[1]].client->ps.stats[STAT_HEALTH] <= 0) && (!g_entities[duelists[2]].inuse || !g_entities[duelists[2]].client || g_entities[duelists[2]].client->sess.sessionTeam != TEAM_FREE || g_entities[duelists[2]].client->ps.stats[STAT_HEALTH] <= 0)) { //the coupled duelists lost, give the lone duelist a win (if applicable) and the couple both losses if (g_entities[duelists[1]].inuse && g_entities[duelists[1]].client) { g_entities[duelists[1]].client->sess.losses++; ClientUserinfoChanged(duelists[1]); } if (g_entities[duelists[2]].inuse && g_entities[duelists[2]].client) { g_entities[duelists[2]].client->sess.losses++; ClientUserinfoChanged(duelists[2]); } if (g_entities[duelists[0]].inuse && g_entities[duelists[0]].client && g_entities[duelists[0]].client->ps.stats[STAT_HEALTH] > 0 && g_entities[duelists[0]].client->sess.sessionTeam == TEAM_FREE) { g_entities[duelists[0]].client->sess.wins++; ClientUserinfoChanged(duelists[0]); } trap_SetConfigstring ( CS_CLIENT_DUELWINNER, va("%i", duelists[0] ) ); if (d_powerDuelPrint.integer) { Com_Printf("POWERDUEL WIN CONDITION: Lone duelist won (1)\n"); } LogExit( "Lone duelist won." ); gDuelExit = qfalse; } } */ return; } if ( level.numPlayingClients < 2 ) { return; } if (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL) { if (g_fraglimit.integer > 1) { sKillLimit = "Kill limit hit."; } else { sKillLimit = ""; printLimit = qfalse; } } else { sKillLimit = "Kill limit hit."; } if ( g_gametype.integer < GT_SIEGE && g_fraglimit.integer ) { if ( level.teamScores[TEAM_RED] >= g_fraglimit.integer ) { trap_SendServerCommand( -1, va("print \"Red %s\n\"", G_GetStringEdString("MP_SVGAME", "HIT_THE_KILL_LIMIT")) ); if (d_powerDuelPrint.integer) { Com_Printf("POWERDUEL WIN CONDITION: Kill limit (1)\n"); } LogExit( sKillLimit ); return; } if ( level.teamScores[TEAM_BLUE] >= g_fraglimit.integer ) { trap_SendServerCommand( -1, va("print \"Blue %s\n\"", G_GetStringEdString("MP_SVGAME", "HIT_THE_KILL_LIMIT")) ); if (d_powerDuelPrint.integer) { Com_Printf("POWERDUEL WIN CONDITION: Kill limit (2)\n"); } LogExit( sKillLimit ); return; } for ( i=0 ; i< g_maxclients.integer ; i++ ) { cl = level.clients + i; if ( cl->pers.connected != CON_CONNECTED ) { continue; } if ( cl->sess.sessionTeam != TEAM_FREE ) { continue; } if ( (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL) && g_duel_fraglimit.integer && cl->sess.wins >= g_duel_fraglimit.integer ) { if (d_powerDuelPrint.integer) { Com_Printf("POWERDUEL WIN CONDITION: Duel limit hit (1)\n"); } LogExit( "Duel limit hit." ); gDuelExit = qtrue; trap_SendServerCommand( -1, va("print \"%s" S_COLOR_WHITE " hit the win limit.\n\"", cl->pers.netname ) ); return; } if ( cl->ps.persistant[PERS_SCORE] >= g_fraglimit.integer ) { if (d_powerDuelPrint.integer) { Com_Printf("POWERDUEL WIN CONDITION: Kill limit (3)\n"); } LogExit( sKillLimit ); gDuelExit = qfalse; if (printLimit) { trap_SendServerCommand( -1, va("print \"%s" S_COLOR_WHITE " %s.\n\"", cl->pers.netname, G_GetStringEdString("MP_SVGAME", "HIT_THE_KILL_LIMIT") ) ); } return; } } } if ( g_gametype.integer >= GT_CTF && g_capturelimit.integer ) { if ( level.teamScores[TEAM_RED] >= g_capturelimit.integer ) { trap_SendServerCommand( -1, va("print \"%s \"", G_GetStringEdString("MP_SVGAME", "PRINTREDTEAM"))); trap_SendServerCommand( -1, va("print \"%s.\n\"", G_GetStringEdString("MP_SVGAME", "HIT_CAPTURE_LIMIT"))); LogExit( "Capturelimit hit." ); return; } if ( level.teamScores[TEAM_BLUE] >= g_capturelimit.integer ) { trap_SendServerCommand( -1, va("print \"%s \"", G_GetStringEdString("MP_SVGAME", "PRINTBLUETEAM"))); trap_SendServerCommand( -1, va("print \"%s.\n\"", G_GetStringEdString("MP_SVGAME", "HIT_CAPTURE_LIMIT"))); LogExit( "Capturelimit hit." ); return; } } }

void DeathFX (  gentity_t *  ent  )

Definition at line 1882 of file g_combat.c. References AngleVectors(), CHAN_AUTO, CLASS_ATST, CLASS_GONK, CLASS_INTERROGATOR, CLASS_MARK1, CLASS_MARK2, CLASS_MOUSE, CLASS_PROBE, CLASS_PROTOCOL, CLASS_R2D2, CLASS_R5D2, CLASS_REMOTE, CLASS_SEEKER, CLASS_SENTRY, gentity_s::client, entityShared_t::currentAngles, entityShared_t::currentOrigin, G_EffectIndex(), G_PlayEffectID(), G_Sound(), G_SoundIndex(), gentity_t, gclient_s::NPC_class, NULL, Q_irand(), gentity_s::r, va(), vec3_t, VectorCopy, VectorMA, and VectorSet. Referenced by player_die(). { vec3_t effectPos, right; vec3_t defaultDir; if ( !ent || !ent->client ) return; VectorSet(defaultDir, 0, 0, 1); // team no longer indicates species/race. NPC_class should be used to identify certain npc types switch(ent->client->NPC_class) { case CLASS_MOUSE: VectorCopy( ent->r.currentOrigin, effectPos ); effectPos[2] -= 20; G_PlayEffectID( G_EffectIndex("env/small_explode"), effectPos, defaultDir ); G_Sound( ent, CHAN_AUTO, G_SoundIndex("sound/chars/mouse/misc/death1") ); break; case CLASS_PROBE: VectorCopy( ent->r.currentOrigin, effectPos ); effectPos[2] += 50; G_PlayEffectID( G_EffectIndex("explosions/probeexplosion1"), effectPos, defaultDir ); break; case CLASS_ATST: AngleVectors( ent->r.currentAngles, NULL, right, NULL ); VectorMA( ent->r.currentOrigin, 20, right, effectPos ); effectPos[2] += 180; G_PlayEffectID( G_EffectIndex("explosions/droidexplosion1"), effectPos, defaultDir ); VectorMA( effectPos, -40, right, effectPos ); G_PlayEffectID( G_EffectIndex("explosions/droidexplosion1"), effectPos, defaultDir ); break; case CLASS_SEEKER: case CLASS_REMOTE: G_PlayEffectID( G_EffectIndex("env/small_explode"), ent->r.currentOrigin, defaultDir ); break; case CLASS_GONK: VectorCopy( ent->r.currentOrigin, effectPos ); effectPos[2] -= 5; // statusTextIndex = Q_irand( IGT_RESISTANCEISFUTILE, IGT_NAMEIS8OF12 ); G_Sound( ent, CHAN_AUTO, G_SoundIndex(va("sound/chars/gonk/misc/death%d.wav",Q_irand( 1, 3 ))) ); G_PlayEffectID( G_EffectIndex("env/med_explode"), effectPos, defaultDir ); break; // should list all remaining droids here, hope I didn't miss any case CLASS_R2D2: VectorCopy( ent->r.currentOrigin, effectPos ); effectPos[2] -= 10; G_PlayEffectID( G_EffectIndex("env/med_explode"), effectPos, defaultDir ); G_Sound( ent, CHAN_AUTO, G_SoundIndex("sound/chars/mark2/misc/mark2_explo") ); break; case CLASS_PROTOCOL: //c3p0 case CLASS_R5D2: VectorCopy( ent->r.currentOrigin, effectPos ); effectPos[2] -= 10; G_PlayEffectID( G_EffectIndex("env/med_explode"), effectPos, defaultDir ); G_Sound( ent, CHAN_AUTO, G_SoundIndex("sound/chars/mark2/misc/mark2_explo") ); break; case CLASS_MARK2: VectorCopy( ent->r.currentOrigin, effectPos ); effectPos[2] -= 15; G_PlayEffectID( G_EffectIndex("explosions/droidexplosion1"), effectPos, defaultDir ); G_Sound( ent, CHAN_AUTO, G_SoundIndex("sound/chars/mark2/misc/mark2_explo") ); break; case CLASS_INTERROGATOR: VectorCopy( ent->r.currentOrigin, effectPos ); effectPos[2] -= 15; G_PlayEffectID( G_EffectIndex("explosions/droidexplosion1"), effectPos, defaultDir ); G_Sound( ent, CHAN_AUTO, G_SoundIndex("sound/chars/interrogator/misc/int_droid_explo") ); break; case CLASS_MARK1: AngleVectors( ent->r.currentAngles, NULL, right, NULL ); VectorMA( ent->r.currentOrigin, 10, right, effectPos ); effectPos[2] -= 15; G_PlayEffectID( G_EffectIndex("explosions/droidexplosion1"), effectPos, defaultDir ); VectorMA( effectPos, -20, right, effectPos ); G_PlayEffectID( G_EffectIndex("explosions/droidexplosion1"), effectPos, defaultDir ); VectorMA( effectPos, -20, right, effectPos ); G_PlayEffectID( G_EffectIndex("explosions/droidexplosion1"), effectPos, defaultDir ); G_Sound( ent, CHAN_AUTO, G_SoundIndex("sound/chars/mark1/misc/mark1_explo") ); break; case CLASS_SENTRY: G_Sound( ent, CHAN_AUTO, G_SoundIndex("sound/chars/sentry/misc/sentry_explo") ); VectorCopy( ent->r.currentOrigin, effectPos ); G_PlayEffectID( G_EffectIndex("env/med_explode"), effectPos, defaultDir ); break; default: break; } }

void DismembermentByNum (  gentity_t *  self, int  num )

Definition at line 3510 of file g_combat.c. References BOTH_DEATH1, G2_MODELPART_HEAD, G2_MODELPART_LARM, G2_MODELPART_LLEG, G2_MODELPART_RARM, G2_MODELPART_RHAND, G2_MODELPART_RLEG, G2_MODELPART_WAIST, G_Dismember(), G_GetDismemberBolt(), gentity_t, qfalse, and vec3_t. Referenced by ClientCommand(). { int sect = G2_MODELPART_HEAD; vec3_t boltPoint; switch (num) { case 0: sect = G2_MODELPART_HEAD; break; case 1: sect = G2_MODELPART_WAIST; break; case 2: sect = G2_MODELPART_LARM; break; case 3: sect = G2_MODELPART_RARM; break; case 4: sect = G2_MODELPART_RHAND; break; case 5: sect = G2_MODELPART_LLEG; break; case 6: sect = G2_MODELPART_RLEG; break; default: break; } G_GetDismemberBolt(self, boltPoint, sect); G_Dismember( self, self, boltPoint, sect, 90, 0, BOTH_DEATH1, qfalse ); }

void DismembermentTest (  gentity_t *  self  )

Definition at line 3497 of file g_combat.c. References BOTH_DEATH1, G2_MODELPART_HEAD, G2_MODELPART_RLEG, G_Dismember(), G_GetDismemberBolt(), gentity_t, qfalse, and vec3_t. Referenced by ClientCommand(). { int sect = G2_MODELPART_HEAD; vec3_t boltPoint; while (sect <= G2_MODELPART_RLEG) { G_GetDismemberBolt(self, boltPoint, sect); G_Dismember( self, self, boltPoint, sect, 90, 0, BOTH_DEATH1, qfalse ); sect++; } }

void ExplodeDeath (  gentity_t *  self  )

Definition at line 368 of file g_combat.c. References entityState_s::angles, AngleVectors(), entityShared_t::currentOrigin, G_RadiusDamage(), gentity_t, entityState_s::loopIsSoundset, entityState_s::loopSound, MOD_UNKNOWN, NULL, ObjectDie(), gentity_s::parent, entityState_s::pos, qfalse, gentity_s::r, gentity_s::s, gentity_s::splashDamage, gentity_s::splashRadius, gentity_s::takedamage, trajectory_t::trBase, vec3_t, and VectorCopy. { // gentity_t *tent; vec3_t forward; self->takedamage = qfalse;//stop chain reaction runaway loops self->s.loopSound = 0; self->s.loopIsSoundset = qfalse; VectorCopy( self->r.currentOrigin, self->s.pos.trBase ); // tent = G_TempEntity( self->s.origin, EV_FX_EXPLOSION ); AngleVectors(self->s.angles, forward, NULL, NULL); /* if ( self->fxID > 0 ) { G_PlayEffect( self->fxID, self->r.currentOrigin, forward ); } else */ { // CG_SurfaceExplosion( self->r.currentOrigin, forward, 20.0f, 12.0f, ((self->spawnflags&4)==qfalse) ); //FIXME: This needs to be consistent to all exploders! // G_Sound(self, self->sounds ); } if(self->splashDamage > 0 && self->splashRadius > 0) { gentity_t *attacker = self; if ( self->parent ) { attacker = self->parent; } G_RadiusDamage( self->r.currentOrigin, attacker, self->splashDamage, self->splashRadius, attacker, NULL, MOD_UNKNOWN ); } ObjectDie( self, self, self, 20, 0 ); }

void G_AddPowerDuelLoserScore (  int  team, int  score )

Definition at line 2036 of file g_combat.c. References gentity_s::client, ClientUserinfoChanged(), CON_CONNECTED, clientPersistant_t::connected, clientSession_t::duelTeam, g_entities, gentity_t, gclient_s::iAmALoser, gentity_s::inuse, clientSession_t::losses, MAX_CLIENTS, entityState_s::number, gclient_s::pers, gclient_s::ps, gentity_s::s, gclient_s::sess, clientSession_t::sessionTeam, STAT_HEALTH, playerState_s::stats, and TEAM_SPECTATOR. Referenced by player_die(). { int i = 0; gentity_t *check; while (i < MAX_CLIENTS) { check = &g_entities[i]; if (check->inuse && check->client && check->client->pers.connected == CON_CONNECTED && (check->client->iAmALoser || (check->client->ps.stats[STAT_HEALTH] <= 0 && check->client->sess.sessionTeam != TEAM_SPECTATOR)) && check->client->sess.duelTeam == team) { //found a living client on the specified team check->client->sess.losses += score; ClientUserinfoChanged(check->s.number); } i++; } }

void G_AddPowerDuelScore (  int  team, int  score )

Definition at line 2015 of file g_combat.c. References gentity_s::client, ClientUserinfoChanged(), CON_CONNECTED, clientPersistant_t::connected, clientSession_t::duelTeam, g_entities, gentity_t, gclient_s::iAmALoser, gentity_s::inuse, MAX_CLIENTS, entityState_s::number, gclient_s::pers, gclient_s::ps, gentity_s::s, gclient_s::sess, clientSession_t::sessionTeam, STAT_HEALTH, playerState_s::stats, TEAM_SPECTATOR, and clientSession_t::wins. Referenced by player_die(). { int i = 0; gentity_t *check; while (i < MAX_CLIENTS) { check = &g_entities[i]; if (check->inuse && check->client && check->client->pers.connected == CON_CONNECTED && !check->client->iAmALoser && check->client->ps.stats[STAT_HEALTH] > 0 && check->client->sess.sessionTeam != TEAM_SPECTATOR && check->client->sess.duelTeam == team) { //found a living client on the specified team check->client->sess.wins += score; ClientUserinfoChanged(check->s.number); } i++; } }

void G_AlertTeam (  gentity_t *  victim, gentity_t *  attacker, float  radius, float  soundDist )

Definition at line 1769 of file g_combat.c. References gentity_s::client, entityShared_t::currentOrigin, gentity_s::enemy, g_entities, G_SetEnemy(), gentity_t, gentity_s::health, gNPCstats_e::hfov, InFOV(), gentity_s::NPC, NPC_ClearLOS2(), NULL, gclient_s::playerTeam, gentity_s::r, SCF_IGNORE_ALERTS, SCF_LOOK_FOR_ENEMIES, SCF_NO_GROUPS, gNPC_t::scriptFlags, gNPC_t::stats, trap_EntitiesInBox(), trap_InPVS(), vec3_t, and gNPCstats_e::vfov. Referenced by G_AngerAlert(), and G_DeathAlert(). { int radiusEnts[ 128 ]; gentity_t *check; vec3_t mins, maxs; int numEnts; int i; float distSq, sndDistSq = (soundDist*soundDist); if ( attacker == NULL || attacker->client == NULL ) return; //Setup the bbox to search in for ( i = 0; i < 3; i++ ) { mins[i] = victim->r.currentOrigin[i] - radius; maxs[i] = victim->r.currentOrigin[i] + radius; } //Get the number of entities in a given space numEnts = trap_EntitiesInBox( mins, maxs, radiusEnts, 128 ); //Cull this list for ( i = 0; i < numEnts; i++ ) { check = &g_entities[radiusEnts[i]]; //Validate clients if ( check->client == NULL ) continue; //only want NPCs if ( check->NPC == NULL ) continue; //Don't bother if they're ignoring enemies // if ( check->svFlags & SVF_IGNORE_ENEMIES ) // continue; //This NPC specifically flagged to ignore alerts if ( check->NPC->scriptFlags & SCF_IGNORE_ALERTS ) continue; //This NPC specifically flagged to ignore alerts if ( !(check->NPC->scriptFlags&SCF_LOOK_FOR_ENEMIES) ) continue; //this ent does not participate in group AI if ( (check->NPC->scriptFlags&SCF_NO_GROUPS) ) continue; //Skip the requested avoid check if present if ( check == victim ) continue; //Skip the attacker if ( check == attacker ) continue; //Must be on the same team if ( check->client->playerTeam != victim->client->playerTeam ) continue; //Must be alive if ( check->health <= 0 ) continue; if ( check->enemy == NULL ) {//only do this if they're not already mad at someone distSq = DistanceSquared( check->r.currentOrigin, victim->r.currentOrigin ); if ( distSq > 16384 /*128 squared*/ && !trap_InPVS( victim->r.currentOrigin, check->r.currentOrigin ) ) {//not even potentially visible/hearable continue; } //NOTE: this allows sound alerts to still go through doors/PVS if the teammate is within 128 of the victim... if ( soundDist <= 0 || distSq > sndDistSq ) {//out of sound range if ( !InFOV( victim, check, check->NPC->stats.hfov, check->NPC->stats.vfov ) || !NPC_ClearLOS2( check, victim->r.currentOrigin ) ) {//out of FOV or no LOS continue; } } //FIXME: This can have a nasty cascading effect if setup wrong... G_SetEnemy( check, attacker ); } } }

void G_ApplyKnockback (  gentity_t *  targ, vec3_t  newDir, float  knockback )

Definition at line 2949 of file g_combat.c. References gentity_s::client, entityShared_t::currentOrigin, g_gravity, g_knockback, gentity_t, level, gentity_s::physicsBounce, playerState_s::pm_flags, playerState_s::pm_time, PMF_TIME_KNOCKBACK, entityState_s::pos, gclient_s::ps, gentity_s::r, gentity_s::s, level_locals_t::time, TR_LINEAR_STOP, TR_NONLINEAR_STOP, TR_STATIONARY, trajectory_t::trBase, trajectory_t::trDelta, trajectory_t::trTime, trajectory_t::trType, vmCvar_t::value, vec3_t, VectorAdd, VectorCopy, VectorScale, and playerState_s::velocity. Referenced by DoImpact(). { vec3_t kvel; float mass; if ( targ->physicsBounce > 0 ) //overide the mass mass = targ->physicsBounce; else mass = 200; if ( g_gravity.value > 0 ) { VectorScale( newDir, g_knockback.value * (float)knockback / mass * 0.8, kvel ); kvel[2] = newDir[2] * g_knockback.value * (float)knockback / mass * 1.5; } else { VectorScale( newDir, g_knockback.value * (float)knockback / mass, kvel ); } if ( targ->client ) { VectorAdd( targ->client->ps.velocity, kvel, targ->client->ps.velocity ); } else if ( targ->s.pos.trType != TR_STATIONARY && targ->s.pos.trType != TR_LINEAR_STOP && targ->s.pos.trType != TR_NONLINEAR_STOP ) { VectorAdd( targ->s.pos.trDelta, kvel, targ->s.pos.trDelta ); VectorCopy( targ->r.currentOrigin, targ->s.pos.trBase ); targ->s.pos.trTime = level.time; } // set the timer so that the other client can't cancel // out the movement immediately if ( targ->client && !targ->client->ps.pm_time ) { int t; t = knockback * 2; if ( t < 50 ) { t = 50; } if ( t > 200 ) { t = 200; } targ->client->ps.pm_time = t; targ->client->ps.pm_flags |= PMF_TIME_KNOCKBACK; } }

void G_CheckForDismemberment (  gentity_t *  ent, gentity_t *  enemy, vec3_t  point, int  damage, int  deathAnim, qboolean  postDeath )

Definition at line 4093 of file g_combat.c. References CLASS_PROTOCOL, gentity_s::client, d_saberGhoul2Collision, G2_MODELPART_HEAD, G2_MODELPART_LARM, G2_MODELPART_LLEG, G2_MODELPART_RARM, G2_MODELPART_RHAND, G2_MODELPART_RLEG, G2_MODELPART_WAIST, gclient_s::g2LastSurfaceHit, gclient_s::g2LastSurfaceTime, g_austrian, g_dismember, G_Dismember(), g_gametype, G_GetDismemberBolt(), G_GetDismemberLoc(), G_GetHitLocation(), G_GetHitLocFromSurfName(), G_GetHitQuad(), G_LogPrintf(), gentity_t, gGAvoidDismember, gentity_s::ghoul2, GT_DUEL, GT_POWERDUEL, hitLocName, HL_ARM_LT, HL_ARM_RT, HL_FOOT_LT, HL_FOOT_RT, HL_HAND_LT, HL_HAND_RT, HL_HEAD, HL_LEG_LT, HL_LEG_RT, HL_WAIST, vmCvar_t::integer, level, gentity_s::localAnimIndex, MAX_QPATH, MOD_UNKNOWN, clientPersistant_t::netname, gentity_s::NPC, gclient_s::NPC_class, gclient_s::pers, Q_irand(), level_locals_t::time, trap_G2API_GetSurfaceName(), vec3_origin, and vec3_t. Referenced by ClientCommand(), ClientThink_real(), G_Damage(), and player_die(). { int hitLoc = -1, hitLocUse = -1; vec3_t boltPoint; int dismember = g_dismember.integer; if (ent->localAnimIndex > 1) { if (!ent->NPC) { return; } if (ent->client->NPC_class != CLASS_PROTOCOL) { //this is the only non-humanoid allowed to do dismemberment. return; } } if (!dismember) { return; } if (gGAvoidDismember == 1) { return; } if (gGAvoidDismember != 2) { //this means do the dismemberment regardless of randomness and damage if (Q_irand(0, 100) > dismember) { return; } if (damage < 5) { return; } } if (gGAvoidDismember == 2) { hitLoc = HL_HAND_RT; } else { if (d_saberGhoul2Collision.integer && ent->client && ent->client->g2LastSurfaceTime == level.time) { char hitSurface[MAX_QPATH]; trap_G2API_GetSurfaceName(ent->ghoul2, ent->client->g2LastSurfaceHit, 0, hitSurface); if (hitSurface[0]) { G_GetHitLocFromSurfName(ent, hitSurface, &hitLoc, point, vec3_origin, vec3_origin, MOD_UNKNOWN); } } if (hitLoc == -1) { hitLoc = G_GetHitLocation( ent, point ); } } switch(hitLoc) { case HL_FOOT_RT: case HL_LEG_RT: hitLocUse = G2_MODELPART_RLEG; break; case HL_FOOT_LT: case HL_LEG_LT: hitLocUse = G2_MODELPART_LLEG; break; case HL_WAIST: hitLocUse = G2_MODELPART_WAIST; break; /* case HL_BACK_RT: case HL_BACK_LT: case HL_BACK: case HL_CHEST_RT: case HL_CHEST_LT: case HL_CHEST: break; */ case HL_ARM_RT: hitLocUse = G2_MODELPART_RARM; break; case HL_HAND_RT: hitLocUse = G2_MODELPART_RHAND; break; case HL_ARM_LT: case HL_HAND_LT: hitLocUse = G2_MODELPART_LARM; break; case HL_HEAD: hitLocUse = G2_MODELPART_HEAD; break; default: hitLocUse = G_GetHitQuad(ent, point); break; } if (hitLocUse == -1) { return; } if (ent->client) { G_GetDismemberBolt(ent, boltPoint, hitLocUse); if ( g_austrian.integer && (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL) ) { G_LogPrintf( "Duel Dismemberment: %s dismembered at %s\n", ent->client->pers.netname, hitLocName[hitLoc] ); } } else { G_GetDismemberLoc(ent, boltPoint, hitLocUse); } G_Dismember(ent, enemy, boltPoint, hitLocUse, 90, 0, deathAnim, postDeath); }

void G_CheckVictoryScript (  gentity_t *  self  )

Definition at line 1985 of file g_combat.c. References gNPC_t::blockedSpeechDebounceTime, BSET_VICTORY, CLASS_GALAKMECH, gentity_s::client, AIGroupInfo_s::commander, G_ActivateBehavior(), gentity_t, gNPC_t::greetingDebounceTime, gNPC_t::group, level, gentity_s::NPC, gclient_s::NPC_class, Q_irand(), gNPC_t::rank, gentity_s::s, level_locals_t::time, TIMER_Set(), gentity_s::wait, entityState_s::weapon, and WP_SABER. Referenced by player_die(). { if ( !G_ActivateBehavior( self, BSET_VICTORY ) ) { if ( self->NPC && self->s.weapon == WP_SABER ) {//Jedi taunt from within their AI self->NPC->blockedSpeechDebounceTime = 0;//get them ready to taunt return; } if ( self->client && self->client->NPC_class == CLASS_GALAKMECH ) { self->wait = 1; TIMER_Set( self, "gloatTime", Q_irand( 5000, 8000 ) ); self->NPC->blockedSpeechDebounceTime = 0;//get him ready to taunt return; } //FIXME: any way to not say this *right away*? Wait for victim's death anim/scream to finish? if ( self->NPC && self->NPC->group && self->NPC->group->commander && self->NPC->group->commander->NPC && self->NPC->group->commander->NPC->rank > self->NPC->rank && !Q_irand( 0, 2 ) ) {//sometimes have the group commander speak instead self->NPC->group->commander->NPC->greetingDebounceTime = level.time + Q_irand( 2000, 5000 ); //G_AddVoiceEvent( self->NPC->group->commander, Q_irand(EV_VICTORY1, EV_VICTORY3), 2000 ); } else if ( self->NPC ) { self->NPC->greetingDebounceTime = level.time + Q_irand( 2000, 5000 ); //G_AddVoiceEvent( self, Q_irand(EV_VICTORY1, EV_VICTORY3), 2000 ); } } }

void G_Damage (  gentity_t *  targ, gentity_t *  inflictor, gentity_t *  attacker, vec3_t  dir, vec3_t  point, int  damage, int  dflags, int  mod )

Definition at line 4369 of file g_combat.c. References gentity_s::activator, gentity_s::alliedTeam, AngleVectors(), bgSiegeClasses, BotDamageNotification(), BROKENLIMB_LARM, BROKENLIMB_RARM, playerState_s::brokenLimbs, BSET_DEATH, CFL_STRONGAGAINSTPHYSICAL, CheckArmor(), CLASS_ATST, CLASS_GONK, CLASS_INTERROGATOR, CLASS_MARK1, CLASS_MARK2, CLASS_MOUSE, CLASS_PROBE, CLASS_PROTOCOL, CLASS_R2D2, CLASS_R5D2, CLASS_RANCOR, CLASS_SEEKER, CLASS_SENTRY, CLASS_VEHICLE, client, gentity_s::client, playerState_s::clientNum, entityShared_t::currentOrigin, gclient_s::damage_armor, gclient_s::damage_blood, gclient_s::damage_from, gclient_s::damage_fromWorld, gclient_s::damage_knockback, DAMAGE_NO_DISMEMBER, DAMAGE_NO_HIT_LOC, DAMAGE_NO_KNOCKBACK, DAMAGE_NO_PROTECTION, DAMAGE_NO_SELF_PROTECTION, DAMAGE_RADIUS, DAMAGE_SABER_KNOCKBACK1, DAMAGE_SABER_KNOCKBACK1_B2, DAMAGE_SABER_KNOCKBACK2, DAMAGE_SABER_KNOCKBACK2_B2, gentity_s::damageRedirect, gentity_s::damageRedirectTo, gentity_s::die, DirToByte(), DotProduct, playerState_s::duelIndex, playerState_s::duelInProgress, EF_DEAD, EF_INVULNERABLE, playerState_s::eFlags, entityState_s::eFlags, playerState_s::electrifyTime, gentity_s::enemy, ENTITYNUM_WORLD, ET_GENERAL, ET_MISSILE, ET_MOVER, ET_NPC, ET_PLAYER, entityState_s::eType, EV_POWERUP_BATTLESUIT, EV_SHIELD_HIT, entityState_s::eventParm, playerState_s::fd, FL_BBRUSH, FL_DMG_BY_HEAVY_WEAP_ONLY, FL_DMG_BY_SABER_ONLY, FL_GODMODE, FL_NO_KNOCKBACK, FL_SHIELDED, FL_UNDYING, gentity_s::flags, FORCE_LEVEL_1, FORCE_LEVEL_2, FORCE_LEVEL_3, forcedata_s::forcePower, forcedata_s::forcePowerLevel, forcedata_s::forcePowersActive, gclient_s::forcePowerSoundDebounce, FP_PROTECT, FP_RAGE, trace_t::fraction, gclient_s::g2LastSurfaceHit, gclient_s::g2LastSurfaceTime, G_ActivateBehavior(), G_AddEvent(), g_armBreakage, G_BreakArm(), G_CheckForDismemberment(), g_debugDamage, g_debugMelee, g_entities, g_ff_objectives, G_FlyVehicleDestroySurface(), g_friendlyFire, g_gametype, G_GetHitLocFromSurfName(), G_HeavyMelee(), g_knockback, G_LetGoOfWall(), G_LocationBasedDamageModifier(), G_LogWeaponDamage(), G_PreDefSound(), G_Printf(), g_saberDmgVelocityScale, G_ScaleNetHealth(), G_ShipSurfaceForSurfName(), G_TempEntity(), G_ThereIsAMaster(), g_trueJedi, G_VehicleSetDamageLocFlags(), G_VehUpdateShields(), gclient_t, gentity_s::genericValue4, gentity_t, gentity_s::ghoul2, GlobalUse(), gPainHitLoc, gPainMOD, gPainPoint, gSiegeRoundBegun, GT_CTF, GT_CTY, GT_JEDIMASTER, GT_SIEGE, GT_TEAM, gentity_s::health, vehicleInfo_t::health_back, vehicleInfo_t::health_front, vehicleInfo_t::health_left, vehicleInfo_t::health_right, HL_ARM_LT, HL_ARM_RT, HL_HAND_LT, HL_HAND_RT, vmCvar_t::integer, level_locals_t::intermissionQueued, gentity_s::inuse, gclient_s::invulnerableTimer, playerState_s::isJediMaster, Jetpack_Off(), gclient_s::jetPackOn, gclient_s::jetPackToggleTime, saberInfo_t::knockbackScale, saberInfo_t::knockbackScale2, gclient_s::lasthurt_client, gclient_s::lasthurt_mod, level, gentity_s::locationDamage, Vehicle_s::m_iArmor, Vehicle_s::m_iShields, playerState_s::m_iVehicleNum, Vehicle_s::m_LandTrace, gentity_s::m_pVehicle, Vehicle_s::m_pVehicleInfo, Vehicle_s::m_vOrientation, MAX_CLIENTS, MAX_QPATH, gentity_s::maxHealth, MOD_BRYAR_PISTOL, MOD_BRYAR_PISTOL_ALT, MOD_CONC, MOD_CONC_ALT, MOD_CRUSH, MOD_DEMP2, MOD_DEMP2_ALT, MOD_DET_PACK_SPLASH, MOD_FALLING, MOD_FLECHETTE_ALT_SPLASH, MOD_MELEE, MOD_REPEATER_ALT, MOD_REPEATER_ALT_SPLASH, MOD_ROCKET, MOD_ROCKET_HOMING, MOD_ROCKET_HOMING_SPLASH, MOD_ROCKET_SPLASH, MOD_SABER, MOD_SUICIDE, MOD_TELEFRAG, MOD_THERMAL, MOD_THERMAL_SPLASH, MOD_TIMED_MINE_SPLASH, MOD_TRIGGER_HURT, MOD_TRIP_MINE_SPLASH, MOD_TURBLAST, MOD_VEHICLE, MOVER_POS1, gentity_s::moverState, gclient_s::noclip, entityState_s::NPC_class, gclient_s::NPC_class, NULL, entityState_s::number, OnSameTeam(), playerState_s::origin, entityState_s::otherEntityNum, playerState_s::otherKiller, playerState_s::otherKillerDebounceTime, playerState_s::otherKillerTime, entityState_s::owner, gentity_s::pain, PDSOUND_PROTECTHIT, PERS_ATTACKEE_ARMOR, PERS_ATTACKER, PERS_HITS, playerState_s::persistant, PITCH, playerState_s::pm_flags, playerState_s::pm_time, PMF_STUCK_TO_WALL, PMF_TIME_KNOCKBACK, gentity_s::pos1, gentity_s::pos2, playerState_s::powerups, gclient_s::ps, PW_BATTLESUIT, PW_FORCE_BOON, Q3_INFINITE, Q_irand(), qfalse, qtrue, gentity_s::r, ROLL, gentity_s::s, gclient_s::saber, gclient_s::sess, clientSession_t::sessionTeam, SHIPSURF_BACK, SHIPSURF_FRONT, SHIPSURF_LEFT, SHIPSURF_RIGHT, entityState_s::shouldtarget, gclient_s::siegeClass, STAT_ARMOR, STAT_HEALTH, STAT_MAX_HEALTH, playerState_s::stats, SVF_GLASS_BRUSH, entityShared_t::svFlags, gentity_s::takedamage, Team_CheckHurtCarrier(), gentity_s::teamnodmg, entityState_s::teamowner, level_locals_t::time, entityState_s::time2, playerState_s::torsoAnim, trap_G2API_GetSurfaceName(), playerState_s::trueJedi, playerState_s::trueNonJedi, vehicleInfo_t::type, gentity_s::use, vmCvar_t::value, vec3_origin, vec3_t, VectorAdd, VectorClear, VectorCopy, VectorNormalize(), VectorScale, VectorSubtract, playerState_s::velocity, VH_ANIMAL, VH_FIGHTER, VH_SPEEDER, VH_WALKER, playerState_s::weapon, WEAPON_CHARGING, WEAPON_CHARGING_ALT, WEAPON_READY, playerState_s::weaponstate, playerState_s::weaponTime, and WP_SABER. Referenced by AnimateRiders(), Blocked_Door(), Blocked_Mover(), Boba_FireFlameThrower(), ClientEvents(), ClientThink_real(), Cmd_DuelTeam_f(), DEMP2_AltRadiusDamage(), DetPackBlow(), Do_Strike(), DoGripAction(), DoImpact(), EjectAll(), ForceLightningDamage(), funcBBrushDieGo(), G_EjectDroidUnit(), G_KillBox(), G_MissileImpact(), G_MoverPush(), G_RadiusDamage(), G_RunFrame(), G_RunStuckMissile(), G_TryPushingEntity(), Howler_TryDamage(), hurt_touch(), hyperspace_touch(), ImperialProbe_Wait(), Interrogator_Melee(), MineMonster_TryDamage(), NPC_BSGM_Attack(), NPC_BSSeeker_Default(), NPC_Mark1_Pain(), NPC_Mark2_Pain(), NPC_Seeker_Pain(), P_WorldEffects(), player_die(), PM_VehicleImpact(), Rancor_Attack(), Rancor_Bite(), Rancor_Crush(), Rancor_Smash(), Rancor_Swing(), Seeker_Ranged(), shipboundary_touch(), target_kill_use(), target_laser_think(), Wampa_Slash(), WP_DisruptorAltFire(), WP_FireMelee(), WP_FireStunBaton(), WP_SaberApplyDamage(), WP_SaberPositionUpdate(), and WP_SaberRadiusDamage(). { gclient_t *client; int take; int save; int asave; int knockback; int max; int subamt = 0; float famt = 0; float hamt = 0; float shieldAbsorbed = 0; if (targ && targ->damageRedirect) { G_Damage(&g_entities[targ->damageRedirectTo], inflictor, attacker, dir, point, damage, dflags, mod); return; } if (mod == MOD_DEMP2 && targ && targ->inuse && targ->client) { if ( targ->client->ps.electrifyTime < level.time ) {//electrocution effect if (targ->s.eType == ET_NPC && targ->s.NPC_class == CLASS_VEHICLE && targ->m_pVehicle && (targ->m_pVehicle->m_pVehicleInfo->type == VH_SPEEDER || targ->m_pVehicle->m_pVehicleInfo->type == VH_WALKER)) { //do some extra stuff to speeders/walkers targ->client->ps.electrifyTime = level.time + Q_irand( 3000, 4000 ); } else if ( targ->s.NPC_class != CLASS_VEHICLE || (targ->m_pVehicle && targ->m_pVehicle->m_pVehicleInfo->type != VH_FIGHTER) ) {//don't do this to fighters targ->client->ps.electrifyTime = level.time + Q_irand( 300, 800 ); } } } if (g_gametype.integer == GT_SIEGE && !gSiegeRoundBegun) { //nothing can be damaged til the round starts. return; } if (!targ->takedamage) { return; } if ( (targ->flags&FL_SHIELDED) && mod != MOD_SABER && !targ->client) {//magnetically protected, this thing can only be damaged by lightsabers return; } if ((targ->flags & FL_DMG_BY_SABER_ONLY) && mod != MOD_SABER) { //saber-only damage return; } if ( targ->client ) {//don't take damage when in a walker, or fighter //unless the walker/fighter is dead!!! -rww if ( targ->client->ps.clientNum < MAX_CLIENTS && targ->client->ps.m_iVehicleNum ) { gentity_t *veh = &g_entities[targ->client->ps.m_iVehicleNum]; if ( veh->m_pVehicle && veh->health > 0 ) { if ( veh->m_pVehicle->m_pVehicleInfo->type == VH_WALKER || veh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER) { if (!(dflags & DAMAGE_NO_PROTECTION)) { return; } } } } } if ((targ->flags & FL_DMG_BY_HEAVY_WEAP_ONLY)) { //only take damage from explosives and such if (mod != MOD_REPEATER_ALT && mod != MOD_ROCKET && mod != MOD_FLECHETTE_ALT_SPLASH && mod != MOD_ROCKET_HOMING && mod != MOD_THERMAL && mod != MOD_THERMAL_SPLASH && mod != MOD_TRIP_MINE_SPLASH && mod != MOD_TIMED_MINE_SPLASH && mod != MOD_DET_PACK_SPLASH && mod != MOD_VEHICLE && mod != MOD_CONC && mod != MOD_CONC_ALT && mod != MOD_SABER && mod != MOD_TURBLAST && mod != MOD_SUICIDE && mod != MOD_FALLING && mod != MOD_CRUSH && mod != MOD_TELEFRAG && mod != MOD_TRIGGER_HURT) { if ( mod != MOD_MELEE || !G_HeavyMelee( attacker ) ) { //let classes with heavy melee ability damage heavy wpn dmg doors with fists return; } } } if (targ->flags & FL_BBRUSH) { if (mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT || mod == MOD_BRYAR_PISTOL || mod == MOD_BRYAR_PISTOL_ALT || mod == MOD_MELEE) { //these don't damage bbrushes.. ever if ( mod != MOD_MELEE || !G_HeavyMelee( attacker ) ) { //let classes with heavy melee ability damage breakable brushes with fists return; } } } if (targ && targ->client && targ->client->ps.duelInProgress) { if (attacker && attacker->client && attacker->s.number != targ->client->ps.duelIndex) { return; } else if (attacker && attacker->client && mod != MOD_SABER) { return; } } if (attacker && attacker->client && attacker->client->ps.duelInProgress) { if (targ && targ->client && targ->s.number != attacker->client->ps.duelIndex) { return; } else if (targ && targ->client && mod != MOD_SABER) { return; } } if ( !(dflags & DAMAGE_NO_PROTECTION) ) {//rage overridden by no_protection if (targ && targ->client && (targ->client->ps.fd.forcePowersActive & (1 << FP_RAGE))) { damage *= 0.5; } } // the intermission has allready been qualified for, so don't // allow any extra scoring if ( level.intermissionQueued ) { return; } if ( !inflictor ) { inflictor = &g_entities[ENTITYNUM_WORLD]; } if ( !attacker ) { attacker = &g_entities[ENTITYNUM_WORLD]; } // shootable doors / buttons don't actually have any health //if genericValue4 == 1 then it's glass or a breakable and those do have health if ( targ->s.eType == ET_MOVER && targ->genericValue4 != 1 ) { if ( targ->use && targ->moverState == MOVER_POS1 ) { GlobalUse( targ, inflictor, attacker ); } return; } // reduce damage by the attacker's handicap value // unless they are rocket jumping if ( attacker->client && attacker != targ && attacker->s.eType == ET_PLAYER && g_gametype.integer != GT_SIEGE ) { max = attacker->client->ps.stats[STAT_MAX_HEALTH]; damage = damage * max / 100; } if ( !(dflags&DAMAGE_NO_HIT_LOC) ) {//see if we should modify it by damage location if (targ->inuse && (targ->client || targ->s.eType == ET_NPC) && attacker->inuse && (attacker->client || attacker->s.eType == ET_NPC)) { //check for location based damage stuff. G_LocationBasedDamageModifier(targ, point, mod, dflags, &damage); } } if ( targ->client && targ->client->NPC_class == CLASS_RANCOR && (!attacker||!attacker->client||attacker->client->NPC_class!=CLASS_RANCOR) ) { // I guess always do 10 points of damage...feel free to tweak as needed if ( damage < 10 ) {//ignore piddly little damage damage = 0; } else if ( damage >= 10 ) { damage = 10; } } client = targ->client; if ( client ) { if ( client->noclip ) { return; } } if ( !dir ) { dflags |= DAMAGE_NO_KNOCKBACK; } else { VectorNormalize(dir); } knockback = damage; if ( knockback > 200 ) { knockback = 200; } if ( targ->flags & FL_NO_KNOCKBACK ) { knockback = 0; } if ( dflags & DAMAGE_NO_KNOCKBACK ) { knockback = 0; } // figure momentum add, even if the damage won't be taken if ( knockback && targ->client ) { vec3_t kvel; float mass; mass = 200; if (mod == MOD_SABER) { float saberKnockbackScale = g_saberDmgVelocityScale.value; if ( (dflags&DAMAGE_SABER_KNOCKBACK1) || (dflags&DAMAGE_SABER_KNOCKBACK2) ) {//saber does knockback, scale it by the right number if ( !saberKnockbackScale ) { saberKnockbackScale = 1.0f; } if ( attacker && attacker->client ) { if ( (dflags&DAMAGE_SABER_KNOCKBACK1) ) { if ( attacker && attacker->client ) { saberKnockbackScale *= attacker->client->saber[0].knockbackScale; } } if ( (dflags&DAMAGE_SABER_KNOCKBACK1_B2) ) { if ( attacker && attacker->client ) { saberKnockbackScale *= attacker->client->saber[0].knockbackScale2; } } if ( (dflags&DAMAGE_SABER_KNOCKBACK2) ) { if ( attacker && attacker->client ) { saberKnockbackScale *= attacker->client->saber[1].knockbackScale; } } if ( (dflags&DAMAGE_SABER_KNOCKBACK2_B2) ) { if ( attacker && attacker->client ) { saberKnockbackScale *= attacker->client->saber[1].knockbackScale2; } } } } VectorScale (dir, (g_knockback.value * (float)knockback / mass)*saberKnockbackScale, kvel); } else { VectorScale (dir, g_knockback.value * (float)knockback / mass, kvel); } VectorAdd (targ->client->ps.velocity, kvel, targ->client->ps.velocity); if (attacker && attacker->client && attacker != targ) { float dur = 5000; float dur2 = 100; if (targ->client && targ->s.eType == ET_NPC && targ->s.NPC_class == CLASS_VEHICLE) { dur = 25000; dur2 = 25000; } targ->client->ps.otherKiller = attacker->s.number; targ->client->ps.otherKillerTime = level.time + dur; targ->client->ps.otherKillerDebounceTime = level.time + dur2; } // set the timer so that the other client can't cancel // out the movement immediately if ( !targ->client->ps.pm_time && (g_saberDmgVelocityScale.integer || mod != MOD_SABER || (dflags&DAMAGE_SABER_KNOCKBACK1) || (dflags&DAMAGE_SABER_KNOCKBACK2) || (dflags&DAMAGE_SABER_KNOCKBACK1_B2) || (dflags&DAMAGE_SABER_KNOCKBACK2_B2) ) ) { int t; t = knockback * 2; if ( t < 50 ) { t = 50; } if ( t > 200 ) { t = 200; } targ->client->ps.pm_time = t; targ->client->ps.pm_flags |= PMF_TIME_KNOCKBACK; } } else if (targ->client && targ->s.eType == ET_NPC && targ->s.NPC_class == CLASS_VEHICLE && attacker != targ) { targ->client->ps.otherKiller = attacker->s.number; targ->client->ps.otherKillerTime = level.time + 25000; targ->client->ps.otherKillerDebounceTime = level.time + 25000; } if ( (g_trueJedi.integer || g_gametype.integer == GT_SIEGE) && client ) {//less explosive damage for jedi, more saber damage for non-jedi if ( client->ps.trueJedi || (g_gametype.integer == GT_SIEGE&&client->ps.weapon == WP_SABER)) {//if the target is a trueJedi, reduce splash and explosive damage to 1/2 switch ( mod ) { case MOD_REPEATER_ALT: case MOD_REPEATER_ALT_SPLASH: case MOD_DEMP2_ALT: case MOD_FLECHETTE_ALT_SPLASH: case MOD_ROCKET: case MOD_ROCKET_SPLASH: case MOD_ROCKET_HOMING: case MOD_ROCKET_HOMING_SPLASH: case MOD_THERMAL: case MOD_THERMAL_SPLASH: case MOD_TRIP_MINE_SPLASH: case MOD_TIMED_MINE_SPLASH: case MOD_DET_PACK_SPLASH: damage *= 0.75; break; } } else if ( (client->ps.trueNonJedi || (g_gametype.integer == GT_SIEGE&&client->ps.weapon != WP_SABER)) && mod == MOD_SABER ) {//if the target is a trueNonJedi, take more saber damage... combined with the 1.5 in the w_saber stuff, this is 6 times damage! if ( damage < 100 ) { damage *= 4; if ( damage > 100 ) { damage = 100; } } } } if (attacker->client && targ->client && g_gametype.integer == GT_SIEGE && targ->client->siegeClass != -1 && (bgSiegeClasses[targ->client->siegeClass].classflags & (1<<CFL_STRONGAGAINSTPHYSICAL))) { //this class is flagged to take less damage from physical attacks. //For now I'm just decreasing against any client-based attack, this can be changed later I guess. damage *= 0.5; } // check for completely getting out of the damage if ( !(dflags & DAMAGE_NO_PROTECTION) ) { // if TF_NO_FRIENDLY_FIRE is set, don't do damage to the target // if the attacker was on the same team if ( targ != attacker) { if (OnSameTeam (targ, attacker)) { if ( !g_friendlyFire.integer ) { return; } } else if (attacker && attacker->inuse && !attacker->client && attacker->activator && targ != attacker->activator && attacker->activator->inuse && attacker->activator->client) { //emplaced guns don't hurt teammates of user if (OnSameTeam (targ, attacker->activator)) { if ( !g_friendlyFire.integer ) { return; } } } else if (targ->inuse && targ->client && g_gametype.integer >= GT_TEAM && attacker->s.number >= MAX_CLIENTS && attacker->alliedTeam && targ->client->sess.sessionTeam == attacker->alliedTeam && !g_friendlyFire.integer) { //things allied with my team should't hurt me.. I guess return; } } if (g_gametype.integer == GT_JEDIMASTER && !g_friendlyFire.integer && targ && targ->client && attacker && attacker->client && targ != attacker && !targ->client->ps.isJediMaster && !attacker->client->ps.isJediMaster && G_ThereIsAMaster()) { return; } if (targ->s.number >= MAX_CLIENTS && targ->client && targ->s.shouldtarget && targ->s.teamowner && attacker && attacker->inuse && attacker->client && targ->s.owner >= 0 && targ->s.owner < MAX_CLIENTS) { gentity_t *targown = &g_entities[targ->s.owner]; if (targown && targown->inuse && targown->client && OnSameTeam(targown, attacker)) { if (!g_friendlyFire.integer) { return; } } } // check for godmode if ( (targ->flags & FL_GODMODE) && targ->s.eType != ET_NPC ) { return; } if (targ && targ->client && (targ->client->ps.eFlags & EF_INVULNERABLE) && attacker && attacker->client && targ != attacker) { if (targ->client->invulnerableTimer <= level.time) { targ->client->ps.eFlags &= ~EF_INVULNERABLE; } else { return; } } } //check for teamnodmg //NOTE: non-client objects hitting clients (and clients hitting clients) purposely doesn't obey this teamnodmg (for emplaced guns) if ( attacker && !targ->client ) {//attacker hit a non-client if ( g_gametype.integer == GT_SIEGE && !g_ff_objectives.integer ) {//in siege mode (and...?) if ( targ->teamnodmg ) {//targ shouldn't take damage from a certain team if ( attacker->client ) {//a client hit a non-client object if ( targ->teamnodmg == attacker->client->sess.sessionTeam ) { return; } } else if ( attacker->teamnodmg ) {//a non-client hit a non-client object //FIXME: maybe check alliedTeam instead? if ( targ->teamnodmg == attacker->teamnodmg ) { if (attacker->activator && attacker->activator->inuse && attacker->activator->s.number < MAX_CLIENTS && attacker->activator->client && attacker->activator->client->sess.sessionTeam != targ->teamnodmg) { //uh, let them damage it I guess. } else { return; } } } } } } // battlesuit protects from all radius damage (but takes knockback) // and protects 50% against all damage if ( client && client->ps.powerups[PW_BATTLESUIT] ) { G_AddEvent( targ, EV_POWERUP_BATTLESUIT, 0 ); if ( ( dflags & DAMAGE_RADIUS ) || ( mod == MOD_FALLING ) ) { return; } damage *= 0.5; } // add to the attacker's hit counter (if the target isn't a general entity like a prox mine) if ( attacker->client && targ != attacker && targ->health > 0 && targ->s.eType != ET_MISSILE && targ->s.eType != ET_GENERAL && client) { if ( OnSameTeam( targ, attacker ) ) { attacker->client->ps.persistant[PERS_HITS]--; } else { attacker->client->ps.persistant[PERS_HITS]++; } attacker->client->ps.persistant[PERS_ATTACKEE_ARMOR] = (targ->health<<8)|(client->ps.stats[STAT_ARMOR]); } // always give half damage if hurting self... but not in siege. Heavy weapons need a counter. // calculated after knockback, so rocket jumping works if ( targ == attacker && !(dflags & DAMAGE_NO_SELF_PROTECTION)) { if ( g_gametype.integer == GT_SIEGE ) { damage *= 1.5; } else { damage *= 0.5; } } if ( damage < 1 ) { damage = 1; } take = damage; save = 0; // save some from armor asave = CheckArmor (targ, take, dflags); if (asave) { shieldAbsorbed = asave; } take -= asave; if ( targ->client ) {//update vehicle shields and armor, check for explode if ( targ->client->NPC_class == CLASS_VEHICLE && targ->m_pVehicle ) {//FIXME: should be in its own function in g_vehicles.c now, too big to be here int surface = -1; if ( attacker ) {//so we know the last guy who shot at us targ->enemy = attacker; } if ( ( targ->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL ) ) { //((CVehicleNPC *)targ->NPC)->m_ulFlags |= CVehicleNPC::VEH_BUCKING; } targ->m_pVehicle->m_iShields = targ->client->ps.stats[STAT_ARMOR]; G_VehUpdateShields( targ ); targ->m_pVehicle->m_iArmor -= take; if ( targ->m_pVehicle->m_iArmor <= 0 ) { targ->s.eFlags |= EF_DEAD; targ->client->ps.eFlags |= EF_DEAD; targ->m_pVehicle->m_iArmor = 0; } if ( targ->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER ) {//get the last surf that was hit if ( targ->client && targ->client->g2LastSurfaceTime == level.time) { char hitSurface[MAX_QPATH]; trap_G2API_GetSurfaceName(targ->ghoul2, targ->client->g2LastSurfaceHit, 0, hitSurface); if (hitSurface[0]) { surface = G_ShipSurfaceForSurfName( &hitSurface[0] ); if ( take && surface > 0 ) {//hit a certain part of the ship int deathPoint = 0; targ->locationDamage[surface] += take; switch(surface) { case SHIPSURF_FRONT: deathPoint = targ->m_pVehicle->m_pVehicleInfo->health_front; break; case SHIPSURF_BACK: deathPoint = targ->m_pVehicle->m_pVehicleInfo->health_back; break; case SHIPSURF_RIGHT: deathPoint = targ->m_pVehicle->m_pVehicleInfo->health_right; break; case SHIPSURF_LEFT: deathPoint = targ->m_pVehicle->m_pVehicleInfo->health_left; break; default: break; } //presume 0 means it wasn't set and so it should never die. if ( deathPoint ) { if ( targ->locationDamage[surface] >= deathPoint) { //this area of the ship is now dead if ( G_FlyVehicleDestroySurface( targ, surface ) ) {//actually took off a surface G_VehicleSetDamageLocFlags( targ, surface, deathPoint ); } } else { G_VehicleSetDamageLocFlags( targ, surface, deathPoint ); } } } } } } if ( targ->m_pVehicle->m_pVehicleInfo->type != VH_ANIMAL ) { /* if ( targ->m_pVehicle->m_iArmor <= 0 ) {//vehicle all out of armor Vehicle_t *pVeh = targ->m_pVehicle; if ( pVeh->m_iDieTime == 0 ) {//just start the flaming effect and explosion delay, if it's not going already... pVeh->m_pVehicleInfo->StartDeathDelay( pVeh, 0 ); } } else*/ if ( attacker //&& attacker->client && targ != attacker && point && !VectorCompare( targ->client->ps.origin, point ) && targ->m_pVehicle->m_LandTrace.fraction >= 1.0f) {//just took a hit, knock us around vec3_t vUp, impactDir; float impactStrength = (damage/200.0f)*10.0f; float dot = 0.0f; if ( impactStrength > 10.0f ) { impactStrength = 10.0f; } //pitch or roll us based on where we were hit AngleVectors( targ->m_pVehicle->m_vOrientation, NULL, NULL, vUp ); VectorSubtract( point, targ->r.currentOrigin, impactDir ); VectorNormalize( impactDir ); if ( surface <= 0 ) {//no surf guess where we were hit, then vec3_t vFwd, vRight; AngleVectors( targ->m_pVehicle->m_vOrientation, vFwd, vRight, vUp ); dot = DotProduct( vRight, impactDir ); if ( dot > 0.4f ) { surface = SHIPSURF_RIGHT; } else if ( dot < -0.4f ) { surface = SHIPSURF_LEFT; } else { dot = DotProduct( vFwd, impactDir ); if ( dot > 0.0f ) { surface = SHIPSURF_FRONT; } else { surface = SHIPSURF_BACK; } } } switch ( surface ) { case SHIPSURF_FRONT: dot = DotProduct( vUp, impactDir ); if ( dot > 0 ) { targ->m_pVehicle->m_vOrientation[PITCH] += impactStrength; } else { targ->m_pVehicle->m_vOrientation[PITCH] -= impactStrength; } break; case SHIPSURF_BACK: dot = DotProduct( vUp, impactDir ); if ( dot > 0 ) { targ->m_pVehicle->m_vOrientation[PITCH] -= impactStrength; } else { targ->m_pVehicle->m_vOrientation[PITCH] += impactStrength; } break; case SHIPSURF_RIGHT: dot = DotProduct( vUp, impactDir ); if ( dot > 0 ) { targ->m_pVehicle->m_vOrientation[ROLL] -= impactStrength; } else { targ->m_pVehicle->m_vOrientation[ROLL] += impactStrength; } break; case SHIPSURF_LEFT: dot = DotProduct( vUp, impactDir ); if ( dot > 0 ) { targ->m_pVehicle->m_vOrientation[ROLL] += impactStrength; } else { targ->m_pVehicle->m_vOrientation[ROLL] -= impactStrength; } break; } } } } } if ( mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT ) {//FIXME: screw with non-animal vehicles, too? if ( client ) { if ( client->NPC_class == CLASS_VEHICLE && targ->m_pVehicle && targ->m_pVehicle->m_pVehicleInfo && targ->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER ) {//all damage goes into the disruption of shields and systems take = 0; } else { if (client->jetPackOn) { //disable jetpack temporarily Jetpack_Off(targ); client->jetPackToggleTime = level.time + Q_irand(3000, 10000); } if ( client->NPC_class == CLASS_PROTOCOL || client->NPC_class == CLASS_SEEKER || client->NPC_class == CLASS_R2D2 || client->NPC_class == CLASS_R5D2 || client->NPC_class == CLASS_MOUSE || client->NPC_class == CLASS_GONK ) { // DEMP2 does more damage to these guys. take *= 2; } else if ( client->NPC_class == CLASS_PROBE || client->NPC_class == CLASS_INTERROGATOR || client->NPC_class == CLASS_MARK1 || client->NPC_class == CLASS_MARK2 || client->NPC_class == CLASS_SENTRY || client->NPC_class == CLASS_ATST ) { // DEMP2 does way more damage to these guys. take *= 5; } else { if (take > 0) { take /= 3; if (take < 1) { take = 1; } } } } } } #ifndef FINAL_BUILD if ( g_debugDamage.integer ) { G_Printf( "%i: client:%i health:%i damage:%i armor:%i\n", level.time, targ->s.number, targ->health, take, asave ); } #endif // add to the damage inflicted on a player this frame // the total will be turned into screen blends and view angle kicks // at the end of the frame if ( client ) { if ( attacker ) { client->ps.persistant[PERS_ATTACKER] = attacker->s.number; } else { client->ps.persistant[PERS_ATTACKER] = ENTITYNUM_WORLD; } client->damage_armor += asave; client->damage_blood += take; client->damage_knockback += knockback; if ( dir ) { VectorCopy ( dir, client->damage_from ); client->damage_fromWorld = qfalse; } else { VectorCopy ( targ->r.currentOrigin, client->damage_from ); client->damage_fromWorld = qtrue; } if (attacker && attacker->client) { BotDamageNotification(client, attacker); } else if (inflictor && inflictor->client) { BotDamageNotification(client, inflictor); } } // See if it's the player hurting the emeny flag carrier if( g_gametype.integer == GT_CTF || g_gametype.integer == GT_CTY) { Team_CheckHurtCarrier(targ, attacker); } if (targ->client) { // set the last client who damaged the target targ->client->lasthurt_client = attacker->s.number; targ->client->lasthurt_mod = mod; } if ( !(dflags & DAMAGE_NO_PROTECTION) ) {//protect overridden by no_protection if (take && targ->client && (targ->client->ps.fd.forcePowersActive & (1 << FP_PROTECT))) { if (targ->client->ps.fd.forcePower) { int maxtake = take; //G_Sound(targ, CHAN_AUTO, protectHitSound); if (targ->client->forcePowerSoundDebounce < level.time) { G_PreDefSound(targ->client->ps.origin, PDSOUND_PROTECTHIT); targ->client->forcePowerSoundDebounce = level.time + 400; } if (targ->client->ps.fd.forcePowerLevel[FP_PROTECT] == FORCE_LEVEL_1) { famt = 1; hamt = 0.40; if (maxtake > 100) { maxtake = 100; } } else if (targ->client->ps.fd.forcePowerLevel[FP_PROTECT] == FORCE_LEVEL_2) { famt = 0.5; hamt = 0.60; if (maxtake > 200) { maxtake = 200; } } else if (targ->client->ps.fd.forcePowerLevel[FP_PROTECT] == FORCE_LEVEL_3) { famt = 0.25; hamt = 0.80; if (maxtake > 400) { maxtake = 400; } } if (!targ->client->ps.powerups[PW_FORCE_BOON]) { targ->client->ps.fd.forcePower -= maxtake*famt; } else { targ->client->ps.fd.forcePower -= (maxtake*famt)/2; } subamt = (maxtake*hamt)+(take-maxtake); if (targ->client->ps.fd.forcePower < 0) { subamt += targ->client->ps.fd.forcePower; targ->client->ps.fd.forcePower = 0; } if (subamt) { take -= subamt; if (take < 0) { take = 0; } } } } } if (shieldAbsorbed) { /* if ( targ->client->NPC_class == CLASS_VEHICLE ) { targ->client->ps.electrifyTime = level.time + Q_irand( 500, 1000 ); } else */ { gentity_t *evEnt; // Send off an event to show a shield shell on the player, pointing in the right direction. //evEnt = G_TempEntity(vec3_origin, EV_SHIELD_HIT); //rww - er.. what the? This isn't broadcast, why is it being set on vec3_origin?! evEnt = G_TempEntity(targ->r.currentOrigin, EV_SHIELD_HIT); evEnt->s.otherEntityNum = targ->s.number; evEnt->s.eventParm = DirToByte(dir); evEnt->s.time2=shieldAbsorbed; /* shieldAbsorbed *= 20; if (shieldAbsorbed > 1500) { shieldAbsorbed = 1500; } if (shieldAbsorbed < 200) { shieldAbsorbed = 200; } if (targ->client->ps.powerups[PW_SHIELDHIT] < (level.time + shieldAbsorbed)) { targ->client->ps.powerups[PW_SHIELDHIT] = level.time + shieldAbsorbed; } //flicker for as many ms as damage was absorbed (*20) //therefore 10 damage causes 1/5 of a seond of flickering, whereas //a full 100 causes 2 seconds (but is reduced to 1.5 seconds due to the max) */ } } // do the damage if (take) { if (targ->client && targ->s.number < MAX_CLIENTS && (mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT)) { //uh.. shock them or something. what the hell, I don't know. if (targ->client->ps.weaponTime <= 0) { //yeah, we were supposed to be beta a week ago, I don't feel like //breaking the game so I'm gonna be safe and only do this only //if your weapon is not busy targ->client->ps.weaponTime = 2000; targ->client->ps.electrifyTime = level.time + 2000; if (targ->client->ps.weaponstate == WEAPON_CHARGING || targ->client->ps.weaponstate == WEAPON_CHARGING_ALT) { targ->client->ps.weaponstate = WEAPON_READY; } } } if ( !(dflags & DAMAGE_NO_PROTECTION) ) {//rage overridden by no_protection if (targ->client && (targ->client->ps.fd.forcePowersActive & (1 << FP_RAGE)) && (inflictor->client || attacker->client)) { take /= (targ->client->ps.fd.forcePowerLevel[FP_RAGE]+1); } } targ->health = targ->health - take; if ( (targ->flags&FL_UNDYING) ) {//take damage down to 1, but never die if ( targ->health < 1 ) { targ->health = 1; } } if ( targ->client ) { targ->client->ps.stats[STAT_HEALTH] = targ->health; } if ( !(dflags & DAMAGE_NO_PROTECTION) ) {//rage overridden by no_protection if (targ->client && (targ->client->ps.fd.forcePowersActive & (1 << FP_RAGE)) && (inflictor->client || attacker->client)) { if (targ->health <= 0) { targ->health = 1; } if (targ->client->ps.stats[STAT_HEALTH] <= 0) { targ->client->ps.stats[STAT_HEALTH] = 1; } } } //We want to go ahead and set gPainHitLoc regardless of if we have a pain func, //so we can adjust the location damage too. if (targ->client && targ->ghoul2 && targ->client->g2LastSurfaceTime == level.time) { //We updated the hit surface this frame, so it's valid. char hitSurface[MAX_QPATH]; trap_G2API_GetSurfaceName(targ->ghoul2, targ->client->g2LastSurfaceHit, 0, hitSurface); if (hitSurface[0]) { G_GetHitLocFromSurfName(targ, hitSurface, &gPainHitLoc, point, dir, vec3_origin, mod); } else { gPainHitLoc = -1; } if (gPainHitLoc < HL_MAX && gPainHitLoc >= 0 && targ->locationDamage[gPainHitLoc] < Q3_INFINITE && (targ->s.eType == ET_PLAYER || targ->s.NPC_class != CLASS_VEHICLE)) { targ->locationDamage[gPainHitLoc] += take; if (g_armBreakage.integer && !targ->client->ps.brokenLimbs && targ->client->ps.stats[STAT_HEALTH] > 0 && targ->health > 0 && !(targ->s.eFlags & EF_DEAD)) { //check for breakage if (targ->locationDamage[HL_ARM_RT]+targ->locationDamage[HL_HAND_RT] >= 80) { G_BreakArm(targ, BROKENLIMB_RARM); } else if (targ->locationDamage[HL_ARM_LT]+targ->locationDamage[HL_HAND_LT] >= 80) { G_BreakArm(targ, BROKENLIMB_LARM); } } } } else { gPainHitLoc = -1; } if (targ->maxHealth) { //if this is non-zero this guy should be updated his s.health to send to the client G_ScaleNetHealth(targ); } if ( targ->health <= 0 ) { if ( client ) { targ->flags |= FL_NO_KNOCKBACK; if (point) { VectorCopy( point, targ->pos1 ); } else { VectorCopy(targ->client->ps.origin, targ->pos1); } } else if (targ->s.eType == ET_NPC) { //g2animent VectorCopy(point, targ->pos1); } if (targ->health < -999) targ->health = -999; // If we are a breaking glass brush, store the damage point so we can do cool things with it. if ( targ->r.svFlags & SVF_GLASS_BRUSH ) { VectorCopy( point, targ->pos1 ); if (dir) { VectorCopy( dir, targ->pos2 ); } else { VectorClear(targ->pos2); } } if (targ->s.eType == ET_NPC && targ->client && (targ->s.eFlags & EF_DEAD)) { //an NPC that's already dead. Maybe we can cut some more limbs off! if ( (mod == MOD_SABER || (mod == MOD_MELEE && G_HeavyMelee( attacker )) )//saber or heavy melee (claws) && take > 2 && !(dflags&DAMAGE_NO_DISMEMBER) ) { G_CheckForDismemberment(targ, attacker, targ->pos1, take, targ->client->ps.torsoAnim, qtrue); } } targ->enemy = attacker; targ->die (targ, inflictor, attacker, take, mod); G_ActivateBehavior( targ, BSET_DEATH ); return; } else { if ( g_debugMelee.integer ) {//getting hurt makes you let go of the wall if ( targ->client && (targ->client->ps.pm_flags&PMF_STUCK_TO_WALL) ) { G_LetGoOfWall( targ ); } } if ( targ->pain ) { if (targ->s.eType != ET_NPC || mod != MOD_SABER || take > 1) { //don't even notify NPCs of pain if it's just idle saber damage gPainMOD = mod; if (point) { VectorCopy(point, gPainPoint); } else { VectorCopy(targ->r.currentOrigin, gPainPoint); } targ->pain (targ, attacker, take); } } } G_LogWeaponDamage(attacker->s.number, mod, take); } }

void G_DeathAlert (  gentity_t *  victim, gentity_t *  attacker )

Definition at line 1868 of file g_combat.c. References DEATH_ALERT_RADIUS, DEATH_ALERT_SOUND_RADIUS, G_AlertTeam(), and gentity_t. Referenced by player_die(). {//FIXME: with all the other alert stuff, do we really need this? G_AlertTeam( victim, attacker, DEATH_ALERT_RADIUS, DEATH_ALERT_SOUND_RADIUS ); }

void G_Dismember (  gentity_t *  ent, gentity_t *  enemy, vec3_t  point, int  limbType, float  limbRollBase, float  limbPitchBase, int  deathAnim, qboolean  postDeath )

Definition at line 3311 of file g_combat.c. References entityState_s::apos, BG_GetRootSurfNameWithVariant(), BG_InDeathAnim(), gentity_s::classname, gentity_s::client, gentity_s::clipmask, Com_sprintf(), entityShared_t::contents, CONTENTS_TRIGGER, entityShared_t::currentAngles, entityShared_t::currentOrigin, entityState_s::customRGBA, gentity_s::epGravFactor, gentity_s::epVelocity, ET_GENERAL, ET_NPC, entityState_s::eType, FRAMETIME, G2_MODEL_PART, G2_MODELPART_HEAD, G2_MODELPART_LARM, G2_MODELPART_LLEG, G2_MODELPART_RARM, G2_MODELPART_RHAND, G2_MODELPART_RLEG, G2_MODELPART_WAIST, entityState_s::g2radius, G_SetOrigin(), G_Spawn(), gentity_t, gentity_s::ghoul2, gclient_s::lastSaberBase_Always, gclient_s::lastSaberStorageTime, level, LimbThink(), LimbTouch(), MASK_SOLID, MAX_QPATH, entityShared_t::maxs, entityShared_t::mins, entityState_s::modelGhoul2, entityState_s::modelindex, gentity_s::nextthink, entityState_s::number, gclient_s::olderIsValid, gclient_s::olderSaberBase, entityState_s::otherEntityNum2, gentity_s::physicsObject, entityState_s::pos, gclient_s::ps, Q_irand(), Q_strncpyz(), qtrue, gentity_s::r, gentity_s::s, gentity_s::speed, SVF_USE_CURRENT_ORIGIN, entityShared_t::svFlags, gentity_s::think, level_locals_t::time, playerState_s::torsoAnim, playerState_s::torsoTimer, gentity_s::touch, trap_G2API_GetSurfaceRenderStatus(), trap_G2API_SetSurfaceOnOff(), trap_LinkEntity(), trajectory_t::trBase, trajectory_t::trDelta, vec3_t, VectorAdd, VectorClear, VectorCopy, VectorMA, VectorNormalize(), VectorScale, VectorSet, VectorSubtract, playerState_s::velocity, playerState_s::viewangles, entityState_s::weapon, playerState_s::weapon, and WP_SABER. Referenced by DismembermentByNum(), DismembermentTest(), G_CheckForDismemberment(), Rancor_Attack(), Rancor_Bite(), and Wampa_Slash(). { vec3_t newPoint, dir, vel; gentity_t *limb; char limbName[MAX_QPATH]; char stubName[MAX_QPATH]; char stubCapName[MAX_QPATH]; if (limbType == G2_MODELPART_HEAD) { Q_strncpyz( limbName , "head", sizeof( limbName ) ); Q_strncpyz( stubCapName, "torso_cap_head", sizeof( stubCapName ) ); } else if (limbType == G2_MODELPART_WAIST) { Q_strncpyz( limbName, "torso", sizeof( limbName ) ); Q_strncpyz( stubCapName, "hips_cap_torso", sizeof( stubCapName ) ); } else if (limbType == G2_MODELPART_LARM) { BG_GetRootSurfNameWithVariant( ent->ghoul2, "l_arm", limbName, sizeof(limbName) ); BG_GetRootSurfNameWithVariant( ent->ghoul2, "torso", stubName, sizeof(stubName) ); Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_l_arm", stubName ); } else if (limbType == G2_MODELPART_RARM) { BG_GetRootSurfNameWithVariant( ent->ghoul2, "r_arm", limbName, sizeof(limbName) ); BG_GetRootSurfNameWithVariant( ent->ghoul2, "torso", stubName, sizeof(stubName) ); Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_arm", stubName ); } else if (limbType == G2_MODELPART_RHAND) { BG_GetRootSurfNameWithVariant( ent->ghoul2, "r_hand", limbName, sizeof(limbName) ); BG_GetRootSurfNameWithVariant( ent->ghoul2, "r_arm", stubName, sizeof(stubName) ); Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_hand", stubName ); } else if (limbType == G2_MODELPART_LLEG) { BG_GetRootSurfNameWithVariant( ent->ghoul2, "l_leg", limbName, sizeof(limbName) ); BG_GetRootSurfNameWithVariant( ent->ghoul2, "hips", stubName, sizeof(stubName) ); Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_l_leg", stubName ); } else if (limbType == G2_MODELPART_RLEG) { BG_GetRootSurfNameWithVariant( ent->ghoul2, "r_leg", limbName, sizeof(limbName) ); BG_GetRootSurfNameWithVariant( ent->ghoul2, "hips", stubName, sizeof(stubName) ); Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_leg", stubName ); } else {//umm... just default to the right leg, I guess (same as on client) BG_GetRootSurfNameWithVariant( ent->ghoul2, "r_leg", limbName, sizeof(limbName) ); BG_GetRootSurfNameWithVariant( ent->ghoul2, "hips", stubName, sizeof(stubName) ); Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_leg", stubName ); } if (ent->ghoul2 && limbName && trap_G2API_GetSurfaceRenderStatus(ent->ghoul2, 0, limbName)) { //is it already off? If so there's no reason to be doing it again, so get out of here. return; } VectorCopy( point, newPoint ); limb = G_Spawn(); limb->classname = "playerlimb"; /* if (limbType == G2_MODELPART_WAIST) { //slight hack newPoint[2] += 1; } */ G_SetOrigin( limb, newPoint ); VectorCopy( newPoint, limb->s.pos.trBase ); limb->think = LimbThink; limb->touch = LimbTouch; limb->speed = level.time + Q_irand(8000, 16000); limb->nextthink = level.time + FRAMETIME; limb->r.svFlags = SVF_USE_CURRENT_ORIGIN; limb->clipmask = MASK_SOLID; limb->r.contents = CONTENTS_TRIGGER; limb->physicsObject = qtrue; VectorSet( limb->r.mins, -6.0f, -6.0f, -3.0f ); VectorSet( limb->r.maxs, 6.0f, 6.0f, 6.0f ); limb->s.g2radius = 200; limb->s.eType = ET_GENERAL; limb->s.weapon = G2_MODEL_PART; limb->s.modelGhoul2 = limbType; limb->s.modelindex = ent->s.number; if (!ent->client) { limb->s.modelindex = -1; limb->s.otherEntityNum2 = ent->s.number; } VectorClear(limb->s.apos.trDelta); if (ent->client) { VectorCopy(ent->client->ps.viewangles, limb->r.currentAngles); VectorCopy(ent->client->ps.viewangles, limb->s.apos.trBase); } else { VectorCopy(ent->r.currentAngles, limb->r.currentAngles); VectorCopy(ent->r.currentAngles, limb->s.apos.trBase); } //Set up the ExPhys values for the entity. limb->epGravFactor = 0; VectorClear(limb->epVelocity); VectorSubtract( point, ent->r.currentOrigin, dir ); VectorNormalize( dir ); if (ent->client) { VectorCopy(ent->client->ps.velocity, vel); } else { VectorCopy(ent->s.pos.trDelta, vel); } VectorMA( vel, 80, dir, limb->epVelocity ); //add some vertical velocity if (limbType == G2_MODELPART_HEAD || limbType == G2_MODELPART_WAIST) { limb->epVelocity[2] += 10; } if (enemy && enemy->client && ent && ent != enemy && ent->s.number != enemy->s.number && enemy->client->ps.weapon == WP_SABER && enemy->client->olderIsValid && (level.time - enemy->client->lastSaberStorageTime) < 200) { //The enemy has valid saber positions between this and last frame. Use them to factor in direction of the limb. vec3_t dif; float totalDistance; const float distScale = 1.2f; //scale down the initial velocity first, which is based on the speed of the limb owner. //ExPhys object velocity operates on a slightly different scale than Q3-based physics velocity. VectorScale(limb->epVelocity, 0.4f, limb->epVelocity); VectorSubtract(enemy->client->lastSaberBase_Always, enemy->client->olderSaberBase, dif); totalDistance = VectorNormalize(dif); VectorScale(dif, totalDistance*distScale, dif); VectorAdd(limb->epVelocity, dif, limb->epVelocity); if (ent->client && (ent->client->ps.torsoTimer > 0 || !BG_InDeathAnim(ent->client->ps.torsoAnim))) { //if he's done with his death anim we don't actually want the limbs going far vec3_t preVel; VectorCopy(limb->epVelocity, preVel); preVel[2] = 0; totalDistance = VectorNormalize(preVel); if (totalDistance < 40.0f) { float mAmt = 40.0f;//60.0f/totalDistance; limb->epVelocity[0] = preVel[0]*mAmt; limb->epVelocity[1] = preVel[1]*mAmt; } } else if (ent->client) { VectorScale(limb->epVelocity, 0.3f, limb->epVelocity); } } if (ent->s.eType == ET_NPC && ent->ghoul2 && limbName && stubCapName) { //if it's an npc remove these surfs on the server too. For players we don't even care cause there's no further dismemberment after death. trap_G2API_SetSurfaceOnOff(ent->ghoul2, limbName, 0x00000100); trap_G2API_SetSurfaceOnOff(ent->ghoul2, stubCapName, 0); } limb->s.customRGBA[0] = ent->s.customRGBA[0]; limb->s.customRGBA[1] = ent->s.customRGBA[1]; limb->s.customRGBA[2] = ent->s.customRGBA[2]; limb->s.customRGBA[3] = ent->s.customRGBA[3]; trap_LinkEntity( limb ); }

qboolean G_FlyVehicleDestroySurface (  gentity_t *  veh, int  surface )

Referenced by G_Damage().

void G_GetDismemberBolt (  gentity_t *  self, vec3_t  boltPoint, int  limbType )

Definition at line 3139 of file g_combat.c. References entityState_s::angles, gentity_s::client, ENTITYNUM_NONE, EV_SABER_HIT, entityState_s::eventParm, G2_MODELPART_HEAD, G2_MODELPART_LARM, G2_MODELPART_LLEG, G2_MODELPART_RARM, G2_MODELPART_RHAND, G2_MODELPART_RLEG, G2_MODELPART_WAIST, G_TempEntity(), gentity_s::genericValue5, gentity_t, gentity_s::ghoul2, entityState_s::legsAnim, level, gentity_s::localAnimIndex, mdxaBone_t::matrix, gentity_s::modelScale, NULL, entityState_s::number, entityState_s::origin, playerState_s::origin, entityState_s::otherEntityNum, entityState_s::otherEntityNum2, gclient_s::ps, gentity_s::s, level_locals_t::time, trap_G2API_AddBolt(), trap_G2API_GetBoltMatrix(), vec3_t, VectorCopy, VectorNormalize(), playerState_s::velocity, playerState_s::viewangles, entityState_s::weapon, and YAW. Referenced by DismembermentByNum(), DismembermentTest(), and G_CheckForDismemberment(). { int useBolt = self->genericValue5; vec3_t properOrigin, properAngles, addVel; //vec3_t legAxis[3]; mdxaBone_t boltMatrix; float fVSpeed = 0; char *rotateBone = NULL; switch (limbType) { case G2_MODELPART_HEAD: rotateBone = "cranium"; break; case G2_MODELPART_WAIST: if (self->localAnimIndex <= 1) { //humanoid rotateBone = "thoracic"; } else { rotateBone = "pelvis"; } break; case G2_MODELPART_LARM: rotateBone = "lradius"; break; case G2_MODELPART_RARM: rotateBone = "rradius"; break; case G2_MODELPART_RHAND: rotateBone = "rhand"; break; case G2_MODELPART_LLEG: rotateBone = "ltibia"; break; case G2_MODELPART_RLEG: rotateBone = "rtibia"; break; default: rotateBone = "rtibia"; break; } useBolt = trap_G2API_AddBolt(self->ghoul2, 0, rotateBone); VectorCopy(self->client->ps.origin, properOrigin); VectorCopy(self->client->ps.viewangles, properAngles); //try to predict the origin based on velocity so it's more like what the client is seeing VectorCopy(self->client->ps.velocity, addVel); VectorNormalize(addVel); if (self->client->ps.velocity[0] < 0) { fVSpeed += (-self->client->ps.velocity[0]); } else { fVSpeed += self->client->ps.velocity[0]; } if (self->client->ps.velocity[1] < 0) { fVSpeed += (-self->client->ps.velocity[1]); } else { fVSpeed += self->client->ps.velocity[1]; } if (self->client->ps.velocity[2] < 0) { fVSpeed += (-self->client->ps.velocity[2]); } else { fVSpeed += self->client->ps.velocity[2]; } fVSpeed *= 0.08; properOrigin[0] += addVel[0]*fVSpeed; properOrigin[1] += addVel[1]*fVSpeed; properOrigin[2] += addVel[2]*fVSpeed; properAngles[0] = 0; properAngles[1] = self->client->ps.viewangles[YAW]; properAngles[2] = 0; trap_G2API_GetBoltMatrix(self->ghoul2, 0, useBolt, &boltMatrix, properAngles, properOrigin, level.time, NULL, self->modelScale); boltPoint[0] = boltMatrix.matrix[0][3]; boltPoint[1] = boltMatrix.matrix[1][3]; boltPoint[2] = boltMatrix.matrix[2][3]; trap_G2API_GetBoltMatrix(self->ghoul2, 1, 0, &boltMatrix, properAngles, properOrigin, level.time, NULL, self->modelScale); if (self->client && limbType == G2_MODELPART_RHAND) { //Make some saber hit sparks over the severed wrist area vec3_t boltAngles; gentity_t *te; boltAngles[0] = -boltMatrix.matrix[0][1]; boltAngles[1] = -boltMatrix.matrix[1][1]; boltAngles[2] = -boltMatrix.matrix[2][1]; te = G_TempEntity( boltPoint, EV_SABER_HIT ); te->s.otherEntityNum = self->s.number; te->s.otherEntityNum2 = ENTITYNUM_NONE; te->s.weapon = 0;//saberNum te->s.legsAnim = 0;//bladeNum VectorCopy(boltPoint, te->s.origin); VectorCopy(boltAngles, te->s.angles); if (!te->s.angles[0] && !te->s.angles[1] && !te->s.angles[2]) { //don't let it play with no direction te->s.angles[1] = 1; } te->s.eventParm = 16; //lots of sparks } }

void G_GetDismemberLoc (  gentity_t *  self, vec3_t  boltPoint, int  limbType )

Definition at line 3067 of file g_combat.c. References AngleVectors(), entityShared_t::currentAngles, entityShared_t::currentOrigin, G2_MODELPART_HEAD, G2_MODELPART_LARM, G2_MODELPART_LLEG, G2_MODELPART_RARM, G2_MODELPART_RHAND, G2_MODELPART_RLEG, G2_MODELPART_WAIST, gentity_t, gentity_s::r, vec3_t, and VectorCopy. Referenced by G_CheckForDismemberment(). { //Just get the general area without using server-side ghoul2 vec3_t fwd, right, up; AngleVectors(self->r.currentAngles, fwd, right, up); VectorCopy(self->r.currentOrigin, boltPoint); switch (limbType) { case G2_MODELPART_HEAD: boltPoint[0] += up[0]*24; boltPoint[1] += up[1]*24; boltPoint[2] += up[2]*24; break; case G2_MODELPART_WAIST: boltPoint[0] += up[0]*4; boltPoint[1] += up[1]*4; boltPoint[2] += up[2]*4; break; case G2_MODELPART_LARM: boltPoint[0] += up[0]*18; boltPoint[1] += up[1]*18; boltPoint[2] += up[2]*18; boltPoint[0] -= right[0]*10; boltPoint[1] -= right[1]*10; boltPoint[2] -= right[2]*10; break; case G2_MODELPART_RARM: boltPoint[0] += up[0]*18; boltPoint[1] += up[1]*18; boltPoint[2] += up[2]*18; boltPoint[0] += right[0]*10; boltPoint[1] += right[1]*10; boltPoint[2] += right[2]*10; break; case G2_MODELPART_RHAND: boltPoint[0] += up[0]*8; boltPoint[1] += up[1]*8; boltPoint[2] += up[2]*8; boltPoint[0] += right[0]*10; boltPoint[1] += right[1]*10; boltPoint[2] += right[2]*10; break; case G2_MODELPART_LLEG: boltPoint[0] -= up[0]*4; boltPoint[1] -= up[1]*4; boltPoint[2] -= up[2]*4; boltPoint[0] -= right[0]*10; boltPoint[1] -= right[1]*10; boltPoint[2] -= right[2]*10; break; case G2_MODELPART_RLEG: boltPoint[0] -= up[0]*4; boltPoint[1] -= up[1]*4; boltPoint[2] -= up[2]*4; boltPoint[0] += right[0]*10; boltPoint[1] += right[1]*10; boltPoint[2] += right[2]*10; break; default: break; } return; }

int G_GetHitLocation (  gentity_t *  target, vec3_t  ppoint )

Definition at line 45 of file g_combat.c. References entityShared_t::absmax, entityShared_t::absmin, AngleVectors(), gentity_s::client, entityShared_t::currentAngles, DotProduct, fabs(), gentity_t, HL_ARM_LT, HL_ARM_RT, HL_BACK, HL_BACK_LT, HL_BACK_RT, HL_CHEST, HL_CHEST_LT, HL_CHEST_RT, HL_FOOT_LT, HL_FOOT_RT, HL_HAND_LT, HL_HAND_RT, HL_HEAD, HL_LEG_LT, HL_LEG_RT, HL_NONE, HL_WAIST, entityShared_t::maxs, entityShared_t::mins, gentity_s::r, vec3_origin, vec3_t, VectorAdd, VectorCopy, VectorNormalize(), VectorScale, VectorSet, VectorSubtract, and YAW. Referenced by G_CheckForDismemberment(), G_LocationBasedDamageModifier(), G_PickDeathAnim(), and WP_DisruptorAltFire(). { vec3_t point, point_dir; vec3_t forward, right, up; vec3_t tangles, tcenter; float tradius; float udot, fdot, rdot; int Vertical, Forward, Lateral; int HitLoc; // Get target forward, right and up. if(target->client) { // Ignore player's pitch and roll. VectorSet(tangles, 0, target->r.currentAngles[YAW], 0); } AngleVectors(tangles, forward, right, up); // Get center of target. VectorAdd(target->r.absmin, target->r.absmax, tcenter); VectorScale(tcenter, 0.5, tcenter); // Get radius width of target. tradius = (fabs(target->r.maxs[0]) + fabs(target->r.maxs[1]) + fabs(target->r.mins[0]) + fabs(target->r.mins[1]))/4; // Get impact point. if(ppoint && !VectorCompare(ppoint, vec3_origin)) { VectorCopy(ppoint, point); } else { return HL_NONE; } /* //get impact dir if(pdir && !VectorCompare(pdir, vec3_origin)) { VectorCopy(pdir, dir); } else { return; } //put point at controlled distance from center VectorSubtract(point, tcenter, tempvec); tempvec[2] = 0; hdist = VectorLength(tempvec); VectorMA(point, hdist - tradius, dir, point); //now a point on the surface of a cylinder with a radius of tradius */ VectorSubtract(point, tcenter, point_dir); VectorNormalize(point_dir); // Get bottom to top (vertical) position index udot = DotProduct(up, point_dir); if(udot>.800) { Vertical = 4; } else if(udot>.400) { Vertical = 3; } else if(udot>-.333) { Vertical = 2; } else if(udot>-.666) { Vertical = 1; } else { Vertical = 0; } // Get back to front (forward) position index. fdot = DotProduct(forward, point_dir); if(fdot>.666) { Forward = 4; } else if(fdot>.333) { Forward = 3; } else if(fdot>-.333) { Forward = 2; } else if(fdot>-.666) { Forward = 1; } else { Forward = 0; } // Get left to right (lateral) position index. rdot = DotProduct(right, point_dir); if(rdot>.666) { Lateral = 4; } else if(rdot>.333) { Lateral = 3; } else if(rdot>-.333) { Lateral = 2; } else if(rdot>-.666) { Lateral = 1; } else { Lateral = 0; } HitLoc = Vertical * 25 + Forward * 5 + Lateral; if(HitLoc <= 10) { // Feet. if ( rdot > 0 ) { return HL_FOOT_RT; } else { return HL_FOOT_LT; } } else if(HitLoc <= 50) { // Legs. if ( rdot > 0 ) { return HL_LEG_RT; } else { return HL_LEG_LT; } } else if(HitLoc == 56||HitLoc == 60||HitLoc == 61||HitLoc == 65||HitLoc == 66||HitLoc == 70) { // Hands. if ( rdot > 0 ) { return HL_HAND_RT; } else { return HL_HAND_LT; } } else if(HitLoc == 83||HitLoc == 87||HitLoc == 88||HitLoc == 92||HitLoc == 93||HitLoc == 97) { // Arms. if ( rdot > 0 ) { return HL_ARM_RT; } else { return HL_ARM_LT; } } else if((HitLoc >= 107 && HitLoc <= 109)||(HitLoc >= 112 && HitLoc <= 114)||(HitLoc >= 117 && HitLoc <= 119)) { // Head. return HL_HEAD; } else { if(udot < 0.3) { return HL_WAIST; } else if(fdot < 0) { if(rdot > 0.4) { return HL_BACK_RT; } else if(rdot < -0.4) { return HL_BACK_LT; } else if(fdot < 0) { return HL_BACK; } } else { if(rdot > 0.3) { return HL_CHEST_RT; } else if(rdot < -0.3) { return HL_CHEST_LT; } else if(fdot < 0) { return HL_CHEST; } } } return HL_NONE; }

qboolean G_GetHitLocFromSurfName (  gentity_t *  ent, const char *  surfName, int *  hitLoc, vec3_t  point, vec3_t  dir, vec3_t  bladeDir, int  mod )

Definition at line 3632 of file g_combat.c. References AngleVectors(), renderInfo_s::boltValidityTime, CLASS_ATST, CLASS_GALAKMECH, CLASS_GONK, CLASS_INTERROGATOR, CLASS_MARK1, CLASS_MARK2, CLASS_MOUSE, CLASS_PROBE, CLASS_PROTOCOL, CLASS_R2D2, CLASS_SENTRY, gentity_s::client, entityShared_t::currentAngles, entityShared_t::currentOrigin, DotProduct, g_dismember, gentity_t, gentity_s::ghoul2, HL_ARM_LT, HL_ARM_RT, HL_BACK, HL_BACK_LT, HL_BACK_RT, HL_CHEST, HL_CHEST_LT, HL_CHEST_RT, HL_FOOT_LT, HL_FOOT_RT, HL_GENERIC1, HL_GENERIC2, HL_GENERIC3, HL_GENERIC4, HL_GENERIC5, HL_GENERIC6, HL_HAND_LT, HL_HAND_RT, HL_HEAD, HL_LEG_LT, HL_LEG_RT, HL_NONE, HL_WAIST, vmCvar_t::integer, level, gentity_s::localAnimIndex, MOD_SABER, gentity_s::modelScale, NEGATIVE_Y, gclient_s::NPC_class, NULL, ORIGIN, playerState_s::origin, gclient_s::ps, Q_stricmp(), Q_strncmp(), qboolean, qfalse, qtrue, gentity_s::r, gclient_s::renderInfo, level_locals_t::time, renderInfo_s::torsoAngles, renderInfo_s::torsoPoint, trap_G2API_AddBolt(), trap_G2API_GetBoltMatrix(), UpdateClientRenderBolts(), vec3_t, VectorSet, VectorSubtract, playerState_s::viewangles, and YAW. Referenced by G_CheckForDismemberment(), G_Damage(), and G_LocationBasedDamageModifier(). { qboolean dismember = qfalse; int actualTime; int kneeLBolt = -1; int kneeRBolt = -1; int handRBolt = -1; int handLBolt = -1; int footRBolt = -1; int footLBolt = -1; *hitLoc = HL_NONE; if ( !surfName || !surfName[0] ) { return qfalse; } if( !ent->client ) { return qfalse; } if (!point) { return qfalse; } if ( ent->client && ( ent->client->NPC_class == CLASS_R2D2 || ent->client->NPC_class == CLASS_R2D2 || ent->client->NPC_class == CLASS_GONK || ent->client->NPC_class == CLASS_MOUSE || ent->client->NPC_class == CLASS_SENTRY || ent->client->NPC_class == CLASS_INTERROGATOR || ent->client->NPC_class == CLASS_SENTRY || ent->client->NPC_class == CLASS_PROBE ) ) {//we don't care about per-surface hit-locations or dismemberment for these guys return qfalse; } if (ent->localAnimIndex <= 1) { //humanoid handLBolt = trap_G2API_AddBolt(ent->ghoul2, 0, "*l_hand"); handRBolt = trap_G2API_AddBolt(ent->ghoul2, 0, "*r_hand"); kneeLBolt = trap_G2API_AddBolt(ent->ghoul2, 0, "*hips_l_knee"); kneeRBolt = trap_G2API_AddBolt(ent->ghoul2, 0, "*hips_r_knee"); footLBolt = trap_G2API_AddBolt(ent->ghoul2, 0, "*l_leg_foot"); footRBolt = trap_G2API_AddBolt(ent->ghoul2, 0, "*r_leg_foot"); } if ( ent->client && (ent->client->NPC_class == CLASS_ATST) ) { //FIXME: almost impossible to hit these... perhaps we should // check for splashDamage and do radius damage to these parts? // Or, if we ever get bbox G2 traces, that may fix it, too if (!Q_stricmp("head_light_blaster_cann",surfName)) { *hitLoc = HL_ARM_LT; } else if (!Q_stricmp("head_concussion_charger",surfName)) { *hitLoc = HL_ARM_RT; } return(qfalse); } else if ( ent->client && (ent->client->NPC_class == CLASS_MARK1) ) { if (!Q_stricmp("l_arm",surfName)) { *hitLoc = HL_ARM_LT; } else if (!Q_stricmp("r_arm",surfName)) { *hitLoc = HL_ARM_RT; } else if (!Q_stricmp("torso_front",surfName)) { *hitLoc = HL_CHEST; } else if (!Q_stricmp("torso_tube1",surfName)) { *hitLoc = HL_GENERIC1; } else if (!Q_stricmp("torso_tube2",surfName)) { *hitLoc = HL_GENERIC2; } else if (!Q_stricmp("torso_tube3",surfName)) { *hitLoc = HL_GENERIC3; } else if (!Q_stricmp("torso_tube4",surfName)) { *hitLoc = HL_GENERIC4; } else if (!Q_stricmp("torso_tube5",surfName)) { *hitLoc = HL_GENERIC5; } else if (!Q_stricmp("torso_tube6",surfName)) { *hitLoc = HL_GENERIC6; } return(qfalse); } else if ( ent->client && (ent->client->NPC_class == CLASS_MARK2) ) { if (!Q_stricmp("torso_canister1",surfName)) { *hitLoc = HL_GENERIC1; } else if (!Q_stricmp("torso_canister2",surfName)) { *hitLoc = HL_GENERIC2; } else if (!Q_stricmp("torso_canister3",surfName)) { *hitLoc = HL_GENERIC3; } return(qfalse); } else if ( ent->client && (ent->client->NPC_class == CLASS_GALAKMECH) ) { if (!Q_stricmp("torso_antenna",surfName)||!Q_stricmp("torso_antenna_base",surfName)) { *hitLoc = HL_GENERIC1; } else if (!Q_stricmp("torso_shield",surfName)) { *hitLoc = HL_GENERIC2; } else { *hitLoc = HL_CHEST; } return(qfalse); } //FIXME: check the hitLoc and hitDir against the cap tag for the place //where the split will be- if the hit dir is roughly perpendicular to //the direction of the cap, then the split is allowed, otherwise we //hit it at the wrong angle and should not dismember... actualTime = level.time; if ( !Q_strncmp( "hips", surfName, 4 ) ) {//FIXME: test properly for legs *hitLoc = HL_WAIST; if ( ent->client != NULL && ent->ghoul2 ) { mdxaBone_t boltMatrix; vec3_t tagOrg, angles; VectorSet( angles, 0, ent->r.currentAngles[YAW], 0 ); if (kneeLBolt>=0) { trap_G2API_GetBoltMatrix( ent->ghoul2, 0, kneeLBolt, &boltMatrix, angles, ent->r.currentOrigin, actualTime, NULL, ent->modelScale ); BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, tagOrg ); if ( DistanceSquared( point, tagOrg ) < 100 ) {//actually hit the knee *hitLoc = HL_LEG_LT; } } if (*hitLoc == HL_WAIST) { if (kneeRBolt>=0) { trap_G2API_GetBoltMatrix( ent->ghoul2, 0, kneeRBolt, &boltMatrix, angles, ent->r.currentOrigin, actualTime, NULL, ent->modelScale ); BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, tagOrg ); if ( DistanceSquared( point, tagOrg ) < 100 ) {//actually hit the knee *hitLoc = HL_LEG_RT; } } } } } else if ( !Q_strncmp( "torso", surfName, 5 ) ) { if ( !ent->client ) { *hitLoc = HL_CHEST; } else { vec3_t t_fwd, t_rt, t_up, dirToImpact; float frontSide, rightSide, upSide; AngleVectors( ent->client->renderInfo.torsoAngles, t_fwd, t_rt, t_up ); if (ent->client->renderInfo.boltValidityTime != level.time) { vec3_t renderAng; renderAng[0] = 0; renderAng[1] = ent->client->ps.viewangles[YAW]; renderAng[2] = 0; UpdateClientRenderBolts(ent, ent->client->ps.origin, renderAng); } VectorSubtract( point, ent->client->renderInfo.torsoPoint, dirToImpact ); frontSide = DotProduct( t_fwd, dirToImpact ); rightSide = DotProduct( t_rt, dirToImpact ); upSide = DotProduct( t_up, dirToImpact ); if ( upSide < -10 ) {//hit at waist *hitLoc = HL_WAIST; } else {//hit on upper torso if ( rightSide > 4 ) { *hitLoc = HL_ARM_RT; } else if ( rightSide < -4 ) { *hitLoc = HL_ARM_LT; } else if ( rightSide > 2 ) { if ( frontSide > 0 ) { *hitLoc = HL_CHEST_RT; } else { *hitLoc = HL_BACK_RT; } } else if ( rightSide < -2 ) { if ( frontSide > 0 ) { *hitLoc = HL_CHEST_LT; } else { *hitLoc = HL_BACK_LT; } } else if ( upSide > -3 && mod == MOD_SABER ) { *hitLoc = HL_HEAD; } else if ( frontSide > 0 ) { *hitLoc = HL_CHEST; } else { *hitLoc = HL_BACK; } } } } else if ( !Q_strncmp( "head", surfName, 4 ) ) { *hitLoc = HL_HEAD; } else if ( !Q_strncmp( "r_arm", surfName, 5 ) ) { *hitLoc = HL_ARM_RT; if ( ent->client != NULL && ent->ghoul2 ) { mdxaBone_t boltMatrix; vec3_t tagOrg, angles; VectorSet( angles, 0, ent->r.currentAngles[YAW], 0 ); if (handRBolt>=0) { trap_G2API_GetBoltMatrix( ent->ghoul2, 0, handRBolt, &boltMatrix, angles, ent->r.currentOrigin, actualTime, NULL, ent->modelScale ); BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, tagOrg ); if ( DistanceSquared( point, tagOrg ) < 256 ) {//actually hit the hand *hitLoc = HL_HAND_RT; } } } } else if ( !Q_strncmp( "l_arm", surfName, 5 ) ) { *hitLoc = HL_ARM_LT; if ( ent->client != NULL && ent->ghoul2 ) { mdxaBone_t boltMatrix; vec3_t tagOrg, angles; VectorSet( angles, 0, ent->r.currentAngles[YAW], 0 ); if (handLBolt>=0) { trap_G2API_GetBoltMatrix( ent->ghoul2, 0, handLBolt, &boltMatrix, angles, ent->r.currentOrigin, actualTime, NULL, ent->modelScale ); BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, tagOrg ); if ( DistanceSquared( point, tagOrg ) < 256 ) {//actually hit the hand *hitLoc = HL_HAND_LT; } } } } else if ( !Q_strncmp( "r_leg", surfName, 5 ) ) { *hitLoc = HL_LEG_RT; if ( ent->client != NULL && ent->ghoul2 ) { mdxaBone_t boltMatrix; vec3_t tagOrg, angles; VectorSet( angles, 0, ent->r.currentAngles[YAW], 0 ); if (footRBolt>=0) { trap_G2API_GetBoltMatrix( ent->ghoul2, 0, footRBolt, &boltMatrix, angles, ent->r.currentOrigin, actualTime, NULL, ent->modelScale ); BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, tagOrg ); if ( DistanceSquared( point, tagOrg ) < 100 ) {//actually hit the foot *hitLoc = HL_FOOT_RT; } } } } else if ( !Q_strncmp( "l_leg", surfName, 5 ) ) { *hitLoc = HL_LEG_LT; if ( ent->client != NULL && ent->ghoul2 ) { mdxaBone_t boltMatrix; vec3_t tagOrg, angles; VectorSet( angles, 0, ent->r.currentAngles[YAW], 0 ); if (footLBolt>=0) { trap_G2API_GetBoltMatrix( ent->ghoul2, 0, footLBolt, &boltMatrix, angles, ent->r.currentOrigin, actualTime, NULL, ent->modelScale ); BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, tagOrg ); if ( DistanceSquared( point, tagOrg ) < 100 ) {//actually hit the foot *hitLoc = HL_FOOT_LT; } } } } else if ( !Q_strncmp( "r_hand", surfName, 6 ) || !Q_strncmp( "w_", surfName, 2 ) ) {//right hand or weapon *hitLoc = HL_HAND_RT; } else if ( !Q_strncmp( "l_hand", surfName, 6 ) ) { *hitLoc = HL_HAND_LT; } /* #ifdef _DEBUG else { Com_Printf( "ERROR: surface %s does not belong to any hitLocation!!!\n", surfName ); } #endif //_DEBUG */ //if ( g_dismemberment->integer >= 11381138 || !ent->client->dismembered ) if (g_dismember.integer == 100) { //full probability... if ( ent->client && ent->client->NPC_class == CLASS_PROTOCOL ) { dismember = qtrue; } else if ( dir && (dir[0] || dir[1] || dir[2]) && bladeDir && (bladeDir[0] || bladeDir[1] || bladeDir[2]) ) {//we care about direction (presumably for dismemberment) //if ( g_dismemberProbabilities->value<=0.0f||G_Dismemberable( ent, *hitLoc ) ) if (1) //Fix me? {//either we don't care about probabilties or the probability let us continue char *tagName = NULL; float aoa = 0.5f; //dir must be roughly perpendicular to the hitLoc's cap bolt switch ( *hitLoc ) { case HL_LEG_RT: tagName = "*hips_cap_r_leg"; break; case HL_LEG_LT: tagName = "*hips_cap_l_leg"; break; case HL_WAIST: tagName = "*hips_cap_torso"; aoa = 0.25f; break; case HL_CHEST_RT: case HL_ARM_RT: case HL_BACK_LT: tagName = "*torso_cap_r_arm"; break; case HL_CHEST_LT: case HL_ARM_LT: case HL_BACK_RT: tagName = "*torso_cap_l_arm"; break; case HL_HAND_RT: tagName = "*r_arm_cap_r_hand"; break; case HL_HAND_LT: tagName = "*l_arm_cap_l_hand"; break; case HL_HEAD: tagName = "*torso_cap_head"; aoa = 0.25f; break; case HL_CHEST: case HL_BACK: case HL_FOOT_RT: case HL_FOOT_LT: default: //no dismemberment possible with these, so no checks needed break; } if ( tagName ) { int tagBolt = trap_G2API_AddBolt( ent->ghoul2, 0, tagName ); if ( tagBolt != -1 ) { mdxaBone_t boltMatrix; vec3_t tagOrg, tagDir, angles; VectorSet( angles, 0, ent->r.currentAngles[YAW], 0 ); trap_G2API_GetBoltMatrix( ent->ghoul2, 0, tagBolt, &boltMatrix, angles, ent->r.currentOrigin, actualTime, NULL, ent->modelScale ); BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, tagOrg ); BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, tagDir ); if ( DistanceSquared( point, tagOrg ) < 256 ) {//hit close float dot = DotProduct( dir, tagDir ); if ( dot < aoa && dot > -aoa ) {//hit roughly perpendicular dot = DotProduct( bladeDir, tagDir ); if ( dot < aoa && dot > -aoa ) {//blade was roughly perpendicular dismember = qtrue; } } } } } } } else { //hmm, no direction supplied. dismember = qtrue; } } return dismember; }

int G_GetHitQuad (  gentity_t *  self, vec3_t  hitloc )

Definition at line 3546 of file g_combat.c. References AngleVectors(), entityState_s::apos, gentity_s::client, DotProduct, G2_MODELPART_HEAD, G2_MODELPART_LARM, G2_MODELPART_LLEG, G2_MODELPART_RARM, G2_MODELPART_RLEG, gentity_t, gPainHitLoc, NULL, playerState_s::origin, entityState_s::pos, gclient_s::ps, gentity_s::s, trajectory_t::trBase, vec3_t, VectorCopy, VectorNormalize(), VectorSubtract, playerState_s::viewangles, and playerState_s::viewheight. Referenced by G_CheckForDismemberment(). { vec3_t diff, fwdangles={0,0,0}, right; vec3_t clEye; float rightdot; float zdiff; int hitLoc = gPainHitLoc; if (self->client) { VectorCopy(self->client->ps.origin, clEye); clEye[2] += self->client->ps.viewheight; } else { VectorCopy(self->s.pos.trBase, clEye); clEye[2] += 16; }