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