Merge branch 'master' into Mario/turrets
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / g_damage.qc
1 #include "g_damage.qh"
2
3 #if defined(CSQC)
4 #elif defined(MENUQC)
5 #elif defined(SVQC)
6     #include "../warpzonelib/common.qh"
7     #include "../common/constants.qh"
8     #include "../common/teams.qh"
9     #include "../common/util.qh"
10     #include "../common/weapons/weapons.qh"
11     #include "weapons/accuracy.qh"
12     #include "weapons/csqcprojectile.qh"
13     #include "weapons/selection.qh"
14     #include "t_items.qh"
15     #include "autocvars.qh"
16     #include "constants.qh"
17     #include "defs.qh"
18     #include "../common/notifications.qh"
19     #include "../common/deathtypes.qh"
20     #include "mutators/mutators_include.qh"
21     #include "../common/turrets/turrets.qh"
22     #include "../common/turrets/sv_turrets.qh"
23     #include "vehicles/vehicles_def.qh"
24     #include "../csqcmodellib/sv_model.qh"
25     #include "../common/playerstats.qh"
26     #include "g_hook.qh"
27     #include "scores.qh"
28     #include "spawnpoints.qh"
29 #endif
30
31 float Damage_DamageInfo_SendEntity(entity to, float sf)
32 {
33         WriteByte(MSG_ENTITY, ENT_CLIENT_DAMAGEINFO);
34         WriteShort(MSG_ENTITY, self.projectiledeathtype);
35         WriteCoord(MSG_ENTITY, floor(self.origin.x));
36         WriteCoord(MSG_ENTITY, floor(self.origin.y));
37         WriteCoord(MSG_ENTITY, floor(self.origin.z));
38         WriteByte(MSG_ENTITY, bound(1, self.dmg, 255));
39         WriteByte(MSG_ENTITY, bound(0, self.dmg_radius, 255));
40         WriteByte(MSG_ENTITY, bound(1, self.dmg_edge, 255));
41         WriteShort(MSG_ENTITY, self.oldorigin.x);
42         WriteByte(MSG_ENTITY, self.species);
43         return true;
44 }
45
46 void Damage_DamageInfo(vector org, float coredamage, float edgedamage, float rad, vector force, float deathtype, float bloodtype, entity dmgowner)
47 {
48         // TODO maybe call this from non-edgedamage too?
49         // TODO maybe make the client do the particle effects for the weapons and the impact sounds using this info?
50
51         entity e;
52
53         if(!sound_allowed(MSG_BROADCAST, dmgowner))
54                 deathtype |= 0x8000;
55
56         e = spawn();
57         setorigin(e, org);
58         e.projectiledeathtype = deathtype;
59         e.dmg = coredamage;
60         e.dmg_edge = edgedamage;
61         e.dmg_radius = rad;
62         e.dmg_force = vlen(force);
63         e.velocity = force;
64         e.oldorigin_x = compressShortVector(e.velocity);
65         e.species = bloodtype;
66
67         Net_LinkEntity(e, false, 0.2, Damage_DamageInfo_SendEntity);
68 }
69
70 float IsFlying(entity a)
71 {
72         if(a.flags & FL_ONGROUND)
73                 return 0;
74         if(a.waterlevel >= WATERLEVEL_SWIMMING)
75                 return 0;
76         traceline(a.origin, a.origin - '0 0 48', MOVE_NORMAL, a);
77         if(trace_fraction < 1)
78                 return 0;
79         return 1;
80 }
81
82 void UpdateFrags(entity player, float f)
83 {
84         PlayerTeamScore_AddScore(player, f);
85 }
86
87 void GiveFrags (entity attacker, entity targ, float f, float deathtype)
88 {
89         // TODO route through PlayerScores instead
90         if(gameover) return;
91
92         if(f < 0)
93         {
94                 if(targ == attacker)
95                 {
96                         // suicide
97                         PlayerScore_Add(attacker, SP_SUICIDES, 1);
98                 }
99                 else
100                 {
101                         // teamkill
102                         PlayerScore_Add(attacker, SP_KILLS, -1); // or maybe add a teamkills field?
103                 }
104         }
105         else
106         {
107                 // regular frag
108                 PlayerScore_Add(attacker, SP_KILLS, 1);
109                 if(targ.playerid)
110                         PS_GR_P_ADDVAL(attacker, sprintf("kills-%d", targ.playerid), 1);
111         }
112
113         PlayerScore_Add(targ, SP_DEATHS, 1);
114
115         if(targ != attacker) // not for suicides
116         if(g_weaponarena_random)
117         {
118                 // after a frag, exchange the current weapon (or the culprit, if detectable) by a new random weapon
119                 float culprit;
120                 culprit = DEATH_WEAPONOF(deathtype);
121                 if(!culprit)
122                         culprit = attacker.weapon;
123                 else if(!(attacker.weapons & WepSet_FromWeapon(culprit)))
124                         culprit = attacker.weapon;
125
126                 if(g_weaponarena_random_with_blaster && culprit == WEP_BLASTER) // WEAPONTODO: Shouldn't this be in a mutator?
127                 {
128                         // no exchange
129                 }
130                 else
131                 {
132                         if(!GiveFrags_randomweapons)
133                         {
134                                 GiveFrags_randomweapons = spawn();
135                                 GiveFrags_randomweapons.classname = "GiveFrags_randomweapons";
136                         }
137
138                         if(warmup_stage)
139                                 GiveFrags_randomweapons.weapons = WARMUP_START_WEAPONS;
140                         else
141                                 GiveFrags_randomweapons.weapons = start_weapons;
142
143                         // all others (including the culprit): remove
144                         GiveFrags_randomweapons.weapons &= ~attacker.weapons;
145                         GiveFrags_randomweapons.weapons &= ~WepSet_FromWeapon(culprit);
146
147                         // among the remaining ones, choose one by random
148                         W_RandomWeapons(GiveFrags_randomweapons, 1);
149
150                         if(GiveFrags_randomweapons.weapons)
151                         {
152                                 attacker.weapons |= GiveFrags_randomweapons.weapons;
153                                 attacker.weapons &= ~WepSet_FromWeapon(culprit);
154                         }
155                 }
156
157                 // after a frag, choose another random weapon set
158                 if (!(attacker.weapons & WepSet_FromWeapon(attacker.weapon)))
159                         W_SwitchWeapon_Force(attacker, w_getbestweapon(attacker));
160         }
161
162         // FIXME fix the mess this is (we have REAL points now!)
163         entity oldself;
164         oldself = self;
165         self = attacker;
166         frag_attacker = attacker;
167         frag_target = targ;
168         frag_score = f;
169         if(MUTATOR_CALLHOOK(GiveFragsForKill))
170         {
171                 f = frag_score;
172                 self = oldself;
173         }
174         else
175         {
176                 self = oldself;
177         }
178
179         attacker.totalfrags += f;
180
181         if(f)
182                 UpdateFrags(attacker, f);
183 }
184
185 string AppendItemcodes(string s, entity player)
186 {
187         float w;
188         w = player.weapon;
189         //if(w == 0)
190         //      w = player.switchweapon;
191         if(w == 0)
192                 w = player.cnt; // previous weapon!
193         s = strcat(s, ftos(w));
194         if(time < player.strength_finished)
195                 s = strcat(s, "S");
196         if(time < player.invincible_finished)
197                 s = strcat(s, "I");
198         if(player.flagcarried != world)
199                 s = strcat(s, "F");
200         if(player.BUTTON_CHAT)
201                 s = strcat(s, "T");
202         if(player.kh_next)
203                 s = strcat(s, "K");
204         return s;
205 }
206
207 void LogDeath(string mode, float deathtype, entity killer, entity killed)
208 {
209         string s;
210         if(!autocvar_sv_eventlog)
211                 return;
212         s = strcat(":kill:", mode);
213         s = strcat(s, ":", ftos(killer.playerid));
214         s = strcat(s, ":", ftos(killed.playerid));
215         s = strcat(s, ":type=", Deathtype_Name(deathtype));
216         s = strcat(s, ":items=");
217         s = AppendItemcodes(s, killer);
218         if(killed != killer)
219         {
220                 s = strcat(s, ":victimitems=");
221                 s = AppendItemcodes(s, killed);
222         }
223         GameLogEcho(s);
224 }
225
226 void Obituary_SpecialDeath(
227         entity notif_target,
228         float murder,
229         float deathtype,
230         string s1, string s2, string s3,
231         float f1, float f2, float f3)
232 {
233         if(DEATH_ISSPECIAL(deathtype))
234         {
235                 entity deathent = deathtypes[(deathtype - DT_FIRST)];
236                 if (!deathent) { backtrace("Obituary_SpecialDeath: Could not find deathtype entity!\n"); return; }
237
238                 if(murder)
239                 {
240                         if(deathent.death_msgmurder)
241                         {
242                                 Send_Notification_WOCOVA(
243                                         NOTIF_ONE,
244                                         notif_target,
245                                         MSG_MULTI,
246                                         deathent.death_msgmurder.nent_id,
247                                         s1, s2, s3, "",
248                                         f1, f2, f3, 0
249                                 );
250                                 Send_Notification_WOCOVA(
251                                         NOTIF_ALL_EXCEPT,
252                                         notif_target,
253                                         MSG_INFO,
254                                         deathent.death_msgmurder.nent_msginfo.nent_id,
255                                         s1, s2, s3, "",
256                                         f1, f2, f3, 0
257                                 );
258                         }
259                 }
260                 else
261                 {
262                         if(deathent.death_msgself)
263                         {
264                                 Send_Notification_WOCOVA(
265                                         NOTIF_ONE,
266                                         notif_target,
267                                         MSG_MULTI,
268                                         deathent.death_msgself.nent_id,
269                                         s1, s2, s3, "",
270                                         f1, f2, f3, 0
271                                 );
272                                 Send_Notification_WOCOVA(
273                                         NOTIF_ALL_EXCEPT,
274                                         notif_target,
275                                         MSG_INFO,
276                                         deathent.death_msgself.nent_msginfo.nent_id,
277                                         s1, s2, s3, "",
278                                         f1, f2, f3, 0
279                                 );
280                         }
281                 }
282         }
283         else { backtrace("Obituary_SpecialDeath called without a special deathtype?\n"); return; }
284 }
285
286 float Obituary_WeaponDeath(
287         entity notif_target,
288         float murder,
289         float deathtype,
290         string s1, string s2, string s3,
291         float f1, float f2)
292 {
293         float death_weapon = DEATH_WEAPONOF(deathtype);
294         if(death_weapon)
295         {
296                 w_deathtype = deathtype;
297                 float death_message = WEP_ACTION(death_weapon, ((murder) ? WR_KILLMESSAGE : WR_SUICIDEMESSAGE));
298                 w_deathtype = false;
299
300                 if(death_message)
301                 {
302                         Send_Notification_WOCOVA(
303                                 NOTIF_ONE,
304                                 notif_target,
305                                 MSG_MULTI,
306                                 death_message,
307                                 s1, s2, s3, "",
308                                 f1, f2, 0, 0
309                         );
310                         Send_Notification_WOCOVA(
311                                 NOTIF_ALL_EXCEPT,
312                                 notif_target,
313                                 MSG_INFO,
314                                 msg_multi_notifs[death_message - 1].nent_msginfo.nent_id,
315                                 s1, s2, s3, "",
316                                 f1, f2, 0, 0
317                         );
318                 }
319                 else
320                 {
321                         dprintf(
322                                 "Obituary_WeaponDeath(): ^1Deathtype ^7(%d)^1 has no notification for weapon %d!\n",
323                                 deathtype,
324                                 death_weapon
325                         );
326                 }
327
328                 return true;
329         }
330         return false;
331 }
332
333 void Obituary(entity attacker, entity inflictor, entity targ, float deathtype)
334 {
335         // Sanity check
336         if (!IS_PLAYER(targ)) { backtrace("Obituary called on non-player?!\n"); return; }
337
338         // Declarations
339         float notif_firstblood = false;
340         float kill_count_to_attacker, kill_count_to_target;
341
342         // Set final information for the death
343         targ.death_origin = targ.origin;
344         if(targ != attacker) { targ.killer_origin = attacker.origin; }
345         string deathlocation = (autocvar_notification_server_allows_location ? NearestLocation(targ.death_origin) : "");
346
347         #ifdef NOTIFICATIONS_DEBUG
348         Debug_Notification(
349                 sprintf(
350                         "Obituary(%s, %s, %s, %s = %d);\n",
351                         attacker.netname,
352                         inflictor.netname,
353                         targ.netname,
354                         Deathtype_Name(deathtype),
355                         deathtype
356                 )
357         );
358         #endif
359
360         // =======
361         // SUICIDE
362         // =======
363         if(targ == attacker)
364         {
365                 if(DEATH_ISSPECIAL(deathtype))
366                 {
367                         if(deathtype == DEATH_TEAMCHANGE || deathtype == DEATH_AUTOTEAMCHANGE)
368                         {
369                                 Obituary_SpecialDeath(targ, false, deathtype, targ.netname, deathlocation, "", targ.team, 0, 0);
370                         }
371                         else
372                         {
373                                 switch(deathtype)
374                                 {
375                                         case DEATH_MIRRORDAMAGE:
376                                         {
377                                                 Obituary_SpecialDeath(targ, false, deathtype, targ.netname, deathlocation, "", targ.killcount, 0, 0);
378                                                 break;
379                                         }
380
381                                         default:
382                                         {
383                                                 Obituary_SpecialDeath(targ, false, deathtype, targ.netname, deathlocation, "", targ.killcount, 0, 0);
384                                                 break;
385                                         }
386                                 }
387                         }
388                 }
389                 else if (!Obituary_WeaponDeath(targ, false, deathtype, targ.netname, deathlocation, "", targ.killcount, 0))
390                 {
391                         backtrace("SUICIDE: what the hell happened here?\n");
392                         return;
393                 }
394                 LogDeath("suicide", deathtype, targ, targ);
395                 GiveFrags(attacker, targ, -1, deathtype);
396         }
397
398         // ======
399         // MURDER
400         // ======
401         else if(IS_PLAYER(attacker))
402         {
403                 if(SAME_TEAM(attacker, targ))
404                 {
405                         LogDeath("tk", deathtype, attacker, targ);
406                         GiveFrags(attacker, targ, -1, deathtype);
407
408                         attacker.killcount = 0;
409
410                         Send_Notification(NOTIF_ONE, attacker, MSG_CENTER, CENTER_DEATH_TEAMKILL_FRAG, targ.netname);
411                         Send_Notification(NOTIF_ONE, targ, MSG_CENTER, CENTER_DEATH_TEAMKILL_FRAGGED, attacker.netname);
412                         Send_Notification(NOTIF_ALL, world, MSG_INFO, APP_TEAM_NUM_4(targ.team, INFO_DEATH_TEAMKILL_), targ.netname, attacker.netname, deathlocation, targ.killcount);
413
414                         // In this case, the death message will ALWAYS be "foo was betrayed by bar"
415                         // No need for specific death/weapon messages...
416                 }
417                 else
418                 {
419                         LogDeath("frag", deathtype, attacker, targ);
420                         GiveFrags(attacker, targ, 1, deathtype);
421
422                         attacker.taunt_soundtime = time + 1;
423                         attacker.killcount = attacker.killcount + 1;
424
425                         #define SPREE_ITEM(counta,countb,center,normal,gentle) \
426                                 case counta: \
427                                 { \
428                                         Send_Notification(NOTIF_ONE, attacker, MSG_ANNCE, ANNCE_KILLSTREAK_##countb); \
429                                         PS_GR_P_ADDVAL(attacker, PLAYERSTATS_ACHIEVEMENT_KILL_SPREE_##counta, 1); \
430                                         break; \
431                                 }
432                         switch(attacker.killcount)
433                         {
434                                 KILL_SPREE_LIST
435                                 default: break;
436                         }
437                         #undef SPREE_ITEM
438
439                         if(!checkrules_firstblood)
440                         {
441                                 checkrules_firstblood = true;
442                                 notif_firstblood = true; // modify the current messages so that they too show firstblood information
443                                 PS_GR_P_ADDVAL(attacker, PLAYERSTATS_ACHIEVEMENT_FIRSTBLOOD, 1);
444                                 PS_GR_P_ADDVAL(targ, PLAYERSTATS_ACHIEVEMENT_FIRSTVICTIM, 1);
445
446                                 // tell spree_inf and spree_cen that this is a first-blood and first-victim event
447                                 kill_count_to_attacker = -1;
448                                 kill_count_to_target = -2;
449                         }
450                         else
451                         {
452                                 kill_count_to_attacker = attacker.killcount;
453                                 kill_count_to_target = 0;
454                         }
455
456                         if(targ.istypefrag)
457                         {
458                                 Send_Notification(
459                                         NOTIF_ONE,
460                                         attacker,
461                                         MSG_CHOICE,
462                                         CHOICE_TYPEFRAG,
463                                         targ.netname,
464                                         kill_count_to_attacker,
465                                         (IS_BOT_CLIENT(targ) ? NO_MSG : targ.ping)
466                                 );
467                                 Send_Notification(
468                                         NOTIF_ONE,
469                                         targ,
470                                         MSG_CHOICE,
471                                         CHOICE_TYPEFRAGGED,
472                                         attacker.netname,
473                                         kill_count_to_target,
474                                         attacker.health,
475                                         attacker.armorvalue,
476                                         (IS_BOT_CLIENT(attacker) ? NO_MSG : attacker.ping)
477                                 );
478                         }
479                         else
480                         {
481                                 Send_Notification(
482                                         NOTIF_ONE,
483                                         attacker,
484                                         MSG_CHOICE,
485                                         CHOICE_FRAG,
486                                         targ.netname,
487                                         kill_count_to_attacker,
488                                         (IS_BOT_CLIENT(targ) ? NO_MSG : targ.ping)
489                                 );
490                                 Send_Notification(
491                                         NOTIF_ONE,
492                                         targ,
493                                         MSG_CHOICE,
494                                         CHOICE_FRAGGED,
495                                         attacker.netname,
496                                         kill_count_to_target,
497                                         attacker.health,
498                                         attacker.armorvalue,
499                                         (IS_BOT_CLIENT(attacker) ? NO_MSG : attacker.ping)
500                                 );
501                         }
502
503                         if (!Obituary_WeaponDeath(targ, true, deathtype, targ.netname, attacker.netname, deathlocation, targ.killcount, kill_count_to_attacker))
504                                 Obituary_SpecialDeath(targ, true, deathtype, targ.netname, attacker.netname, deathlocation, targ.killcount, kill_count_to_attacker, 0);
505                 }
506         }
507
508         // =============
509         // ACCIDENT/TRAP
510         // =============
511         else
512         {
513                 switch(deathtype)
514                 {
515                         // For now, we're just forcing HURTTRIGGER to behave as "DEATH_VOID" and giving it no special options...
516                         // Later on you will only be able to make custom messages using DEATH_CUSTOM,
517                         // and there will be a REAL DEATH_VOID implementation which mappers will use.
518                         /*case DEATH_HURTTRIGGER:
519                         {
520                                 s1 = targ.netname;
521                                 s2 = inflictor.message;
522                                 if(strstrofs(s2, "%", 0) < 0) { s2 = strcat("%s ", s2); }
523                                 break;
524                         }*/
525
526                         case DEATH_CUSTOM:
527                         {
528                                 Obituary_SpecialDeath(targ, false, deathtype,
529                                         targ.netname,
530                                         ((strstrofs(deathmessage, "%", 0) < 0) ? strcat("%s ", deathmessage) : deathmessage),
531                                         deathlocation,
532                                         targ.killcount,
533                                         0,
534                                         0);
535                                 break;
536                         }
537
538                         default:
539                         {
540                                 Obituary_SpecialDeath(targ, false, deathtype, targ.netname, deathlocation, "", targ.killcount, 0, 0);
541                                 break;
542                         }
543                 }
544
545                 LogDeath("accident", deathtype, targ, targ);
546                 GiveFrags(targ, targ, -1, deathtype);
547
548                 if(PlayerScore_Add(targ, SP_SCORE, 0) == -5)
549                 {
550                         Send_Notification(NOTIF_ONE, targ, MSG_ANNCE, ANNCE_ACHIEVEMENT_BOTLIKE);
551                         PS_GR_P_ADDVAL(attacker, PLAYERSTATS_ACHIEVEMENT_BOTLIKE, 1);
552                 }
553         }
554
555         // reset target kill count
556         if(targ.killcount) { targ.killcount = 0; }
557 }
558
559 void Ice_Think()
560 {
561         if(!self.owner.frozen || self.owner.iceblock != self)
562         {
563                 remove(self);
564                 return;
565         }
566         setorigin(self, self.owner.origin - '0 0 16');
567         self.nextthink = time;
568 }
569
570 void Freeze (entity targ, float freeze_time, float frozen_type, float show_waypoint)
571 {
572         if(!IS_PLAYER(targ) && !(targ.flags & FL_MONSTER)) // only specified entities can be freezed
573                 return;
574
575         if(targ.frozen)
576                 return;
577
578         float targ_maxhealth = ((targ.flags & FL_MONSTER) ? targ.max_health : start_health);
579
580         targ.frozen = frozen_type;
581         targ.revive_progress = ((frozen_type == 3) ? 1 : 0);
582         targ.health = ((frozen_type == 3) ? targ_maxhealth : 1);
583         targ.revive_speed = freeze_time;
584
585         entity ice, head;
586         ice = spawn();
587         ice.owner = targ;
588         ice.classname = "ice";
589         ice.scale = targ.scale;
590         ice.think = Ice_Think;
591         ice.nextthink = time;
592         ice.frame = floor(random() * 21); // ice model has 20 different looking frames
593         setmodel(ice, "models/ice/ice.md3");
594         ice.alpha = 1;
595         ice.colormod = Team_ColorRGB(targ.team);
596         ice.glowmod = ice.colormod;
597         targ.iceblock = ice;
598         targ.revival_time = 0;
599
600         entity oldself;
601         oldself = self;
602         self = ice;
603         Ice_Think();
604         self = oldself;
605
606         RemoveGrapplingHook(targ);
607
608         FOR_EACH_PLAYER(head)
609         if(head.hook.aiment == targ)
610                 RemoveGrapplingHook(head);
611
612         // add waypoint
613         if(show_waypoint)
614                 WaypointSprite_Spawn("frozen", 0, 0, targ, '0 0 64', world, targ.team, targ, waypointsprite_attached, true, RADARICON_WAYPOINT, '0.25 0.90 1');
615 }
616
617 void Unfreeze (entity targ)
618 {
619         if(targ.frozen && targ.frozen != 3) // only reset health if target was frozen
620                 targ.health = ((IS_PLAYER(targ)) ? start_health : targ.max_health);
621
622         entity head;
623         targ.frozen = 0;
624         targ.revive_progress = 0;
625         targ.revival_time = time;
626
627         WaypointSprite_Kill(targ.waypointsprite_attached);
628
629         FOR_EACH_PLAYER(head)
630         if(head.hook.aiment == targ)
631                 RemoveGrapplingHook(head);
632
633         // remove the ice block
634         if(targ.iceblock)
635                 remove(targ.iceblock);
636         targ.iceblock = world;
637 }
638
639 void Damage (entity targ, entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
640 {
641         float mirrordamage;
642         float mirrorforce;
643         float complainteamdamage = 0;
644         entity attacker_save;
645         mirrordamage = 0;
646         mirrorforce = 0;
647
648         if (gameover || targ.killcount == -666)
649                 return;
650
651         entity oldself;
652         oldself = self;
653         self = targ;
654         damage_targ = targ;
655         damage_inflictor = inflictor;
656         damage_attacker = attacker;
657                 attacker_save = attacker;
658
659         if(IS_PLAYER(targ))
660                 if(targ.hook)
661                         if(targ.hook.aiment)
662                                 if(targ.hook.aiment == attacker)
663                                         RemoveGrapplingHook(targ); // STOP THAT, you parasite!
664
665         // special rule: gravity bomb does not hit team mates (other than for disconnecting the hook)
666         if(DEATH_ISWEAPON(deathtype, WEP_HOOK) || DEATH_ISWEAPON(deathtype, WEP_TUBA))
667         {
668                 if(IS_PLAYER(targ))
669                         if(SAME_TEAM(targ, attacker))
670                         {
671                                 self = oldself;
672                                 return;
673                         }
674         }
675
676         if(deathtype == DEATH_KILL || deathtype == DEATH_TEAMCHANGE || deathtype == DEATH_AUTOTEAMCHANGE)
677         {
678                 // exit the vehicle before killing (fixes a crash)
679                 if(IS_PLAYER(targ) && targ.vehicle)
680                         vehicles_exit(VHEF_RELESE);
681
682                 // These are ALWAYS lethal
683                 // No damage modification here
684                 // Instead, prepare the victim for his death...
685                 targ.armorvalue = 0;
686                 targ.spawnshieldtime = 0;
687                 targ.health = 0.9; // this is < 1
688                 targ.flags -= targ.flags & FL_GODMODE;
689                 damage = 100000;
690         }
691         else if(deathtype == DEATH_MIRRORDAMAGE || deathtype == DEATH_NOAMMO)
692         {
693                 // no processing
694         }
695         else
696         {
697                 // nullify damage if teamplay is on
698                 if(deathtype != DEATH_TELEFRAG)
699                 if(IS_PLAYER(attacker))
700                 {
701                         if(IS_PLAYER(targ) && targ != attacker && (IS_INDEPENDENT_PLAYER(attacker) || IS_INDEPENDENT_PLAYER(targ)))
702                         {
703                                 damage = 0;
704                                 force = '0 0 0';
705                         }
706                         else if(SAME_TEAM(attacker, targ))
707                         {
708                                 if(autocvar_teamplay_mode == 1)
709                                         damage = 0;
710                                 else if(attacker != targ)
711                                 {
712                                         if(autocvar_teamplay_mode == 3)
713                                                 damage = 0;
714                                         else if(autocvar_teamplay_mode == 4)
715                                         {
716                                                 if(IS_PLAYER(targ) && targ.deadflag == DEAD_NO)
717                                                 {
718                                                         attacker.dmg_team = attacker.dmg_team + damage;
719                                                         complainteamdamage = attacker.dmg_team - autocvar_g_teamdamage_threshold;
720                                                         if(complainteamdamage > 0)
721                                                                 mirrordamage = autocvar_g_mirrordamage * complainteamdamage;
722                                                         mirrorforce = autocvar_g_mirrordamage * vlen(force);
723                                                         damage = autocvar_g_friendlyfire * damage;
724                                                         // mirrordamage will be used LATER
725
726                                                         if(autocvar_g_mirrordamage_virtual)
727                                                         {
728                                                                 vector v  = healtharmor_applydamage(attacker.armorvalue, autocvar_g_balance_armor_blockpercent, deathtype, mirrordamage);
729                                                                 attacker.dmg_take += v.x;
730                                                                 attacker.dmg_save += v.y;
731                                                                 attacker.dmg_inflictor = inflictor;
732                                                                 mirrordamage = v.z;
733                                                                 mirrorforce = 0;
734                                                         }
735
736                                                         if(autocvar_g_friendlyfire_virtual)
737                                                         {
738                                                                 vector v = healtharmor_applydamage(targ.armorvalue, autocvar_g_balance_armor_blockpercent, deathtype, damage);
739                                                                 targ.dmg_take += v.x;
740                                                                 targ.dmg_save += v.y;
741                                                                 targ.dmg_inflictor = inflictor;
742                                                                 damage = 0;
743                                                                 if(!autocvar_g_friendlyfire_virtual_force)
744                                                                         force = '0 0 0';
745                                                         }
746                                                 }
747                                                 else
748                                                         damage = 0;
749                                         }
750                                 }
751                         }
752                 }
753
754                 if (!DEATH_ISSPECIAL(deathtype))
755                 {
756                         damage *= g_weapondamagefactor;
757                         mirrordamage *= g_weapondamagefactor;
758                         complainteamdamage *= g_weapondamagefactor;
759                         force = force * g_weaponforcefactor;
760                         mirrorforce *= g_weaponforcefactor;
761                 }
762
763                 // should this be changed at all? If so, in what way?
764                 frag_attacker = attacker;
765                 frag_target = targ;
766                 frag_damage = damage;
767                 frag_force = force;
768                 frag_deathtype = deathtype;
769                 frag_mirrordamage = mirrordamage;
770                 MUTATOR_CALLHOOK(PlayerDamage_Calculate);
771                 damage = frag_damage;
772                 mirrordamage = frag_mirrordamage;
773                 force = frag_force;
774
775                 if(targ.frozen)
776                 if(deathtype != DEATH_HURTTRIGGER && deathtype != DEATH_TEAMCHANGE && deathtype != DEATH_AUTOTEAMCHANGE)
777                 {
778                         if(autocvar_g_freezetag_revive_falldamage > 0)
779                         if(deathtype == DEATH_FALL)
780                         if(damage >= autocvar_g_freezetag_revive_falldamage)
781                         {
782                                 Unfreeze(targ);
783                                 targ.health = autocvar_g_freezetag_revive_falldamage_health;
784                                 pointparticles(particleeffectnum("iceorglass"), targ.origin, '0 0 0', 3);
785                                 Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_FREEZETAG_REVIVED_FALL, targ.netname);
786                                 Send_Notification(NOTIF_ONE, targ, MSG_CENTER, CENTER_FREEZETAG_REVIVE_SELF);
787                         }
788
789                         damage = 0;
790                         force *= autocvar_g_freezetag_frozen_force;
791                 }
792
793                 if(targ.frozen && deathtype == DEATH_HURTTRIGGER && !autocvar_g_freezetag_frozen_damage_trigger)
794                 {
795                         pointparticles(particleeffectnum("teleport"), targ.origin, '0 0 0', 1);
796
797                         entity oldself = self;
798                         self = targ;
799                         entity spot = SelectSpawnPoint (false);
800
801                         if(spot)
802                         {
803                                 damage = 0;
804                                 self.deadflag = DEAD_NO;
805
806                                 self.angles = spot.angles;
807
808                                 self.effects = 0;
809                                 self.effects |= EF_TELEPORT_BIT;
810
811                                 self.angles_z = 0; // never spawn tilted even if the spot says to
812                                 self.fixangle = true; // turn this way immediately
813                                 self.velocity = '0 0 0';
814                                 self.avelocity = '0 0 0';
815                                 self.punchangle = '0 0 0';
816                                 self.punchvector = '0 0 0';
817                                 self.oldvelocity = self.velocity;
818
819                                 self.spawnorigin = spot.origin;
820                                 setorigin (self, spot.origin + '0 0 1' * (1 - self.mins.z - 24));
821                                 // don't reset back to last position, even if new position is stuck in solid
822                                 self.oldorigin = self.origin;
823                                 self.prevorigin = self.origin;
824
825                                 pointparticles(particleeffectnum("teleport"), self.origin, '0 0 0', 1);
826                         }
827
828                         self = oldself;
829                 }
830
831                 if(!g_instagib)
832                 {
833                         // apply strength multiplier
834                         if (attacker.items & IT_STRENGTH)
835                         {
836                                 if(targ == attacker)
837                                 {
838                                         damage = damage * autocvar_g_balance_powerup_strength_selfdamage;
839                                         force = force * autocvar_g_balance_powerup_strength_selfforce;
840                                 }
841                                 else
842                                 {
843                                         damage = damage * autocvar_g_balance_powerup_strength_damage;
844                                         force = force * autocvar_g_balance_powerup_strength_force;
845                                 }
846                         }
847
848                         // apply invincibility multiplier
849                         if (targ.items & IT_INVINCIBLE)
850                                 damage = damage * autocvar_g_balance_powerup_invincible_takedamage;
851                 }
852
853                 if (targ == attacker)
854                         damage = damage * autocvar_g_balance_selfdamagepercent; // Partial damage if the attacker hits himself
855
856                 // count the damage
857                 if(attacker)
858                 if(!targ.deadflag)
859                 if(deathtype != DEATH_BUFF_VENGEANCE)
860                 if(targ.takedamage == DAMAGE_AIM)
861                 if(targ != attacker)
862                 {
863                         entity victim;
864                         if((targ.vehicle_flags & VHF_ISVEHICLE) && targ.owner)
865                                 victim = targ.owner;
866                         else
867                                 victim = targ;
868
869                         if(IS_PLAYER(victim) || ((victim.turret_flags & TUR_FLAG_ISTURRET) && victim.active == ACTIVE_ACTIVE) || (victim.flags & FL_MONSTER))
870                         {
871                                 if(DIFF_TEAM(victim, attacker) && !victim.frozen)
872                                 {
873                                         if(damage > 0)
874                                         {
875                                                 if(deathtype != DEATH_FIRE)
876                                                 {
877                                                         if(victim.BUTTON_CHAT)
878                                                                 attacker.typehitsound += 1;
879                                                         else
880                                                                 attacker.damage_dealt += damage;
881                                                 }
882
883                                                 damage_goodhits += 1;
884                                                 damage_gooddamage += damage;
885
886                                                 if (!DEATH_ISSPECIAL(deathtype))
887                                                 {
888                                                         if(IS_PLAYER(targ)) // don't do this for vehicles
889                                                         if(IsFlying(victim))
890                                                                 yoda = 1;
891                                                 }
892                                         }
893                                 }
894                                 else
895                                 {
896                                         if(deathtype != DEATH_FIRE)
897                                         {
898                                                 attacker.typehitsound += 1;
899                                         }
900                                         if(complainteamdamage > 0)
901                                                 if(time > attacker.teamkill_complain)
902                                                 {
903                                                         attacker.teamkill_complain = time + 5;
904                                                         attacker.teamkill_soundtime = time + 0.4;
905                                                         attacker.teamkill_soundsource = targ;
906                                                 }
907                                 }
908                         }
909                 }
910         }
911
912         // apply push
913         if (self.damageforcescale)
914         if (vlen(force))
915         if (!IS_PLAYER(self) || time >= self.spawnshieldtime || self == attacker)
916         {
917                 vector farce = damage_explosion_calcpush(self.damageforcescale * force, self.velocity, autocvar_g_balance_damagepush_speedfactor);
918                 if(self.movetype == MOVETYPE_PHYSICS)
919                 {
920                         entity farcent;
921                         farcent = spawn();
922                         farcent.classname = "farce";
923                         farcent.enemy = self;
924                         farcent.movedir = farce * 10;
925                         if(self.mass)
926                                 farcent.movedir = farcent.movedir * self.mass;
927                         farcent.origin = hitloc;
928                         farcent.forcetype = FORCETYPE_FORCEATPOS;
929                         farcent.nextthink = time + 0.1;
930                         farcent.think = SUB_Remove;
931                 }
932                 else
933                         self.velocity = self.velocity + farce;
934                 self.flags &= ~FL_ONGROUND;
935                 UpdateCSQCProjectile(self);
936         }
937         // apply damage
938         if (damage != 0 || (self.damageforcescale && vlen(force)))
939         if (self.event_damage)
940                 self.event_damage (inflictor, attacker, damage, deathtype, hitloc, force);
941         self = oldself;
942
943         // apply mirror damage if any
944         if(mirrordamage > 0 || mirrorforce > 0)
945         {
946                 attacker = attacker_save;
947
948                 force = normalize(attacker.origin + attacker.view_ofs - hitloc) * mirrorforce;
949                 Damage(attacker, inflictor, attacker, mirrordamage, DEATH_MIRRORDAMAGE, attacker.origin, force);
950         }
951 }
952
953 float RadiusDamageForSource (entity inflictor, vector inflictororigin, vector inflictorvelocity, entity attacker, float coredamage, float edgedamage, float rad, entity cantbe, entity mustbe, float inflictorselfdamage, float forceintensity, float deathtype, entity directhitentity)
954         // Returns total damage applies to creatures
955 {
956         entity  targ;
957         vector  force;
958         float   total_damage_to_creatures;
959         entity  next;
960         float   tfloordmg;
961         float   tfloorforce;
962
963         float stat_damagedone;
964
965         if(RadiusDamage_running)
966         {
967                 backtrace("RadiusDamage called recursively! Expect stuff to go HORRIBLY wrong.");
968                 return 0;
969         }
970
971         RadiusDamage_running = 1;
972
973         tfloordmg = autocvar_g_throughfloor_damage;
974         tfloorforce = autocvar_g_throughfloor_force;
975
976         total_damage_to_creatures = 0;
977
978         if(deathtype != (WEP_HOOK | HITTYPE_SECONDARY | HITTYPE_BOUNCE)) // only send gravity bomb damage once
979                 if(DEATH_WEAPONOF(deathtype) != WEP_TUBA) // do not send tuba damage (bandwidth hog)
980                 {
981                         force = inflictorvelocity;
982                         if(vlen(force) == 0)
983                                 force = '0 0 -1';
984                         else
985                                 force = normalize(force);
986                         if(forceintensity >= 0)
987                                 Damage_DamageInfo(inflictororigin, coredamage, edgedamage, rad, forceintensity * force, deathtype, 0, attacker);
988                         else
989                                 Damage_DamageInfo(inflictororigin, coredamage, edgedamage, -rad, (-forceintensity) * force, deathtype, 0, attacker);
990                 }
991
992         stat_damagedone = 0;
993
994         targ = WarpZone_FindRadius (inflictororigin, rad + MAX_DAMAGEEXTRARADIUS, false);
995         while (targ)
996         {
997                 next = targ.chain;
998                 if ((targ != inflictor) || inflictorselfdamage)
999                 if (((cantbe != targ) && !mustbe) || (mustbe == targ))
1000                 if (targ.takedamage)
1001                 {
1002                         vector nearest;
1003                         vector diff;
1004                         float power;
1005
1006                         // LordHavoc: measure distance to nearest point on target (not origin)
1007                         // (this guarentees 100% damage on a touch impact)
1008                         nearest = targ.WarpZone_findradius_nearest;
1009                         diff = targ.WarpZone_findradius_dist;
1010                         // round up a little on the damage to ensure full damage on impacts
1011                         // and turn the distance into a fraction of the radius
1012                         power = 1 - ((vlen (diff) - bound(MIN_DAMAGEEXTRARADIUS, targ.damageextraradius, MAX_DAMAGEEXTRARADIUS)) / rad);
1013                         //bprint(" ");
1014                         //bprint(ftos(power));
1015                         //if (targ == attacker)
1016                         //      print(ftos(power), "\n");
1017                         if (power > 0)
1018                         {
1019                                 float finaldmg;
1020                                 if (power > 1)
1021                                         power = 1;
1022                                 finaldmg = coredamage * power + edgedamage * (1 - power);
1023                                 if (finaldmg > 0)
1024                                 {
1025                                         float a;
1026                                         float c;
1027                                         vector hitloc;
1028                                         vector myblastorigin;
1029                                         vector center;
1030
1031                                         myblastorigin = WarpZone_TransformOrigin(targ, inflictororigin);
1032
1033                                         // if it's a player, use the view origin as reference
1034                                         center = CENTER_OR_VIEWOFS(targ);
1035
1036                                         force = normalize(center - myblastorigin);
1037                                         force = force * (finaldmg / coredamage) * forceintensity;
1038                                         hitloc = nearest;
1039
1040                                         if(deathtype & WEP_BLASTER)
1041                                                 force *= WEP_CVAR_BOTH(blaster, !(deathtype & HITTYPE_SECONDARY), force_zscale);
1042
1043                                         if(targ != directhitentity)
1044                                         {
1045                                                 float hits;
1046                                                 float total;
1047                                                 float hitratio;
1048                                                 float mininv_f, mininv_d;
1049
1050                                                 // test line of sight to multiple positions on box,
1051                                                 // and do damage if any of them hit
1052                                                 hits = 0;
1053
1054                                                 // we know: max stddev of hitratio = 1 / (2 * sqrt(n))
1055                                                 // so for a given max stddev:
1056                                                 // n = (1 / (2 * max stddev of hitratio))^2
1057
1058                                                 mininv_d = (finaldmg * (1-tfloordmg)) / autocvar_g_throughfloor_damage_max_stddev;
1059                                                 mininv_f = (vlen(force) * (1-tfloorforce)) / autocvar_g_throughfloor_force_max_stddev;
1060
1061                                                 if(autocvar_g_throughfloor_debug)
1062                                                         printf("THROUGHFLOOR: D=%f F=%f max(dD)=1/%f max(dF)=1/%f", finaldmg, vlen(force), mininv_d, mininv_f);
1063
1064
1065                                                 total = 0.25 * pow(max(mininv_f, mininv_d), 2);
1066
1067                                                 if(autocvar_g_throughfloor_debug)
1068                                                         printf(" steps=%f", total);
1069
1070
1071                                                 if (IS_PLAYER(targ))
1072                                                         total = ceil(bound(autocvar_g_throughfloor_min_steps_player, total, autocvar_g_throughfloor_max_steps_player));
1073                                                 else
1074                                                         total = ceil(bound(autocvar_g_throughfloor_min_steps_other, total, autocvar_g_throughfloor_max_steps_other));
1075
1076                                                 if(autocvar_g_throughfloor_debug)
1077                                                         printf(" steps=%f dD=%f dF=%f", total, finaldmg * (1-tfloordmg) / (2 * sqrt(total)), vlen(force) * (1-tfloorforce) / (2 * sqrt(total)));
1078
1079                                                 for(c = 0; c < total; ++c)
1080                                                 {
1081                                                         //traceline(targ.WarpZone_findradius_findorigin, nearest, MOVE_NOMONSTERS, inflictor);
1082                                                         WarpZone_TraceLine(inflictororigin, WarpZone_UnTransformOrigin(targ, nearest), MOVE_NOMONSTERS, inflictor);
1083                                                         if (trace_fraction == 1 || trace_ent == targ)
1084                                                         {
1085                                                                 ++hits;
1086                                                                 if (hits > 1)
1087                                                                         hitloc = hitloc + nearest;
1088                                                                 else
1089                                                                         hitloc = nearest;
1090                                                         }
1091                                                         nearest.x = targ.origin.x + targ.mins.x + random() * targ.size.x;
1092                                                         nearest.y = targ.origin.y + targ.mins.y + random() * targ.size.y;
1093                                                         nearest.z = targ.origin.z + targ.mins.z + random() * targ.size.z;
1094                                                 }
1095
1096                                                 nearest = hitloc * (1 / max(1, hits));
1097                                                 hitratio = (hits / total);
1098                                                 a = bound(0, tfloordmg + (1-tfloordmg) * hitratio, 1);
1099                                                 finaldmg = finaldmg * a;
1100                                                 a = bound(0, tfloorforce + (1-tfloorforce) * hitratio, 1);
1101                                                 force = force * a;
1102
1103                                                 if(autocvar_g_throughfloor_debug)
1104                                                         printf(" D=%f F=%f\n", finaldmg, vlen(force));
1105                                         }
1106
1107                                         //if (targ == attacker)
1108                                         //{
1109                                         //      print("hits ", ftos(hits), " / ", ftos(total));
1110                                         //      print(" finaldmg ", ftos(finaldmg), " force ", vtos(force));
1111                                         //      print(" (", ftos(a), ")\n");
1112                                         //}
1113                                         if(finaldmg || vlen(force))
1114                                         {
1115                                                 if(targ.iscreature)
1116                                                 {
1117                                                         total_damage_to_creatures += finaldmg;
1118
1119                                                         if(accuracy_isgooddamage(attacker, targ))
1120                                                                 stat_damagedone += finaldmg;
1121                                                 }
1122
1123                                                 if(targ == directhitentity || DEATH_ISSPECIAL(deathtype))
1124                                                         Damage (targ, inflictor, attacker, finaldmg, deathtype, nearest, force);
1125                                                 else
1126                                                         Damage (targ, inflictor, attacker, finaldmg, deathtype | HITTYPE_SPLASH, nearest, force);
1127                                         }
1128                                 }
1129                         }
1130                 }
1131                 targ = next;
1132         }
1133
1134         RadiusDamage_running = 0;
1135
1136         if(!DEATH_ISSPECIAL(deathtype))
1137                 accuracy_add(attacker, DEATH_WEAPONOFWEAPONDEATH(deathtype), 0, min(coredamage, stat_damagedone));
1138
1139         return total_damage_to_creatures;
1140 }
1141
1142 float RadiusDamage (entity inflictor, entity attacker, float coredamage, float edgedamage, float rad, entity cantbe, entity mustbe, float forceintensity, float deathtype, entity directhitentity)
1143 {
1144         return RadiusDamageForSource (inflictor, (inflictor.origin + (inflictor.mins + inflictor.maxs) * 0.5), inflictor.velocity, attacker, coredamage, edgedamage, rad, cantbe, mustbe, false, forceintensity, deathtype, directhitentity);
1145 }
1146
1147 float Fire_IsBurning(entity e)
1148 {
1149         return (time < e.fire_endtime);
1150 }
1151
1152 float Fire_AddDamage(entity e, entity o, float d, float t, float dt)
1153 {
1154         float dps;
1155         float maxtime, mintime, maxdamage, mindamage, maxdps, mindps, totaldamage, totaltime;
1156
1157         if(IS_PLAYER(e))
1158         {
1159                 if(e.deadflag)
1160                         return -1;
1161         }
1162         else
1163         {
1164                 if(!e.fire_burner)
1165                 {
1166                         // print("adding a fire burner to ", e.classname, "\n");
1167                         e.fire_burner = spawn();
1168                         e.fire_burner.classname = "fireburner";
1169                         e.fire_burner.think = fireburner_think;
1170                         e.fire_burner.nextthink = time;
1171                         e.fire_burner.owner = e;
1172                 }
1173         }
1174
1175         t = max(t, 0.1);
1176         dps = d / t;
1177         if(Fire_IsBurning(e))
1178         {
1179                 mintime = e.fire_endtime - time;
1180                 maxtime = max(mintime, t);
1181
1182                 mindps = e.fire_damagepersec;
1183                 maxdps = max(mindps, dps);
1184
1185                 if(maxtime > mintime || maxdps > mindps)
1186                 {
1187                         // Constraints:
1188
1189                         // damage we have right now
1190                         mindamage = mindps * mintime;
1191
1192                         // damage we want to get
1193                         maxdamage = mindamage + d;
1194
1195                         // but we can't exceed maxtime * maxdps!
1196                         totaldamage = min(maxdamage, maxtime * maxdps);
1197
1198                         // LEMMA:
1199                         // Look at:
1200                         // totaldamage = min(mindamage + d, maxtime * maxdps)
1201                         // We see:
1202                         // totaldamage <= maxtime * maxdps
1203                         // ==> totaldamage / maxdps <= maxtime.
1204                         // We also see:
1205                         // totaldamage / mindps = min(mindamage / mindps + d, maxtime * maxdps / mindps)
1206                         //                     >= min(mintime, maxtime)
1207                         // ==> totaldamage / maxdps >= mintime.
1208
1209                         /*
1210                         // how long do we damage then?
1211                         // at least as long as before
1212                         // but, never exceed maxdps
1213                         totaltime = max(mintime, totaldamage / maxdps); // always <= maxtime due to lemma
1214                         */
1215
1216                         // alternate:
1217                         // at most as long as maximum allowed
1218                         // but, never below mindps
1219                         totaltime = min(maxtime, totaldamage / mindps); // always >= mintime due to lemma
1220
1221                         // assuming t > mintime, dps > mindps:
1222                         // we get d = t * dps = maxtime * maxdps
1223                         // totaldamage = min(maxdamage, maxtime * maxdps) = min(... + d, maxtime * maxdps) = maxtime * maxdps
1224                         // totaldamage / maxdps = maxtime
1225                         // totaldamage / mindps > totaldamage / maxdps = maxtime
1226                         // FROM THIS:
1227                         // a) totaltime = max(mintime, maxtime) = maxtime
1228                         // b) totaltime = min(maxtime, totaldamage / maxdps) = maxtime
1229
1230                         // assuming t <= mintime:
1231                         // we get maxtime = mintime
1232                         // a) totaltime = max(mintime, ...) >= mintime, also totaltime <= maxtime by the lemma, therefore totaltime = mintime = maxtime
1233                         // b) totaltime = min(maxtime, ...) <= maxtime, also totaltime >= mintime by the lemma, therefore totaltime = mintime = maxtime
1234
1235                         // assuming dps <= mindps:
1236                         // we get mindps = maxdps.
1237                         // With this, the lemma says that mintime <= totaldamage / mindps = totaldamage / maxdps <= maxtime.
1238                         // a) totaltime = max(mintime, totaldamage / maxdps) = totaldamage / maxdps
1239                         // b) totaltime = min(maxtime, totaldamage / mindps) = totaldamage / maxdps
1240
1241                         e.fire_damagepersec = totaldamage / totaltime;
1242                         e.fire_endtime = time + totaltime;
1243                         if(totaldamage > 1.2 * mindamage)
1244                         {
1245                                 e.fire_deathtype = dt;
1246                                 if(e.fire_owner != o)
1247                                 {
1248                                         e.fire_owner = o;
1249                                         e.fire_hitsound = false;
1250                                 }
1251                         }
1252                         if(accuracy_isgooddamage(o, e))
1253                                 accuracy_add(o, DEATH_WEAPONOFWEAPONDEATH(dt), 0, max(0, totaldamage - mindamage));
1254                         return max(0, totaldamage - mindamage); // can never be negative, but to make sure
1255                 }
1256                 else
1257                         return 0;
1258         }
1259         else
1260         {
1261                 e.fire_damagepersec = dps;
1262                 e.fire_endtime = time + t;
1263                 e.fire_deathtype = dt;
1264                 e.fire_owner = o;
1265                 e.fire_hitsound = false;
1266                 if(accuracy_isgooddamage(o, e))
1267                         accuracy_add(o, DEATH_WEAPONOFWEAPONDEATH(dt), 0, d);
1268                 return d;
1269         }
1270 }
1271
1272 void Fire_ApplyDamage(entity e)
1273 {
1274         float t, d, hi, ty;
1275         entity o;
1276
1277         if (!Fire_IsBurning(e))
1278                 return;
1279
1280         for(t = 0, o = e.owner; o.owner && t < 16; o = o.owner, ++t);
1281         if(IS_NOT_A_CLIENT(o))
1282                 o = e.fire_owner;
1283
1284         // water and slime stop fire
1285         if(e.waterlevel)
1286         if(e.watertype != CONTENT_LAVA)
1287                 e.fire_endtime = 0;
1288
1289         // ice stops fire
1290         if(e.frozen)
1291                 e.fire_endtime = 0;
1292
1293         t = min(frametime, e.fire_endtime - time);
1294         d = e.fire_damagepersec * t;
1295
1296         hi = e.fire_owner.damage_dealt;
1297         ty = e.fire_owner.typehitsound;
1298         Damage(e, e, e.fire_owner, d, e.fire_deathtype, e.origin, '0 0 0');
1299         if(e.fire_hitsound && e.fire_owner)
1300         {
1301                 e.fire_owner.damage_dealt = hi;
1302                 e.fire_owner.typehitsound = ty;
1303         }
1304         e.fire_hitsound = true;
1305
1306         if (!IS_INDEPENDENT_PLAYER(e))
1307         if(!e.frozen)
1308         FOR_EACH_PLAYER(other) if(e != other)
1309         {
1310                 if(IS_PLAYER(other))
1311                 if(other.deadflag == DEAD_NO)
1312                 if (!IS_INDEPENDENT_PLAYER(other))
1313                 if(boxesoverlap(e.absmin, e.absmax, other.absmin, other.absmax))
1314                 {
1315                         t = autocvar_g_balance_firetransfer_time * (e.fire_endtime - time);
1316                         d = autocvar_g_balance_firetransfer_damage * e.fire_damagepersec * t;
1317                         Fire_AddDamage(other, o, d, t, DEATH_FIRE);
1318                 }
1319         }
1320 }
1321
1322 void Fire_ApplyEffect(entity e)
1323 {
1324         if(Fire_IsBurning(e))
1325                 e.effects |= EF_FLAME;
1326         else
1327                 e.effects &= ~EF_FLAME;
1328 }
1329
1330 void fireburner_think()
1331 {
1332         // for players, this is done in the regular loop
1333         if(wasfreed(self.owner))
1334         {
1335                 remove(self);
1336                 return;
1337         }
1338         Fire_ApplyEffect(self.owner);
1339         if(!Fire_IsBurning(self.owner))
1340         {
1341                 self.owner.fire_burner = world;
1342                 remove(self);
1343                 return;
1344         }
1345         Fire_ApplyDamage(self.owner);
1346         self.nextthink = time;
1347 }