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