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