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