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 revivespeed, 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 = revivespeed;
 538         if(targ.bot_attack)
 539                 IL_REMOVE(g_bot_targets, targ);
 540         targ.bot_attack = false;
 541         targ.freeze_time = time;
 542
 543         entity ice = new(ice);
 544         ice.owner = targ;
 545         ice.scale = targ.scale;
 546         setthink(ice, Ice_Think);
 547         ice.nextthink = time;
 548         ice.frame = floor(random() * 21); // ice model has 20 different looking frames
 549         setmodel(ice, MDL_ICE);
 550         ice.alpha = 1;
 551         ice.colormod = Team_ColorRGB(targ.team);
 552         ice.glowmod = ice.colormod;
 553         targ.iceblock = ice;
 554         targ.revival_time = 0;
 555
 556         Ice_Think(ice);
 557
 558         RemoveGrapplingHooks(targ);
 559
 560         FOREACH_CLIENT(IS_PLAYER(it),
 561         {
 562                 for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
 563             {
 564                 .entity weaponentity = weaponentities[slot];
 565                 if(it.(weaponentity).hook.aiment == targ)
 566                         RemoveHook(it.(weaponentity).hook);
 567             }
 568         });
 569
 570         // add waypoint
 571         if(show_waypoint)
 572                 WaypointSprite_Spawn(WP_Frozen, 0, 0, targ, '0 0 64', NULL, targ.team, targ, waypointsprite_attached, true, RADARICON_WAYPOINT);
 573 }
 574
 575 void Unfreeze (entity targ)
 576 {
 577         if(!STAT(FROZEN, targ))
 578                 return;
 579
 580         if(STAT(FROZEN, targ) && STAT(FROZEN, targ) != 3) // only reset health if target was frozen
 581         {
 582                 SetResourceAmount(targ, RESOURCE_HEALTH, ((IS_PLAYER(targ)) ? start_health : targ.max_health));
 583                 targ.pauseregen_finished = time + autocvar_g_balance_pause_health_regen;
 584         }
 585
 586         STAT(FROZEN, targ) = 0;
 587         targ.revive_progress = 0;
 588         targ.revival_time = time;
 589         if(!targ.bot_attack)
 590                 IL_PUSH(g_bot_targets, targ);
 591         targ.bot_attack = true;
 592
 593         WaypointSprite_Kill(targ.waypointsprite_attached);
 594
 595         FOREACH_CLIENT(IS_PLAYER(it),
 596         {
 597                 for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
 598             {
 599                 .entity weaponentity = weaponentities[slot];
 600                 if(it.(weaponentity).hook.aiment == targ)
 601                         RemoveHook(it.(weaponentity).hook);
 602             }
 603         });
 604
 605         // remove the ice block
 606         if(targ.iceblock)
 607                 delete(targ.iceblock);
 608         targ.iceblock = NULL;
 609 }
 610
 611 void Damage (entity targ, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
 612 {
 613         float complainteamdamage = 0;
 614         float mirrordamage = 0;
 615         float mirrorforce = 0;
 616
 617         if (game_stopped || (IS_CLIENT(targ) && CS(targ).killcount == FRAGS_SPECTATOR))
 618                 return;
 619
 620         entity attacker_save = attacker;
 621
 622         // special rule: gravity bomb does not hit team mates (other than for disconnecting the hook)
 623         if(DEATH_ISWEAPON(deathtype, WEP_HOOK) || DEATH_ISWEAPON(deathtype, WEP_TUBA))
 624         {
 625                 if(IS_PLAYER(targ) && SAME_TEAM(targ, attacker))
 626                 {
 627                         return;
 628                 }
 629         }
 630
 631         if(deathtype == DEATH_KILL.m_id || deathtype == DEATH_TEAMCHANGE.m_id || deathtype == DEATH_AUTOTEAMCHANGE.m_id)
 632         {
 633                 // exit the vehicle before killing (fixes a crash)
 634                 if(IS_PLAYER(targ) && targ.vehicle)
 635                         vehicles_exit(targ.vehicle, VHEF_RELEASE);
 636
 637                 // These are ALWAYS lethal
 638                 // No damage modification here
 639                 // Instead, prepare the victim for his death...
 640                 SetResourceAmount(targ, RESOURCE_ARMOR, 0);
 641                 targ.spawnshieldtime = 0;
 642                 SetResourceAmount(targ, RESOURCE_HEALTH, 0.9); // this is < 1
 643                 targ.flags -= targ.flags & FL_GODMODE;
 644                 damage = 100000;
 645         }
 646         else if(deathtype == DEATH_MIRRORDAMAGE.m_id || deathtype == DEATH_NOAMMO.m_id)
 647         {
 648                 // no processing
 649         }
 650         else
 651         {
 652                 // nullify damage if teamplay is on
 653                 if(deathtype != DEATH_TELEFRAG.m_id)
 654                 if(IS_PLAYER(attacker))
 655                 {
 656                         if(IS_PLAYER(targ) && targ != attacker && (IS_INDEPENDENT_PLAYER(attacker) || IS_INDEPENDENT_PLAYER(targ)))
 657                         {
 658                                 damage = 0;
 659                                 force = '0 0 0';
 660                         }
 661                         else if(SAME_TEAM(attacker, targ))
 662                         {
 663                                 if(autocvar_teamplay_mode == 1)
 664                                         damage = 0;
 665                                 else if(attacker != targ)
 666                                 {
 667                                         if(autocvar_teamplay_mode == 3)
 668                                                 damage = 0;
 669                                         else if(autocvar_teamplay_mode == 4)
 670                                         {
 671                                                 if(IS_PLAYER(targ) && !IS_DEAD(targ))
 672                                                 {
 673                                                         attacker.dmg_team = attacker.dmg_team + damage;
 674                                                         complainteamdamage = attacker.dmg_team - autocvar_g_teamdamage_threshold;
 675                                                         if(complainteamdamage > 0)
 676                                                                 mirrordamage = autocvar_g_mirrordamage * complainteamdamage;
 677                                                         mirrorforce = autocvar_g_mirrordamage * vlen(force);
 678                                                         damage = autocvar_g_friendlyfire * damage;
 679                                                         // mirrordamage will be used LATER
 680
 681                                                         if(autocvar_g_mirrordamage_virtual)
 682                                                         {
 683                                                                 vector v  = healtharmor_applydamage(attacker.armorvalue, autocvar_g_balance_armor_blockpercent, deathtype, mirrordamage);
 684                                                                 attacker.dmg_take += v.x;
 685                                                                 attacker.dmg_save += v.y;
 686                                                                 attacker.dmg_inflictor = inflictor;
 687                                                                 mirrordamage = v.z;
 688                                                                 mirrorforce = 0;
 689                                                         }
 690
 691                                                         if(autocvar_g_friendlyfire_virtual)
 692                                                         {
 693                                                                 vector v = healtharmor_applydamage(targ.armorvalue, autocvar_g_balance_armor_blockpercent, deathtype, damage);
 694                                                                 targ.dmg_take += v.x;
 695                                                                 targ.dmg_save += v.y;
 696                                                                 targ.dmg_inflictor = inflictor;
 697                                                                 damage = 0;
 698                                                                 if(!autocvar_g_friendlyfire_virtual_force)
 699                                                                         force = '0 0 0';
 700                                                         }
 701                                                 }
 702                                                 else if(!targ.canteamdamage)
 703                                                         damage = 0;
 704                                         }
 705                                 }
 706                         }
 707                 }
 708
 709                 if (!DEATH_ISSPECIAL(deathtype))
 710                 {
 711                         damage *= g_weapondamagefactor;
 712                         mirrordamage *= g_weapondamagefactor;
 713                         complainteamdamage *= g_weapondamagefactor;
 714                         force = force * g_weaponforcefactor;
 715                         mirrorforce *= g_weaponforcefactor;
 716                 }
 717
 718                 // should this be changed at all? If so, in what way?
 719                 MUTATOR_CALLHOOK(Damage_Calculate, inflictor, attacker, targ, deathtype, damage, mirrordamage, force);
 720                 damage = M_ARGV(4, float);
 721                 mirrordamage = M_ARGV(5, float);
 722                 force = M_ARGV(6, vector);
 723
 724                 if(IS_PLAYER(targ) && damage > 0 && attacker)
 725                 {
 726                         for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
 727                     {
 728                         .entity weaponentity = weaponentities[slot];
 729                         if(targ.(weaponentity).hook && targ.(weaponentity).hook.aiment == attacker)
 730                                 RemoveHook(targ.(weaponentity).hook);
 731                     }
 732                 }
 733
 734                 if(STAT(FROZEN, targ))
 735                 if(deathtype != DEATH_HURTTRIGGER.m_id && deathtype != DEATH_TEAMCHANGE.m_id && deathtype != DEATH_AUTOTEAMCHANGE.m_id)
 736                 {
 737                         if(autocvar_g_frozen_revive_falldamage > 0)
 738                         if(deathtype == DEATH_FALL.m_id)
 739                         if(damage >= autocvar_g_frozen_revive_falldamage)
 740                         {
 741                                 Unfreeze(targ);
 742                                 SetResourceAmount(targ, RESOURCE_HEALTH, autocvar_g_frozen_revive_falldamage_health);
 743                                 Send_Effect(EFFECT_ICEORGLASS, targ.origin, '0 0 0', 3);
 744                                 Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_FREEZETAG_REVIVED_FALL, targ.netname);
 745                                 Send_Notification(NOTIF_ONE, targ, MSG_CENTER, CENTER_FREEZETAG_REVIVE_SELF);
 746                         }
 747
 748                         damage = 0;
 749                         force *= autocvar_g_frozen_force;
 750                 }
 751
 752                 if(STAT(FROZEN, targ) && deathtype == DEATH_HURTTRIGGER.m_id && !autocvar_g_frozen_damage_trigger)
 753                 {
 754                         Send_Effect(EFFECT_TELEPORT, targ.origin, '0 0 0', 1);
 755
 756                         entity spot = SelectSpawnPoint (targ, false);
 757
 758                         if(spot)
 759                         {
 760                                 damage = 0;
 761                                 targ.deadflag = DEAD_NO;
 762
 763                                 targ.angles = spot.angles;
 764
 765                                 targ.effects = 0;
 766                                 targ.effects |= EF_TELEPORT_BIT;
 767
 768                                 targ.angles_z = 0; // never spawn tilted even if the spot says to
 769                                 targ.fixangle = true; // turn this way immediately
 770                                 targ.velocity = '0 0 0';
 771                                 targ.avelocity = '0 0 0';
 772                                 targ.punchangle = '0 0 0';
 773                                 targ.punchvector = '0 0 0';
 774                                 targ.oldvelocity = targ.velocity;
 775
 776                                 targ.spawnorigin = spot.origin;
 777                                 setorigin(targ, spot.origin + '0 0 1' * (1 - targ.mins.z - 24));
 778                                 // don't reset back to last position, even if new position is stuck in solid
 779                                 targ.oldorigin = targ.origin;
 780
 781                                 Send_Effect(EFFECT_TELEPORT, targ.origin, '0 0 0', 1);
 782                         }
 783                 }
 784
 785                 if(!g_instagib)
 786                 {
 787                         // apply strength multiplier
 788                         if (attacker.items & ITEM_Strength.m_itemid)
 789                         {
 790                                 if(targ == attacker)
 791                                 {
 792                                         damage = damage * autocvar_g_balance_powerup_strength_selfdamage;
 793                                         force = force * autocvar_g_balance_powerup_strength_selfforce;
 794                                 }
 795                                 else
 796                                 {
 797                                         damage = damage * autocvar_g_balance_powerup_strength_damage;
 798                                         force = force * autocvar_g_balance_powerup_strength_force;
 799                                 }
 800                         }
 801
 802                         // apply invincibility multiplier
 803                         if (targ.items & ITEM_Shield.m_itemid)
 804                                 damage = damage * autocvar_g_balance_powerup_invincible_takedamage;
 805                 }
 806
 807                 if (targ == attacker)
 808                         damage = damage * autocvar_g_balance_selfdamagepercent; // Partial damage if the attacker hits himself
 809
 810                 // count the damage
 811                 if(attacker)
 812                 if(!IS_DEAD(targ))
 813                 if(deathtype != DEATH_BUFF.m_id)
 814                 if(targ.takedamage == DAMAGE_AIM)
 815                 if(targ != attacker)
 816                 {
 817                         entity victim;
 818                         if(IS_VEHICLE(targ) && targ.owner)
 819                                 victim = targ.owner;
 820                         else
 821                                 victim = targ;
 822
 823                         if(IS_PLAYER(victim) || (IS_TURRET(victim) && victim.active == ACTIVE_ACTIVE) || IS_MONSTER(victim) || MUTATOR_CALLHOOK(PlayHitsound, victim, attacker))
 824                         {
 825                                 if(DIFF_TEAM(victim, attacker) && !STAT(FROZEN, victim))
 826                                 {
 827                                         if(damage > 0)
 828                                         {
 829                                                 if(deathtype != DEATH_FIRE.m_id)
 830                                                 {
 831                                                         if(PHYS_INPUT_BUTTON_CHAT(victim))
 832                                                                 attacker.typehitsound += 1;
 833                                                         else
 834                                                                 attacker.damage_dealt += damage;
 835                                                 }
 836
 837                                                 damage_goodhits += 1;
 838                                                 damage_gooddamage += damage;
 839
 840                                                 if (!DEATH_ISSPECIAL(deathtype))
 841                                                 {
 842                                                         if(IS_PLAYER(targ)) // don't do this for vehicles
 843                                                         if(IsFlying(victim))
 844                                                                 yoda = 1;
 845                                                 }
 846                                         }
 847                                 }
 848                                 else if(IS_PLAYER(attacker))
 849                                 {
 850                                         if(deathtype != DEATH_FIRE.m_id)
 851                                         {
 852                                                 attacker.typehitsound += 1;
 853                                         }
 854                                         if(complainteamdamage > 0)
 855                                                 if(time > CS(attacker).teamkill_complain)
 856                                                 {
 857                                                         CS(attacker).teamkill_complain = time + 5;
 858                                                         CS(attacker).teamkill_soundtime = time + 0.4;
 859                                                         CS(attacker).teamkill_soundsource = targ;
 860                                                 }
 861                                 }
 862                         }
 863                 }
 864         }
 865
 866         // apply push
 867         if (targ.damageforcescale)
 868         if (force)
 869         if (!IS_PLAYER(targ) || time >= targ.spawnshieldtime || targ == attacker)
 870         {
 871                 vector farce = damage_explosion_calcpush(targ.damageforcescale * force, targ.velocity, autocvar_g_balance_damagepush_speedfactor);
 872                 if(targ.move_movetype == MOVETYPE_PHYSICS)
 873                 {
 874                         entity farcent = new(farce);
 875                         farcent.enemy = targ;
 876                         farcent.movedir = farce * 10;
 877                         if(targ.mass)
 878                                 farcent.movedir = farcent.movedir * targ.mass;
 879                         farcent.origin = hitloc;
 880                         farcent.forcetype = FORCETYPE_FORCEATPOS;
 881                         farcent.nextthink = time + 0.1;
 882                         setthink(farcent, SUB_Remove);
 883                 }
 884                 else
 885                 {
 886                         targ.velocity = targ.velocity + farce;
 887                 }
 888                 UNSET_ONGROUND(targ);
 889                 UpdateCSQCProjectile(targ);
 890         }
 891         // apply damage
 892         if (damage != 0 || (targ.damageforcescale && force))
 893         if (targ.event_damage)
 894                 targ.event_damage (targ, inflictor, attacker, damage, deathtype, hitloc, force);
 895
 896         // apply mirror damage if any
 897         if(!autocvar_g_mirrordamage_onlyweapons || DEATH_WEAPONOF(deathtype) != WEP_Null)
 898         if(mirrordamage > 0 || mirrorforce > 0)
 899         {
 900                 attacker = attacker_save;
 901
 902                 force = normalize(attacker.origin + attacker.view_ofs - hitloc) * mirrorforce;
 903                 Damage(attacker, inflictor, attacker, mirrordamage, DEATH_MIRRORDAMAGE.m_id, attacker.origin, force);
 904         }
 905 }
 906
 907 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)
 908         // Returns total damage applies to creatures
 909 {
 910         entity  targ;
 911         vector  force;
 912         float   total_damage_to_creatures;
 913         entity  next;
 914         float   tfloordmg;
 915         float   tfloorforce;
 916
 917         float stat_damagedone;
 918
 919         if(RadiusDamage_running)
 920         {
 921                 backtrace("RadiusDamage called recursively! Expect stuff to go HORRIBLY wrong.");
 922                 return 0;
 923         }
 924
 925         RadiusDamage_running = 1;
 926
 927         tfloordmg = autocvar_g_throughfloor_damage;
 928         tfloorforce = autocvar_g_throughfloor_force;
 929
 930         total_damage_to_creatures = 0;
 931
 932         if(deathtype != (WEP_HOOK.m_id | HITTYPE_SECONDARY | HITTYPE_BOUNCE)) // only send gravity bomb damage once
 933                 if(DEATH_WEAPONOF(deathtype) != WEP_TUBA) // do not send tuba damage (bandwidth hog)
 934                 {
 935                         force = inflictorvelocity;
 936                         if(force == '0 0 0')
 937                                 force = '0 0 -1';
 938                         else
 939                                 force = normalize(force);
 940                         if(forceintensity >= 0)
 941                                 Damage_DamageInfo(inflictororigin, coredamage, edgedamage, rad, forceintensity * force, deathtype, 0, attacker);
 942                         else
 943                                 Damage_DamageInfo(inflictororigin, coredamage, edgedamage, -rad, (-forceintensity) * force, deathtype, 0, attacker);
 944                 }
 945
 946         stat_damagedone = 0;
 947
 948         targ = WarpZone_FindRadius (inflictororigin, rad + MAX_DAMAGEEXTRARADIUS, false);
 949         while (targ)
 950         {
 951                 next = targ.chain;
 952                 if ((targ != inflictor) || inflictorselfdamage)
 953                 if (((cantbe != targ) && !mustbe) || (mustbe == targ))
 954                 if (targ.takedamage)
 955                 {
 956                         vector nearest;
 957                         vector diff;
 958                         float power;
 959
 960                         // LordHavoc: measure distance to nearest point on target (not origin)
 961                         // (this guarentees 100% damage on a touch impact)
 962                         nearest = targ.WarpZone_findradius_nearest;
 963                         diff = targ.WarpZone_findradius_dist;
 964                         // round up a little on the damage to ensure full damage on impacts
 965                         // and turn the distance into a fraction of the radius
 966                         power = 1 - ((vlen (diff) - bound(MIN_DAMAGEEXTRARADIUS, targ.damageextraradius, MAX_DAMAGEEXTRARADIUS)) / rad);
 967                         //bprint(" ");
 968                         //bprint(ftos(power));
 969                         //if (targ == attacker)
 970                         //      print(ftos(power), "\n");
 971                         if (power > 0)
 972                         {
 973                                 float finaldmg;
 974                                 if (power > 1)
 975                                         power = 1;
 976                                 finaldmg = coredamage * power + edgedamage * (1 - power);
 977                                 if (finaldmg > 0)
 978                                 {
 979                                         float a;
 980                                         float c;
 981                                         vector hitloc;
 982                                         vector myblastorigin;
 983                                         vector center;
 984
 985                                         myblastorigin = WarpZone_TransformOrigin(targ, inflictororigin);
 986
 987                                         // if it's a player, use the view origin as reference
 988                                         center = CENTER_OR_VIEWOFS(targ);
 989
 990                                         force = normalize(center - myblastorigin);
 991                                         force = force * (finaldmg / coredamage) * forceintensity;
 992                                         hitloc = nearest;
 993
 994                                         if(deathtype & WEP_BLASTER.m_id)
 995                                                 force *= WEP_CVAR_BOTH(blaster, !(deathtype & HITTYPE_SECONDARY), force_zscale);
 996
 997                                         if(targ != directhitentity)
 998                                         {
 999                                                 float hits;
1000                                                 float total;
1001                                                 float hitratio;
1002                                                 float mininv_f, mininv_d;
1003
1004                                                 // test line of sight to multiple positions on box,
1005                                                 // and do damage if any of them hit
1006                                                 hits = 0;
1007
1008                                                 // we know: max stddev of hitratio = 1 / (2 * sqrt(n))
1009                                                 // so for a given max stddev:
1010                                                 // n = (1 / (2 * max stddev of hitratio))^2
1011
1012                                                 mininv_d = (finaldmg * (1-tfloordmg)) / autocvar_g_throughfloor_damage_max_stddev;
1013                                                 mininv_f = (vlen(force) * (1-tfloorforce)) / autocvar_g_throughfloor_force_max_stddev;
1014
1015                                                 if(autocvar_g_throughfloor_debug)
1016                                                         LOG_INFOF("THROUGHFLOOR: D=%f F=%f max(dD)=1/%f max(dF)=1/%f", finaldmg, vlen(force), mininv_d, mininv_f);
1017
1018
1019                                                 total = 0.25 * (max(mininv_f, mininv_d) ** 2);
1020
1021                                                 if(autocvar_g_throughfloor_debug)
1022                                                         LOG_INFOF(" steps=%f", total);
1023
1024
1025                                                 if (IS_PLAYER(targ))
1026                                                         total = ceil(bound(autocvar_g_throughfloor_min_steps_player, total, autocvar_g_throughfloor_max_steps_player));
1027                                                 else
1028                                                         total = ceil(bound(autocvar_g_throughfloor_min_steps_other, total, autocvar_g_throughfloor_max_steps_other));
1029
1030                                                 if(autocvar_g_throughfloor_debug)
1031                                                         LOG_INFOF(" steps=%f dD=%f dF=%f", total, finaldmg * (1-tfloordmg) / (2 * sqrt(total)), vlen(force) * (1-tfloorforce) / (2 * sqrt(total)));
1032
1033                                                 for(c = 0; c < total; ++c)
1034                                                 {
1035                                                         //traceline(targ.WarpZone_findradius_findorigin, nearest, MOVE_NOMONSTERS, inflictor);
1036                                                         WarpZone_TraceLine(inflictororigin, WarpZone_UnTransformOrigin(targ, nearest), MOVE_NOMONSTERS, inflictor);
1037                                                         if (trace_fraction == 1 || trace_ent == targ)
1038                                                         {
1039                                                                 ++hits;
1040                                                                 if (hits > 1)
1041                                                                         hitloc = hitloc + nearest;
1042                                                                 else
1043                                                                         hitloc = nearest;
1044                                                         }
1045                                                         nearest.x = targ.origin.x + targ.mins.x + random() * targ.size.x;
1046                                                         nearest.y = targ.origin.y + targ.mins.y + random() * targ.size.y;
1047                                                         nearest.z = targ.origin.z + targ.mins.z + random() * targ.size.z;
1048                                                 }
1049
1050                                                 nearest = hitloc * (1 / max(1, hits));
1051                                                 hitratio = (hits / total);
1052                                                 a = bound(0, tfloordmg + (1-tfloordmg) * hitratio, 1);
1053                                                 finaldmg = finaldmg * a;
1054                                                 a = bound(0, tfloorforce + (1-tfloorforce) * hitratio, 1);
1055                                                 force = force * a;
1056
1057                                                 if(autocvar_g_throughfloor_debug)
1058                                                         LOG_INFOF(" D=%f F=%f", finaldmg, vlen(force));
1059                                         }
1060
1061                                         //if (targ == attacker)
1062                                         //{
1063                                         //      print("hits ", ftos(hits), " / ", ftos(total));
1064                                         //      print(" finaldmg ", ftos(finaldmg), " force ", vtos(force));
1065                                         //      print(" (", ftos(a), ")\n");
1066                                         //}
1067                                         if(finaldmg || force)
1068                                         {
1069                                                 if(targ.iscreature)
1070                                                 {
1071                                                         total_damage_to_creatures += finaldmg;
1072
1073                                                         if(accuracy_isgooddamage(attacker, targ))
1074                                                                 stat_damagedone += finaldmg;
1075                                                 }
1076
1077                                                 if(targ == directhitentity || DEATH_ISSPECIAL(deathtype))
1078                                                         Damage (targ, inflictor, attacker, finaldmg, deathtype, nearest, force);
1079                                                 else
1080                                                         Damage (targ, inflictor, attacker, finaldmg, deathtype | HITTYPE_SPLASH, nearest, force);
1081                                         }
1082                                 }
1083                         }
1084                 }
1085                 targ = next;
1086         }
1087
1088         RadiusDamage_running = 0;
1089
1090         if(!DEATH_ISSPECIAL(deathtype))
1091                 accuracy_add(attacker, DEATH_WEAPONOF(deathtype).m_id, 0, min(coredamage, stat_damagedone));
1092
1093         return total_damage_to_creatures;
1094 }
1095
1096 float RadiusDamage (entity inflictor, entity attacker, float coredamage, float edgedamage, float rad, entity cantbe, entity mustbe, float forceintensity, int deathtype, entity directhitentity)
1097 {
1098         return RadiusDamageForSource (inflictor, (inflictor.origin + (inflictor.mins + inflictor.maxs) * 0.5), inflictor.velocity, attacker, coredamage, edgedamage, rad, cantbe, mustbe, false, forceintensity, deathtype, directhitentity);
1099 }
1100
1101 float Fire_IsBurning(entity e)
1102 {
1103         return (time < e.fire_endtime);
1104 }
1105
1106 float Fire_AddDamage(entity e, entity o, float d, float t, float dt)
1107 {
1108         float dps;
1109         float maxtime, mintime, maxdamage, mindamage, maxdps, mindps, totaldamage, totaltime;
1110
1111         if(IS_PLAYER(e))
1112         {
1113                 if(IS_DEAD(e))
1114                         return -1;
1115         }
1116         else
1117         {
1118                 if(!e.fire_burner)
1119                 {
1120                         // print("adding a fire burner to ", e.classname, "\n");
1121                         e.fire_burner = new(fireburner);
1122                         setthink(e.fire_burner, fireburner_think);
1123                         e.fire_burner.nextthink = time;
1124                         e.fire_burner.owner = e;
1125                 }
1126         }
1127
1128         t = max(t, 0.1);
1129         dps = d / t;
1130         if(Fire_IsBurning(e))
1131         {
1132                 mintime = e.fire_endtime - time;
1133                 maxtime = max(mintime, t);
1134
1135                 mindps = e.fire_damagepersec;
1136                 maxdps = max(mindps, dps);
1137
1138                 if(maxtime > mintime || maxdps > mindps)
1139                 {
1140                         // Constraints:
1141
1142                         // damage we have right now
1143                         mindamage = mindps * mintime;
1144
1145                         // damage we want to get
1146                         maxdamage = mindamage + d;
1147
1148                         // but we can't exceed maxtime * maxdps!
1149                         totaldamage = min(maxdamage, maxtime * maxdps);
1150
1151                         // LEMMA:
1152                         // Look at:
1153                         // totaldamage = min(mindamage + d, maxtime * maxdps)
1154                         // We see:
1155                         // totaldamage <= maxtime * maxdps
1156                         // ==> totaldamage / maxdps <= maxtime.
1157                         // We also see:
1158                         // totaldamage / mindps = min(mindamage / mindps + d, maxtime * maxdps / mindps)
1159                         //                     >= min(mintime, maxtime)
1160                         // ==> totaldamage / maxdps >= mintime.
1161
1162                         /*
1163                         // how long do we damage then?
1164                         // at least as long as before
1165                         // but, never exceed maxdps
1166                         totaltime = max(mintime, totaldamage / maxdps); // always <= maxtime due to lemma
1167                         */
1168
1169                         // alternate:
1170                         // at most as long as maximum allowed
1171                         // but, never below mindps
1172                         totaltime = min(maxtime, totaldamage / mindps); // always >= mintime due to lemma
1173
1174                         // assuming t > mintime, dps > mindps:
1175                         // we get d = t * dps = maxtime * maxdps
1176                         // totaldamage = min(maxdamage, maxtime * maxdps) = min(... + d, maxtime * maxdps) = maxtime * maxdps
1177                         // totaldamage / maxdps = maxtime
1178                         // totaldamage / mindps > totaldamage / maxdps = maxtime
1179                         // FROM THIS:
1180                         // a) totaltime = max(mintime, maxtime) = maxtime
1181                         // b) totaltime = min(maxtime, totaldamage / maxdps) = maxtime
1182
1183                         // assuming t <= mintime:
1184                         // we get maxtime = mintime
1185                         // a) totaltime = max(mintime, ...) >= mintime, also totaltime <= maxtime by the lemma, therefore totaltime = mintime = maxtime
1186                         // b) totaltime = min(maxtime, ...) <= maxtime, also totaltime >= mintime by the lemma, therefore totaltime = mintime = maxtime
1187
1188                         // assuming dps <= mindps:
1189                         // we get mindps = maxdps.
1190                         // With this, the lemma says that mintime <= totaldamage / mindps = totaldamage / maxdps <= maxtime.
1191                         // a) totaltime = max(mintime, totaldamage / maxdps) = totaldamage / maxdps
1192                         // b) totaltime = min(maxtime, totaldamage / mindps) = totaldamage / maxdps
1193
1194                         e.fire_damagepersec = totaldamage / totaltime;
1195                         e.fire_endtime = time + totaltime;
1196                         if(totaldamage > 1.2 * mindamage)
1197                         {
1198                                 e.fire_deathtype = dt;
1199                                 if(e.fire_owner != o)
1200                                 {
1201                                         e.fire_owner = o;
1202                                         e.fire_hitsound = false;
1203                                 }
1204                         }
1205                         if(accuracy_isgooddamage(o, e))
1206                                 accuracy_add(o, DEATH_WEAPONOF(dt).m_id, 0, max(0, totaldamage - mindamage));
1207                         return max(0, totaldamage - mindamage); // can never be negative, but to make sure
1208                 }
1209                 else
1210                         return 0;
1211         }
1212         else
1213         {
1214                 e.fire_damagepersec = dps;
1215                 e.fire_endtime = time + t;
1216                 e.fire_deathtype = dt;
1217                 e.fire_owner = o;
1218                 e.fire_hitsound = false;
1219                 if(accuracy_isgooddamage(o, e))
1220                         accuracy_add(o, DEATH_WEAPONOF(dt).m_id, 0, d);
1221                 return d;
1222         }
1223 }
1224
1225 void Fire_ApplyDamage(entity e)
1226 {
1227         float t, d, hi, ty;
1228         entity o;
1229
1230         if (!Fire_IsBurning(e))
1231                 return;
1232
1233         for(t = 0, o = e.owner; o.owner && t < 16; o = o.owner, ++t);
1234         if(IS_NOT_A_CLIENT(o))
1235                 o = e.fire_owner;
1236
1237         // water and slime stop fire
1238         if(e.waterlevel)
1239         if(e.watertype != CONTENT_LAVA)
1240                 e.fire_endtime = 0;
1241
1242         // ice stops fire
1243         if(STAT(FROZEN, e))
1244                 e.fire_endtime = 0;
1245
1246         t = min(frametime, e.fire_endtime - time);
1247         d = e.fire_damagepersec * t;
1248
1249         hi = e.fire_owner.damage_dealt;
1250         ty = e.fire_owner.typehitsound;
1251         Damage(e, e, e.fire_owner, d, e.fire_deathtype, e.origin, '0 0 0');
1252         if(e.fire_hitsound && e.fire_owner)
1253         {
1254                 e.fire_owner.damage_dealt = hi;
1255                 e.fire_owner.typehitsound = ty;
1256         }
1257         e.fire_hitsound = true;
1258
1259         if(!IS_INDEPENDENT_PLAYER(e))
1260         if(!STAT(FROZEN, e))
1261                 FOREACH_CLIENT(IS_PLAYER(it) && it != e, {
1262                         if(!IS_DEAD(it))
1263                         if(!IS_INDEPENDENT_PLAYER(it))
1264                         if(boxesoverlap(e.absmin, e.absmax, it.absmin, it.absmax))
1265                         {
1266                                 t = autocvar_g_balance_firetransfer_time * (e.fire_endtime - time);
1267                                 d = autocvar_g_balance_firetransfer_damage * e.fire_damagepersec * t;
1268                                 Fire_AddDamage(it, o, d, t, DEATH_FIRE.m_id);
1269                         }
1270                 });
1271 }
1272
1273 void Fire_ApplyEffect(entity e)
1274 {
1275         if(Fire_IsBurning(e))
1276                 e.effects |= EF_FLAME;
1277         else
1278                 e.effects &= ~EF_FLAME;
1279 }
1280
1281 void fireburner_think(entity this)
1282 {
1283         // for players, this is done in the regular loop
1284         if(wasfreed(this.owner))
1285         {
1286                 delete(this);
1287                 return;
1288         }
1289         Fire_ApplyEffect(this.owner);
1290         if(!Fire_IsBurning(this.owner))
1291         {
1292                 this.owner.fire_burner = NULL;
1293                 delete(this);
1294                 return;
1295         }
1296         Fire_ApplyDamage(this.owner);
1297         this.nextthink = time;
1298 }