![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to g_combat.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / rogue|
Return to g_combat.c CVS log | Up to [Quake II] / quake2 / rogue |
1.1 root 1: // g_combat.c
2:
3: #include "g_local.h"
4:
5: void M_SetEffects (edict_t *self);
6:
7: /*
8: ROGUE
9: clean up heal targets for medic
10: */
11: void cleanupHealTarget (edict_t *ent)
12: {
13: ent->monsterinfo.healer = NULL;
14: ent->takedamage = DAMAGE_YES;
15: ent->monsterinfo.aiflags &= ~AI_RESURRECTING;
16: M_SetEffects (ent);
17: }
18: /*
19: ============
20: CanDamage
21:
22: Returns true if the inflictor can directly damage the target. Used for
23: explosions and melee attacks.
24: ============
25: */
26: qboolean CanDamage (edict_t *targ, edict_t *inflictor)
27: {
28: vec3_t dest;
29: trace_t trace;
30:
31: // bmodels need special checking because their origin is 0,0,0
32: if (targ->movetype == MOVETYPE_PUSH)
33: {
34: VectorAdd (targ->absmin, targ->absmax, dest);
35: VectorScale (dest, 0.5, dest);
36: trace = gi.trace (inflictor->s.origin, vec3_origin, vec3_origin, dest, inflictor, MASK_SOLID);
37: if (trace.fraction == 1.0)
38: return true;
39: if (trace.ent == targ)
40: return true;
41: return false;
42: }
43:
44: trace = gi.trace (inflictor->s.origin, vec3_origin, vec3_origin, targ->s.origin, inflictor, MASK_SOLID);
45: if (trace.fraction == 1.0)
46: return true;
47:
48: VectorCopy (targ->s.origin, dest);
49: dest[0] += 15.0;
50: dest[1] += 15.0;
51: trace = gi.trace (inflictor->s.origin, vec3_origin, vec3_origin, dest, inflictor, MASK_SOLID);
52: if (trace.fraction == 1.0)
53: return true;
54:
55: VectorCopy (targ->s.origin, dest);
56: dest[0] += 15.0;
57: dest[1] -= 15.0;
58: trace = gi.trace (inflictor->s.origin, vec3_origin, vec3_origin, dest, inflictor, MASK_SOLID);
59: if (trace.fraction == 1.0)
60: return true;
61:
62: VectorCopy (targ->s.origin, dest);
63: dest[0] -= 15.0;
64: dest[1] += 15.0;
65: trace = gi.trace (inflictor->s.origin, vec3_origin, vec3_origin, dest, inflictor, MASK_SOLID);
66: if (trace.fraction == 1.0)
67: return true;
68:
69: VectorCopy (targ->s.origin, dest);
70: dest[0] -= 15.0;
71: dest[1] -= 15.0;
72: trace = gi.trace (inflictor->s.origin, vec3_origin, vec3_origin, dest, inflictor, MASK_SOLID);
73: if (trace.fraction == 1.0)
74: return true;
75:
76:
77: return false;
78: }
79:
80:
81: /*
82: ============
83: Killed
84: ============
85: */
86: void Killed (edict_t *targ, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
87: {
88: if (targ->health < -999)
89: targ->health = -999;
90:
91: if (targ->monsterinfo.aiflags & AI_MEDIC)
92: {
93: if (targ->enemy) // god, I hope so
94: {
95: cleanupHealTarget (targ->enemy);
96: }
97:
98: // clean up self
99: targ->monsterinfo.aiflags &= ~AI_MEDIC;
100: targ->enemy = attacker;
101: }
102: else
103: {
104: targ->enemy = attacker;
105: }
106:
107: if ((targ->svflags & SVF_MONSTER) && (targ->deadflag != DEAD_DEAD))
108: {
109: // targ->svflags |= SVF_DEADMONSTER; // now treat as a different content type
110: //ROGUE - free up slot for spawned monster if it's spawned
111: if (targ->monsterinfo.aiflags & AI_SPAWNED_CARRIER)
112: {
113: if (targ->monsterinfo.commander && targ->monsterinfo.commander->inuse &&
114: !strcmp(targ->monsterinfo.commander->classname, "monster_carrier"))
115: {
116: targ->monsterinfo.commander->monsterinfo.monster_slots++;
117: // if ((g_showlogic) && (g_showlogic->value))
118: // gi.dprintf ("g_combat: freeing up carrier slot - %d left\n", targ->monsterinfo.commander->monsterinfo.monster_slots);
119: }
120: }
121: if (targ->monsterinfo.aiflags & AI_SPAWNED_MEDIC_C)
122: {
123: if (targ->monsterinfo.commander)
124: {
125: if (targ->monsterinfo.commander->inuse && !strcmp(targ->monsterinfo.commander->classname, "monster_medic_commander"))
126: {
127: targ->monsterinfo.commander->monsterinfo.monster_slots++;
128: // if ((g_showlogic) && (g_showlogic->value))
129: // gi.dprintf ("g_combat: freeing up medic slot - %d left\n", targ->monsterinfo.commander->monsterinfo.monster_slots);
130: }
131: else
132: if ((g_showlogic) && (g_showlogic->value))
133: gi.dprintf ("my commander is dead! he's a %s\n", targ->monsterinfo.commander->classname);
134: }
135: else if ((g_showlogic) && (g_showlogic->value))
136: gi.dprintf ("My commander is GONE\n");
137:
138: }
139: if (targ->monsterinfo.aiflags & AI_SPAWNED_WIDOW)
140: {
141: // need to check this because we can have variable numbers of coop players
142: if (targ->monsterinfo.commander && targ->monsterinfo.commander->inuse &&
143: !strncmp(targ->monsterinfo.commander->classname, "monster_widow", 13))
144: {
145: if (targ->monsterinfo.commander->monsterinfo.monster_used > 0)
146: targ->monsterinfo.commander->monsterinfo.monster_used--;
147: // if ((g_showlogic) && (g_showlogic->value))
148: // gi.dprintf ("g_combat: freeing up black widow slot - %d used\n", targ->monsterinfo.commander->monsterinfo.monster_used);
149: }
150: }
151: //rogue
152: if ((!(targ->monsterinfo.aiflags & AI_GOOD_GUY)) && (!(targ->monsterinfo.aiflags & AI_DO_NOT_COUNT)))
153: {
154: level.killed_monsters++;
155: if (coop->value && attacker->client)
156: attacker->client->resp.score++;
157: // medics won't heal monsters that they kill themselves
158: // PMM - now they will
159: // if (strcmp(attacker->classname, "monster_medic") == 0)
160: // targ->owner = attacker;
161: }
162: }
163:
164: if (targ->movetype == MOVETYPE_PUSH || targ->movetype == MOVETYPE_STOP || targ->movetype == MOVETYPE_NONE)
165: { // doors, triggers, etc
166: targ->die (targ, inflictor, attacker, damage, point);
167: return;
168: }
169:
170: if ((targ->svflags & SVF_MONSTER) && (targ->deadflag != DEAD_DEAD))
171: {
172: targ->touch = NULL;
173: monster_death_use (targ);
174: }
175:
176: targ->die (targ, inflictor, attacker, damage, point);
177: }
178:
179:
180: /*
181: ================
182: SpawnDamage
183: ================
184: */
185: void SpawnDamage (int type, vec3_t origin, vec3_t normal, int damage)
186: {
187: if (damage > 255)
188: damage = 255;
189: gi.WriteByte (svc_temp_entity);
190: gi.WriteByte (type);
191: // gi.WriteByte (damage);
192: gi.WritePosition (origin);
193: gi.WriteDir (normal);
194: gi.multicast (origin, MULTICAST_PVS);
195: }
196:
197:
198: /*
199: ============
200: T_Damage
201:
202: targ entity that is being damaged
203: inflictor entity that is causing the damage
204: attacker entity that caused the inflictor to damage targ
205: example: targ=monster, inflictor=rocket, attacker=player
206:
207: dir direction of the attack
208: point point at which the damage is being inflicted
209: normal normal vector from that point
210: damage amount of damage being inflicted
211: knockback force to be applied against targ as a result of the damage
212:
213: dflags these flags are used to control how T_Damage works
214: DAMAGE_RADIUS damage was indirect (from a nearby explosion)
215: DAMAGE_NO_ARMOR armor does not protect from this damage
216: DAMAGE_ENERGY damage is from an energy based weapon
217: DAMAGE_NO_KNOCKBACK do not affect velocity, just view angles
218: DAMAGE_BULLET damage is from a bullet (used for ricochets)
219: DAMAGE_NO_PROTECTION kills godmode, armor, everything
220: ============
221: */
222: static int CheckPowerArmor (edict_t *ent, vec3_t point, vec3_t normal, int damage, int dflags)
223: {
224: gclient_t *client;
225: int save;
226: int power_armor_type;
227: int index;
228: int damagePerCell;
229: int pa_te_type;
230: int power;
231: int power_used;
232:
233: if (!damage)
234: return 0;
235:
236: client = ent->client;
237:
238: if (dflags & (DAMAGE_NO_ARMOR | DAMAGE_NO_POWER_ARMOR)) // PGM
239: return 0;
240:
241: if (client)
242: {
243: power_armor_type = PowerArmorType (ent);
244: if (power_armor_type != POWER_ARMOR_NONE)
245: {
246: index = ITEM_INDEX(FindItem("Cells"));
247: power = client->pers.inventory[index];
248: }
249: }
250: else if (ent->svflags & SVF_MONSTER)
251: {
252: power_armor_type = ent->monsterinfo.power_armor_type;
253: power = ent->monsterinfo.power_armor_power;
254: }
255: else
256: return 0;
257:
258: if (power_armor_type == POWER_ARMOR_NONE)
259: return 0;
260: if (!power)
261: return 0;
262:
263: if (power_armor_type == POWER_ARMOR_SCREEN)
264: {
265: vec3_t vec;
266: float dot;
267: vec3_t forward;
268:
269: // only works if damage point is in front
270: AngleVectors (ent->s.angles, forward, NULL, NULL);
271: VectorSubtract (point, ent->s.origin, vec);
272: VectorNormalize (vec);
273: dot = DotProduct (vec, forward);
274: if (dot <= 0.3)
275: return 0;
276:
277: damagePerCell = 1;
278: pa_te_type = TE_SCREEN_SPARKS;
279: damage = damage / 3;
280: }
281: else
282: {
283: damagePerCell = 2;
284: pa_te_type = TE_SHIELD_SPARKS;
285: damage = (2 * damage) / 3;
286: }
287:
288: // etf rifle
289: if (dflags & DAMAGE_NO_REG_ARMOR)
290: save = (power * damagePerCell) / 2;
291: else
292: save = power * damagePerCell;
293:
294: if (!save)
295: return 0;
296: if (save > damage)
297: save = damage;
298:
299: SpawnDamage (pa_te_type, point, normal, save);
300: ent->powerarmor_time = level.time + 0.2;
301:
302: if (dflags & DAMAGE_NO_REG_ARMOR)
303: power_used = (save / damagePerCell) * 2;
304: else
305: power_used = save / damagePerCell;
306:
307: if (client)
308: client->pers.inventory[index] -= power_used;
309: else
310: ent->monsterinfo.power_armor_power -= power_used;
311: return save;
312: }
313:
314: static int CheckArmor (edict_t *ent, vec3_t point, vec3_t normal, int damage, int te_sparks, int dflags)
315: {
316: gclient_t *client;
317: int save;
318: int index;
319: gitem_t *armor;
320:
321: if (!damage)
322: return 0;
323:
324: client = ent->client;
325:
326: if (!client)
327: return 0;
328:
329: // ROGUE - added DAMAGE_NO_REG_ARMOR for atf rifle
330: if (dflags & (DAMAGE_NO_ARMOR | DAMAGE_NO_REG_ARMOR))
331: return 0;
332:
333: index = ArmorIndex (ent);
334: if (!index)
335: return 0;
336:
337: armor = GetItemByIndex (index);
338:
339: if (dflags & DAMAGE_ENERGY)
340: save = ceil(((gitem_armor_t *)armor->info)->energy_protection*damage);
341: else
342: save = ceil(((gitem_armor_t *)armor->info)->normal_protection*damage);
343: if (save >= client->pers.inventory[index])
344: save = client->pers.inventory[index];
345:
346: if (!save)
347: return 0;
348:
349: client->pers.inventory[index] -= save;
350: SpawnDamage (te_sparks, point, normal, save);
351:
352: return save;
353: }
354:
355: void M_ReactToDamage (edict_t *targ, edict_t *attacker, edict_t *inflictor)
356: {
357: // pmm
358: qboolean new_tesla;
359:
360: if (!(attacker->client) && !(attacker->svflags & SVF_MONSTER))
361: return;
362:
363: //=======
364: //ROGUE
365: // logic for tesla - if you are hit by a tesla, and can't see who you should be mad at (attacker)
366: // attack the tesla
367: // also, target the tesla if it's a "new" tesla
368: if ((inflictor) && (!strcmp(inflictor->classname, "tesla")))
369: {
370: new_tesla = MarkTeslaArea(targ, inflictor);
371: if (new_tesla)
372: TargetTesla (targ, inflictor);
373: return;
374: // FIXME - just ignore teslas when you're TARGET_ANGER or MEDIC
375: /* if (!(targ->enemy && (targ->monsterinfo.aiflags & (AI_TARGET_ANGER|AI_MEDIC))))
376: {
377: // FIXME - coop issues?
378: if ((!targ->enemy) || (!visible(targ, targ->enemy)))
379: {
380: gi.dprintf ("can't see player, switching to tesla\n");
381: TargetTesla (targ, inflictor);
382: return;
383: }
384: gi.dprintf ("can see player, ignoring tesla\n");
385: }
386: else if ((g_showlogic) && (g_showlogic->value))
387: gi.dprintf ("no enemy, or I'm doing other, more important things, than worrying about a damned tesla!\n");
388: */
389: }
390: //ROGUE
391: //=======
392:
393: if (attacker == targ || attacker == targ->enemy)
394: return;
395:
396: // if we are a good guy monster and our attacker is a player
397: // or another good guy, do not get mad at them
398: if (targ->monsterinfo.aiflags & AI_GOOD_GUY)
399: {
400: if (attacker->client || (attacker->monsterinfo.aiflags & AI_GOOD_GUY))
401: return;
402: }
403:
404: //PGM
405: // if we're currently mad at something a target_anger made us mad at, ignore
406: // damage
407: if (targ->enemy && targ->monsterinfo.aiflags & AI_TARGET_ANGER)
408: {
409: float percentHealth;
410:
411: // make sure whatever we were pissed at is still around.
412: if(targ->enemy->inuse)
413: {
414: percentHealth = (float)(targ->health) / (float)(targ->max_health);
415: if( targ->enemy->inuse && percentHealth > 0.33)
416: return;
417: }
418:
419: // remove the target anger flag
420: targ->monsterinfo.aiflags &= ~AI_TARGET_ANGER;
421: }
422: //PGM
423:
424: // PMM
425: // if we're healing someone, do like above and try to stay with them
426: if ((targ->enemy) && (targ->monsterinfo.aiflags & AI_MEDIC))
427: {
428: float percentHealth;
429:
430: percentHealth = (float)(targ->health) / (float)(targ->max_health);
431: // ignore it some of the time
432: if( targ->enemy->inuse && percentHealth > 0.25)
433: return;
434:
435: // remove the medic flag
436: targ->monsterinfo.aiflags &= ~AI_MEDIC;
437: cleanupHealTarget (targ->enemy);
438: }
439: // PMM
440:
441: // we now know that we are not both good guys
442:
443: // if attacker is a client, get mad at them because he's good and we're not
444: if (attacker->client)
445: {
446: targ->monsterinfo.aiflags &= ~AI_SOUND_TARGET;
447:
448: // this can only happen in coop (both new and old enemies are clients)
449: // only switch if can't see the current enemy
450: if (targ->enemy && targ->enemy->client)
451: {
452: if (visible(targ, targ->enemy))
453: {
454: targ->oldenemy = attacker;
455: return;
456: }
457: targ->oldenemy = targ->enemy;
458: }
459: targ->enemy = attacker;
460: if (!(targ->monsterinfo.aiflags & AI_DUCKED))
461: FoundTarget (targ);
462: return;
463: }
464:
465: // it's the same base (walk/swim/fly) type and a different classname and it's not a tank
466: // (they spray too much), get mad at them
467: // PMM
468: // added medics to this
469: // FIXME -
470: // this really should be turned into an AI flag marking appropriate monsters as "don't shoot me"
471: // this also leads to the problem of tanks and medics being able to, at will, kill monsters with
472: // no chance of retaliation. My vote is to make those monsters who are designed as "don't shoot me"
473: // such that they also ignore being shot by monsters as well
474: /*
475: if (((targ->flags & (FL_FLY|FL_SWIM)) == (attacker->flags & (FL_FLY|FL_SWIM))) &&
476: (strcmp (targ->classname, attacker->classname) != 0) &&
477: (strcmp(attacker->classname, "monster_tank") != 0) &&
478: (strcmp(attacker->classname, "monster_supertank") != 0) &&
479: (strcmp(attacker->classname, "monster_makron") != 0) &&
480: (strcmp(attacker->classname, "monster_jorg") != 0) &&
481: (strcmp(attacker->classname, "monster_carrier") != 0) &&
482: (strncmp(attacker->classname, "monster_medic", 12) != 0) ) // this should get medics & medic_commanders
483: */
484: if (((targ->flags & (FL_FLY|FL_SWIM)) == (attacker->flags & (FL_FLY|FL_SWIM))) &&
485: (strcmp (targ->classname, attacker->classname) != 0) &&
486: !(attacker->monsterinfo.aiflags & AI_IGNORE_SHOTS) &&
487: !(targ->monsterinfo.aiflags & AI_IGNORE_SHOTS) )
488: {
489: if (targ->enemy && targ->enemy->client)
490: targ->oldenemy = targ->enemy;
491: targ->enemy = attacker;
492: if (!(targ->monsterinfo.aiflags & AI_DUCKED))
493: FoundTarget (targ);
494: }
495: // if they *meant* to shoot us, then shoot back
496: else if (attacker->enemy == targ)
497: {
498: if (targ->enemy && targ->enemy->client)
499: targ->oldenemy = targ->enemy;
500: targ->enemy = attacker;
501: if (!(targ->monsterinfo.aiflags & AI_DUCKED))
502: FoundTarget (targ);
503: }
504: // otherwise get mad at whoever they are mad at (help our buddy) unless it is us!
505: else if (attacker->enemy && attacker->enemy != targ)
506: {
507: if (targ->enemy && targ->enemy->client)
508: targ->oldenemy = targ->enemy;
509: targ->enemy = attacker->enemy;
510: if (!(targ->monsterinfo.aiflags & AI_DUCKED))
511: FoundTarget (targ);
512: }
513: }
514:
515: qboolean CheckTeamDamage (edict_t *targ, edict_t *attacker)
516: {
517: //FIXME make the next line real and uncomment this block
518: // if ((ability to damage a teammate == OFF) && (targ's team == attacker's team))
519: return false;
520: }
521:
522: void T_Damage (edict_t *targ, edict_t *inflictor, edict_t *attacker, vec3_t dir, vec3_t point, vec3_t normal, int damage, int knockback, int dflags, int mod)
523: {
524: gclient_t *client;
525: int take;
526: int save;
527: int asave;
528: int psave;
529: int te_sparks;
530: int sphere_notified; // PGM
531:
532: if (!targ->takedamage)
533: return;
534:
535: sphere_notified = false; // PGM
536:
537: // friendly fire avoidance
538: // if enabled you can't hurt teammates (but you can hurt yourself)
539: // knockback still occurs
540: if ((targ != attacker) && ((deathmatch->value && ((int)(dmflags->value) & (DF_MODELTEAMS | DF_SKINTEAMS))) || coop->value))
541: {
542: if (OnSameTeam (targ, attacker))
543: {
544: // PMM - nukes kill everyone
545: if (((int)(dmflags->value) & DF_NO_FRIENDLY_FIRE) && (mod != MOD_NUKE))
546: damage = 0;
547: else
548: mod |= MOD_FRIENDLY_FIRE;
549: }
550: }
551: meansOfDeath = mod;
552:
553: //ROGUE
554: // allow the deathmatch game to change values
555: if (deathmatch->value && gamerules && gamerules->value)
556: {
557: if(DMGame.ChangeDamage)
558: damage = DMGame.ChangeDamage(targ, attacker, damage, mod);
559: if(DMGame.ChangeKnockback)
560: knockback = DMGame.ChangeKnockback(targ, attacker, knockback, mod);
561:
562: if(!damage)
563: return;
564: }
565: //ROGUE
566:
567: // easy mode takes half damage
568: if (skill->value == 0 && deathmatch->value == 0 && targ->client)
569: {
570: damage *= 0.5;
571: if (!damage)
572: damage = 1;
573: }
574:
575: client = targ->client;
576:
577: // PMM - defender sphere takes half damage
578: if ((client) && (client->owned_sphere) && (client->owned_sphere->spawnflags == 1))
579: {
580: damage *= 0.5;
581: if (!damage)
582: damage = 1;
583: }
584:
585: if (dflags & DAMAGE_BULLET)
586: te_sparks = TE_BULLET_SPARKS;
587: else
588: te_sparks = TE_SPARKS;
589:
590: VectorNormalize(dir);
591:
592: // bonus damage for suprising a monster
593: if (!(dflags & DAMAGE_RADIUS) && (targ->svflags & SVF_MONSTER) && (attacker->client) && (!targ->enemy) && (targ->health > 0))
594: damage *= 2;
595:
596: if (targ->flags & FL_NO_KNOCKBACK)
597: knockback = 0;
598:
599: // figure momentum add
600: if (!(dflags & DAMAGE_NO_KNOCKBACK))
601: {
602: if ((knockback) && (targ->movetype != MOVETYPE_NONE) && (targ->movetype != MOVETYPE_BOUNCE) && (targ->movetype != MOVETYPE_PUSH) && (targ->movetype != MOVETYPE_STOP))
603: {
604: vec3_t kvel;
605: float mass;
606:
607: if (targ->mass < 50)
608: mass = 50;
609: else
610: mass = targ->mass;
611:
612: if (targ->client && attacker == targ)
613: VectorScale (dir, 1600.0 * (float)knockback / mass, kvel); // the rocket jump hack...
614: else
615: VectorScale (dir, 500.0 * (float)knockback / mass, kvel);
616:
617: VectorAdd (targ->velocity, kvel, targ->velocity);
618: }
619: }
620:
621: take = damage;
622: save = 0;
623:
624: // check for godmode
625: if ( (targ->flags & FL_GODMODE) && !(dflags & DAMAGE_NO_PROTECTION) )
626: {
627: take = 0;
628: save = damage;
629: SpawnDamage (te_sparks, point, normal, save);
630: }
631:
632: // check for invincibility
633: if ((client && client->invincible_framenum > level.framenum ) && !(dflags & DAMAGE_NO_PROTECTION))
634: {
635: if (targ->pain_debounce_time < level.time)
636: {
637: gi.sound(targ, CHAN_ITEM, gi.soundindex("items/protect4.wav"), 1, ATTN_NORM, 0);
638: targ->pain_debounce_time = level.time + 2;
639: }
640: take = 0;
641: save = damage;
642: }
643: // ROGUE
644: // check for monster invincibility
645: if (((targ->svflags & SVF_MONSTER) && targ->monsterinfo.invincible_framenum > level.framenum ) && !(dflags & DAMAGE_NO_PROTECTION))
646: {
647: if (targ->pain_debounce_time < level.time)
648: {
649: gi.sound(targ, CHAN_ITEM, gi.soundindex("items/protect4.wav"), 1, ATTN_NORM, 0);
650: targ->pain_debounce_time = level.time + 2;
651: }
652: take = 0;
653: save = damage;
654: }
655: // ROGUE
656:
657: psave = CheckPowerArmor (targ, point, normal, take, dflags);
658: take -= psave;
659:
660: asave = CheckArmor (targ, point, normal, take, te_sparks, dflags);
661: take -= asave;
662:
663: //treat cheat/powerup savings the same as armor
664: asave += save;
665:
666: // team damage avoidance
667: if (!(dflags & DAMAGE_NO_PROTECTION) && CheckTeamDamage (targ, attacker))
668: return;
669:
670: // ROGUE - this option will do damage both to the armor and person. originally for DPU rounds
671: if (dflags & DAMAGE_DESTROY_ARMOR)
672: {
673: if(!(targ->flags & FL_GODMODE) && !(dflags & DAMAGE_NO_PROTECTION) &&
674: !(client && client->invincible_framenum > level.framenum))
675: {
676: take = damage;
677: }
678: }
679: // ROGUE
680:
681: // do the damage
682: if (take)
683: {
684: //PGM need more blood for chainfist.
685: if(targ->flags & FL_MECHANICAL)
686: {
687: SpawnDamage ( TE_ELECTRIC_SPARKS, point, normal, take);
688: }
689: else if ((targ->svflags & SVF_MONSTER) || (client))
690: {
691: if(mod == MOD_CHAINFIST)
692: SpawnDamage (TE_MOREBLOOD, point, normal, 255);
693: else
694: SpawnDamage (TE_BLOOD, point, normal, take);
695: }
696: else
697: SpawnDamage (te_sparks, point, normal, take);
698: //PGM
699:
700: targ->health = targ->health - take;
701:
702: //PGM - spheres need to know who to shoot at
703: if(client && client->owned_sphere)
704: {
705: sphere_notified = true;
706: if(client->owned_sphere->pain)
707: client->owned_sphere->pain (client->owned_sphere, attacker, 0, 0);
708: }
709: //PGM
710:
711: if (targ->health <= 0)
712: {
713: if ((targ->svflags & SVF_MONSTER) || (client))
714: targ->flags |= FL_NO_KNOCKBACK;
715: Killed (targ, inflictor, attacker, take, point);
716: return;
717: }
718: }
719:
720: //PGM - spheres need to know who to shoot at
721: if (!sphere_notified)
722: {
723: if(client && client->owned_sphere)
724: {
725: sphere_notified = true;
726: if(client->owned_sphere->pain)
727: client->owned_sphere->pain (client->owned_sphere, attacker, 0, 0);
728: }
729: }
730: //PGM
731:
732: if (targ->svflags & SVF_MONSTER)
733: {
734: M_ReactToDamage (targ, attacker, inflictor);
735: // PMM - fixme - if anyone else but the medic ever uses AI_MEDIC, check for it here instead
736: // of in the medic's pain function
737: if (!(targ->monsterinfo.aiflags & AI_DUCKED) && (take))
738: {
739: targ->pain (targ, attacker, knockback, take);
740: // nightmare mode monsters don't go into pain frames often
741: if (skill->value == 3)
742: targ->pain_debounce_time = level.time + 5;
743: }
744: }
745: else if (client)
746: {
747: if (!(targ->flags & FL_GODMODE) && (take))
748: targ->pain (targ, attacker, knockback, take);
749: }
750: else if (take)
751: {
752: if (targ->pain)
753: targ->pain (targ, attacker, knockback, take);
754: }
755:
756: // add to the damage inflicted on a player this frame
757: // the total will be turned into screen blends and view angle kicks
758: // at the end of the frame
759: if (client)
760: {
761: client->damage_parmor += psave;
762: client->damage_armor += asave;
763: client->damage_blood += take;
764: client->damage_knockback += knockback;
765: VectorCopy (point, client->damage_from);
766: }
767: }
768:
769:
770: /*
771: ============
772: T_RadiusDamage
773: ============
774: */
775: void T_RadiusDamage (edict_t *inflictor, edict_t *attacker, float damage, edict_t *ignore, float radius, int mod)
776: {
777: float points;
778: edict_t *ent = NULL;
779: vec3_t v;
780: vec3_t dir;
781:
782: while ((ent = findradius(ent, inflictor->s.origin, radius)) != NULL)
783: {
784: if (ent == ignore)
785: continue;
786: if (!ent->takedamage)
787: continue;
788:
789: VectorAdd (ent->mins, ent->maxs, v);
790: VectorMA (ent->s.origin, 0.5, v, v);
791: VectorSubtract (inflictor->s.origin, v, v);
792: points = damage - 0.5 * VectorLength (v);
793: if (ent == attacker)
794: points = points * 0.5;
795: if (points > 0)
796: {
797: if (CanDamage (ent, inflictor))
798: {
799: VectorSubtract (ent->s.origin, inflictor->s.origin, dir);
800: T_Damage (ent, inflictor, attacker, dir, inflictor->s.origin, vec3_origin, (int)points, (int)points, DAMAGE_RADIUS, mod);
801: }
802: }
803: }
804: }
805:
806: // **********************
807: // ROGUE
808:
809: /*
810: ============
811: T_RadiusNukeDamage
812:
813: Like T_RadiusDamage, but ignores walls (skips CanDamage check, among others)
814: // up to KILLZONE radius, do 10,000 points
815: // after that, do damage linearly out to KILLZONE2 radius
816: ============
817: */
818:
819: void T_RadiusNukeDamage (edict_t *inflictor, edict_t *attacker, float damage, edict_t *ignore, float radius, int mod)
820: {
821: float points;
822: edict_t *ent = NULL;
823: vec3_t v;
824: vec3_t dir;
825: float len;
826: float killzone, killzone2;
827: trace_t tr;
828: float dist;
829:
830: killzone = radius;
831: killzone2 = radius*2.0;
832:
833: while ((ent = findradius(ent, inflictor->s.origin, killzone2)) != NULL)
834: {
835: // ignore nobody
836: if (ent == ignore)
837: continue;
838: if (!ent->takedamage)
839: continue;
840: if (!ent->inuse)
841: continue;
842: if (!(ent->client || (ent->svflags & SVF_MONSTER) || (ent->svflags & SVF_DAMAGEABLE)))
843: continue;
844:
845: VectorAdd (ent->mins, ent->maxs, v);
846: VectorMA (ent->s.origin, 0.5, v, v);
847: VectorSubtract (inflictor->s.origin, v, v);
848: len = VectorLength(v);
849: if (len <= killzone)
850: {
851: if (ent->client)
852: ent->flags |= FL_NOGIB;
853: points = 10000;
854: }
855: else if (len <= killzone2)
856: points = (damage/killzone)*(killzone2 - len);
857: else
858: points = 0;
859: // points = damage - 0.005 * len*len;
860: // if (ent == attacker)
861: // points = points * 0.5;
862: if ((g_showlogic) && (g_showlogic->value))
863: {
864: if (!(strcmp(ent->classname, "player")))
865: gi.dprintf ("dist = %2.2f doing %6.0f damage to %s\n", len, points, inflictor->teammaster->client->pers.netname);
866: else
867: gi.dprintf ("dist = %2.2f doing %6.0f damage to %s\n", len, points, ent->classname);
868: }
869: if (points > 0)
870: {
871: // if (CanDamage (ent, inflictor))
872: // {
873: if (ent->client)
874: ent->client->nuke_framenum = level.framenum + 20;
875: VectorSubtract (ent->s.origin, inflictor->s.origin, dir);
876: T_Damage (ent, inflictor, attacker, dir, inflictor->s.origin, vec3_origin, (int)points, (int)points, DAMAGE_RADIUS, mod);
877: // }
878: }
879: }
880: ent = g_edicts+1; // skip the worldspawn
881: // cycle through players
882: while (ent)
883: {
884: if ((ent->client) && (ent->client->nuke_framenum != level.framenum+20) && (ent->inuse))
885: {
886: tr = gi.trace (inflictor->s.origin, NULL, NULL, ent->s.origin, inflictor, MASK_SOLID);
887: if (tr.fraction == 1.0)
888: {
889: if ((g_showlogic) && (g_showlogic->value))
890: gi.dprintf ("Undamaged player in LOS with nuke, flashing!\n");
891: ent->client->nuke_framenum = level.framenum + 20;
892: }
893: else
894: {
895: dist = realrange (ent, inflictor);
896: if (dist < 2048)
897: ent->client->nuke_framenum = max(ent->client->nuke_framenum,level.framenum + 15);
898: else
899: ent->client->nuke_framenum = max(ent->client->nuke_framenum,level.framenum + 10);
900: }
901: ent++;
902: }
903: else
904: ent = NULL;
905: }
906: }
907:
908: /*
909: ============
910: T_RadiusClassDamage
911:
912: Like T_RadiusDamage, but ignores anything with classname=ignoreClass
913: ============
914: */
915: void T_RadiusClassDamage (edict_t *inflictor, edict_t *attacker, float damage, char *ignoreClass, float radius, int mod)
916: {
917: float points;
918: edict_t *ent = NULL;
919: vec3_t v;
920: vec3_t dir;
921:
922: while ((ent = findradius(ent, inflictor->s.origin, radius)) != NULL)
923: {
924: if (ent->classname && !strcmp(ent->classname, ignoreClass))
925: continue;
926: if (!ent->takedamage)
927: continue;
928:
929: VectorAdd (ent->mins, ent->maxs, v);
930: VectorMA (ent->s.origin, 0.5, v, v);
931: VectorSubtract (inflictor->s.origin, v, v);
932: points = damage - 0.5 * VectorLength (v);
933: if (ent == attacker)
934: points = points * 0.5;
935: if (points > 0)
936: {
937: if (CanDamage (ent, inflictor))
938: {
939: VectorSubtract (ent->s.origin, inflictor->s.origin, dir);
940: T_Damage (ent, inflictor, attacker, dir, inflictor->s.origin, vec3_origin, (int)points, (int)points, DAMAGE_RADIUS, mod);
941: }
942: }
943: }
944: }
945:
946: // ROGUE
947: // ********************
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.