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