super-coop/source/combat.qc

288 lines
6.1 KiB
Plaintext
Raw Normal View History

// combat.qc: entity-entity damage functions
2019-09-11 11:47:16 -07:00
2019-09-16 11:56:56 -07:00
float(entity targ, entity attacker) SameTeam = {
2019-09-19 16:37:40 -07:00
return targ != attacker &&
targ.team > 0 &&
targ.team == attacker.team;
2019-09-16 11:56:56 -07:00
};
float(entity targ, entity attacker) BothPlayers = {
2019-09-19 16:37:40 -07:00
return targ != attacker &&
targ.classname == "player" &&
attacker.classname == "player";
2019-09-16 11:56:56 -07:00
};
2019-09-11 11:47:16 -07:00
/*
============
CanDamage
Returns true if the inflictor can directly damage the target. Used for
explosions and melee attacks.
============
*/
float(entity targ, entity inflictor) CanDamage = {
// bmodels need special checking because their origin is 0,0,0
if(targ.movetype == MOVETYPE_PUSH) {
traceline(inflictor.origin, 0.5 * (targ.absmin + targ.absmax), TRUE, self);
if(trace_fraction == 1) {
return TRUE;
}
if(trace_ent == targ) {
return TRUE;
}
return FALSE;
}
traceline(inflictor.origin, targ.origin, TRUE, self);
if(trace_fraction == 1) {
return TRUE;
}
traceline(inflictor.origin, targ.origin + '15 15 0', TRUE, self);
if(trace_fraction == 1) {
return TRUE;
}
traceline(inflictor.origin, targ.origin + '-15 -15 0', TRUE, self);
if(trace_fraction == 1) {
return TRUE;
}
traceline(inflictor.origin, targ.origin + '-15 15 0', TRUE, self);
if(trace_fraction == 1) {
return TRUE;
}
traceline(inflictor.origin, targ.origin + '15 -15 0', TRUE, self);
if(trace_fraction == 1) {
return TRUE;
}
return FALSE;
};
/*
============
Killed
============
*/
void(entity targ, entity attacker) Killed = {
2019-09-17 08:26:44 -07:00
entity oself;
2019-09-11 11:47:16 -07:00
oself = self;
self = targ;
if(self.health < -99) {
self.health = -99; // don't let sbar look bad if a player
}
if(self.movetype == MOVETYPE_PUSH || self.movetype == MOVETYPE_NONE) {
// doors, triggers, etc
self.th_die();
self = oself;
return;
}
self.enemy = attacker;
// bump the monster counter
if(self.flags & FL_MONSTER) {
killed_monsters = killed_monsters + 1;
WriteByte(MSG_ALL, SVC_KILLEDMONSTER);
}
ClientObituary(self, attacker);
self.takedamage = DAMAGE_NO;
self.touch = SUB_Null;
monster_death_use();
self.th_die();
self = oself;
};
/*
============
T_Damage
The damage is coming from inflictor, but get mad at attacker
This should be the only function that ever reduces health.
============
*/
void(entity targ, entity inflictor, entity attacker, float damage) T_Damage = {
2019-09-17 08:26:44 -07:00
vector dir;
entity oldself;
float save;
float take;
2019-09-11 11:47:16 -07:00
2019-09-16 11:56:56 -07:00
// team play damage avoidance
if(teamplay == 1 && SameTeam(targ, attacker)) {
return;
}
if(teamplay == 3 && BothPlayers(targ, attacker)) {
return;
}
2019-09-11 11:47:16 -07:00
if(!targ.takedamage) {
return;
}
// used by buttons and triggers to set activator for target firing
damage_attacker = attacker;
// check for quad damage powerup on the attacker
if(attacker.super_damage_finished > time) {
damage = damage * 4;
}
// save damage based on the target's armor level
save = ceil(targ.armortype * damage);
if(save >= targ.armorvalue) {
save = targ.armorvalue;
targ.armortype = 0; // lost all armor
targ.items = targ.items - (targ.items & (IT_ARMOR1 | IT_ARMOR2 | IT_ARMOR3));
}
targ.armorvalue = targ.armorvalue - save;
take = ceil(damage - save);
// add to the damage total for clients, which will be sent as a single
// message at the end of the frame
// FIXME: remove after combining shotgun blasts?
if(targ.flags & FL_CLIENT) {
targ.dmg_take = targ.dmg_take + take;
targ.dmg_save = targ.dmg_save + save;
targ.dmg_inflictor = inflictor;
}
// figure momentum add
if((inflictor != world) && (targ.movetype == MOVETYPE_WALK)) {
dir = targ.origin - (inflictor.absmin + inflictor.absmax) * 0.5;
dir = normalize(dir);
targ.velocity = targ.velocity + dir * damage * 8;
}
// check for godmode or invincibility
if(targ.flags & FL_GODMODE) {
return;
}
if(targ.invincible_finished >= time) {
if(self.invincible_sound < time) {
sound(targ, CHAN_ITEM, "items/protect3.wav", 1, ATTN_NORM);
self.invincible_sound = time + 2;
}
return;
}
// do the damage
targ.health = targ.health - take;
if(targ.health <= 0) {
Killed(targ, attacker);
return;
}
// react to the damage
oldself = self;
self = targ;
if((self.flags & FL_MONSTER) && attacker != world) {
// get mad unless of the same class(except for soldiers)
if(self != attacker && attacker != self.enemy) {
if((self.classname != attacker.classname)
|| (self.classname == "monster_army")) {
if(self.enemy.classname == "player") {
self.oldenemy = self.enemy;
}
self.enemy = attacker;
FoundTarget();
}
}
}
if(self.th_pain) {
self.th_pain(attacker, take);
// nightmare mode monsters don't go into pain frames often
if(skill == 3) {
self.pain_finished = time + 5;
}
}
self = oldself;
};
/*
============
T_RadiusDamage
============
*/
void(entity inflictor, entity attacker, float damage, entity ignore) T_RadiusDamage = {
2019-09-17 08:26:44 -07:00
float points;
entity head;
vector org;
2019-09-11 11:47:16 -07:00
head = findradius(inflictor.origin, damage + 40);
while(head) {
if(head != ignore) {
if(head.takedamage) {
org = head.origin + (head.mins + head.maxs) * 0.5;
points = 0.5 * vlen(inflictor.origin - org);
if(points < 0) {
points = 0;
}
points = damage - points;
if(head == attacker) {
points = points * 0.5;
}
if(points > 0) {
if(CanDamage(head, inflictor)) {
// shambler takes half damage from all explosions
if(head.classname == "monster_shambler") {
T_Damage(head, inflictor, attacker, points * 0.5);
} else {
T_Damage(head, inflictor, attacker, points);
}
}
}
}
}
head = head.chain;
}
};
/*
============
T_BeamDamage
============
*/
void(entity attacker, float damage) T_BeamDamage = {
2019-09-17 08:26:44 -07:00
float points;
entity head;
2019-09-11 11:47:16 -07:00
head = findradius(attacker.origin, damage + 40);
while(head) {
if(head.takedamage) {
points = 0.5 * vlen(attacker.origin - head.origin);
if(points < 0) {
points = 0;
}
points = damage - points;
if(head == attacker) {
points = points * 0.5;
}
if(points > 0) {
if(CanDamage(head, attacker)) {
if(head.classname == "monster_shambler") {
T_Damage(head, attacker, attacker, points * 0.5);
} else {
T_Damage(head, attacker, attacker, points);
}
}
}
}
head = head.chain;
}
};