qcsrc/common/mutators/mutator/buffs/buffs.qc

   1 #ifndef MUTATOR_BUFFS_H
   2 #define MUTATOR_BUFFS_H
   3
   4 #include "../instagib/module.inc"
   5
   6 bool  autocvar_g_buffs_effects;
   7 float autocvar_g_buffs_waypoint_distance;
   8 bool autocvar_g_buffs_randomize;
   9 float autocvar_g_buffs_random_lifetime;
  10 bool autocvar_g_buffs_random_location;
  11 int autocvar_g_buffs_random_location_attempts;
  12 int autocvar_g_buffs_spawn_count;
  13 bool autocvar_g_buffs_replace_powerups;
  14 float autocvar_g_buffs_cooldown_activate;
  15 float autocvar_g_buffs_cooldown_respawn;
  16 float autocvar_g_buffs_resistance_blockpercent;
  17 float autocvar_g_buffs_medic_survive_chance;
  18 float autocvar_g_buffs_medic_survive_health;
  19 float autocvar_g_buffs_medic_rot;
  20 float autocvar_g_buffs_medic_max;
  21 float autocvar_g_buffs_medic_regen;
  22 float autocvar_g_buffs_vengeance_damage_multiplier;
  23 float autocvar_g_buffs_bash_force;
  24 float autocvar_g_buffs_bash_force_self;
  25 float autocvar_g_buffs_disability_slowtime;
  26 float autocvar_g_buffs_disability_speed;
  27 float autocvar_g_buffs_disability_rate;
  28 float autocvar_g_buffs_disability_weaponspeed;
  29 float autocvar_g_buffs_speed_speed;
  30 float autocvar_g_buffs_speed_rate;
  31 float autocvar_g_buffs_speed_weaponspeed;
  32 float autocvar_g_buffs_speed_damage_take;
  33 float autocvar_g_buffs_speed_regen;
  34 float autocvar_g_buffs_vampire_damage_steal;
  35 float autocvar_g_buffs_invisible_alpha;
  36 float autocvar_g_buffs_flight_gravity;
  37 float autocvar_g_buffs_jump_height;
  38 float autocvar_g_buffs_inferno_burntime_factor;
  39 float autocvar_g_buffs_inferno_burntime_min_time;
  40 float autocvar_g_buffs_inferno_burntime_target_damage;
  41 float autocvar_g_buffs_inferno_burntime_target_time;
  42 float autocvar_g_buffs_inferno_damagemultiplier;
  43 float autocvar_g_buffs_swapper_range;
  44 float autocvar_g_buffs_magnet_range_item;
  45
  46 // ammo
  47 .float buff_ammo_prev_infitems;
  48 .int buff_ammo_prev_clipload;
  49 // invisible
  50 .float buff_invisible_prev_alpha;
  51 // flight
  52 .float buff_flight_prev_gravity;
  53 // disability
  54 .float buff_disability_time;
  55 .float buff_disability_effect_time;
  56 // common buff variables
  57 .float buff_effect_delay;
  58
  59 // buff definitions
  60 .float buff_active;
  61 .float buff_activetime;
  62 .float buff_activetime_updated;
  63 .entity buff_waypoint;
  64 .int oldbuffs; // for updating effects
  65 .entity buff_model; // controls effects (TODO: make csqc)
  66
  67 const vector BUFF_MIN = ('-16 -16 -20');
  68 const vector BUFF_MAX = ('16 16 20');
  69
  70 // client side options
  71 .float cvar_cl_buffs_autoreplace;
  72 #endif
  73
  74 #ifdef IMPLEMENTATION
  75
  76 #include "../../../triggers/target/music.qh"
  77 #include "../../../gamemodes/all.qh"
  78 #include "../../../buffs/all.qh"
  79
  80 .float buff_time;
  81 void buffs_DelayedInit();
  82
  83 REGISTER_MUTATOR(buffs, cvar("g_buffs"))
  84 {
  85         MUTATOR_ONADD
  86         {
  87                 addstat(STAT_BUFFS, AS_INT, buffs);
  88                 addstat(STAT_BUFF_TIME, AS_FLOAT, buff_time);
  89
  90                 InitializeEntity(world, buffs_DelayedInit, INITPRIO_FINDTARGET);
  91         }
  92 }
  93
  94 entity buff_FirstFromFlags(int _buffs)
  95 {
  96         if (flags)
  97         {
  98                 FOREACH(Buffs, it.m_itemid & _buffs, LAMBDA(return it));
  99         }
 100         return BUFF_Null;
 101 }
 102
 103 bool buffs_BuffModel_Customize()
 104 {SELFPARAM();
 105         entity player, myowner;
 106         bool same_team;
 107
 108         player = WaypointSprite_getviewentity(other);
 109         myowner = self.owner;
 110         same_team = (SAME_TEAM(player, myowner) || SAME_TEAM(player, myowner));
 111
 112         if(myowner.alpha <= 0.5 && !same_team && myowner.alpha != 0)
 113                 return false;
 114
 115         if(MUTATOR_CALLHOOK(BuffModel_Customize, self, player))
 116                 return false;
 117
 118         if(player == myowner || (IS_SPEC(other) && other.enemy == myowner))
 119         {
 120                 // somewhat hide the model, but keep the glow
 121                 self.effects = 0;
 122                 self.alpha = -1;
 123         }
 124         else
 125         {
 126                 self.effects = EF_FULLBRIGHT | EF_LOWPRECISION;
 127                 self.alpha = 1;
 128         }
 129         return true;
 130 }
 131
 132 void buffs_BuffModel_Spawn(entity player)
 133 {
 134         player.buff_model = spawn();
 135         setmodel(player.buff_model, MDL_BUFF);
 136         setsize(player.buff_model, '0 0 -40', '0 0 40');
 137         setattachment(player.buff_model, player, "");
 138         setorigin(player.buff_model, '0 0 1' * (player.buff_model.maxs.z * 1));
 139         player.buff_model.owner = player;
 140         player.buff_model.scale = 0.7;
 141         player.buff_model.pflags = PFLAGS_FULLDYNAMIC;
 142         player.buff_model.light_lev = 200;
 143         player.buff_model.customizeentityforclient = buffs_BuffModel_Customize;
 144 }
 145
 146 vector buff_GlowColor(entity buff)
 147 {
 148         //if(buff.team) { return Team_ColorRGB(buff.team); }
 149         return buff.m_color;
 150 }
 151
 152 void buff_Effect(entity player, string eff)
 153 {SELFPARAM();
 154         if(!autocvar_g_buffs_effects) { return; }
 155
 156         if(time >= self.buff_effect_delay)
 157         {
 158                 Send_Effect_(eff, player.origin + ((player.mins + player.maxs) * 0.5), '0 0 0', 1);
 159                 self.buff_effect_delay = time + 0.05; // prevent spam
 160         }
 161 }
 162
 163 // buff item
 164 float buff_Waypoint_visible_for_player(entity plr)
 165 {SELFPARAM();
 166         if(!self.owner.buff_active && !self.owner.buff_activetime)
 167                 return false;
 168
 169         if (plr.buffs)
 170         {
 171                 return plr.cvar_cl_buffs_autoreplace == false || plr.buffs != self.owner.buffs;
 172         }
 173
 174         return WaypointSprite_visible_for_player(plr);
 175 }
 176
 177 void buff_Waypoint_Spawn(entity e)
 178 {
 179         entity buff = buff_FirstFromFlags(e.buffs);
 180         entity wp = WaypointSprite_Spawn(WP_Buff, 0, autocvar_g_buffs_waypoint_distance, e, '0 0 1' * e.maxs.z, world, e.team, e, buff_waypoint, true, RADARICON_Buff);
 181         wp.wp_extra = buff.m_id;
 182         WaypointSprite_UpdateTeamRadar(e.buff_waypoint, RADARICON_Buff, e.glowmod);
 183         e.buff_waypoint.waypointsprite_visible_for_player = buff_Waypoint_visible_for_player;
 184 }
 185
 186 void buff_SetCooldown(float cd)
 187 {SELFPARAM();
 188         cd = max(0, cd);
 189
 190         if(!self.buff_waypoint)
 191                 buff_Waypoint_Spawn(self);
 192
 193         WaypointSprite_UpdateBuildFinished(self.buff_waypoint, time + cd);
 194         self.buff_activetime = cd;
 195         self.buff_active = !cd;
 196 }
 197
 198 void buff_Respawn(entity ent)
 199 {SELFPARAM();
 200         if(gameover) { return; }
 201
 202         vector oldbufforigin = ent.origin;
 203
 204         if(!MoveToRandomMapLocation(ent, DPCONTENTS_SOLID | DPCONTENTS_CORPSE | DPCONTENTS_PLAYERCLIP, DPCONTENTS_SLIME | DPCONTENTS_LAVA | DPCONTENTS_SKY | DPCONTENTS_BODY | DPCONTENTS_DONOTENTER, Q3SURFACEFLAG_SKY, ((autocvar_g_buffs_random_location_attempts > 0) ? autocvar_g_buffs_random_location_attempts : 10), 1024, 256))
 205         {
 206                 entity spot = SelectSpawnPoint(true);
 207                 setorigin(ent, spot.origin + '0 0 200');
 208                 ent.angles = spot.angles;
 209         }
 210
 211         tracebox(ent.origin, ent.mins * 1.5, self.maxs * 1.5, ent.origin, MOVE_NOMONSTERS, ent);
 212
 213         setorigin(ent, trace_endpos); // attempt to unstick
 214
 215         ent.movetype = MOVETYPE_TOSS;
 216
 217         makevectors(ent.angles);
 218         ent.velocity = '0 0 200';
 219         ent.angles = '0 0 0';
 220         if(autocvar_g_buffs_random_lifetime > 0)
 221                 ent.lifetime = time + autocvar_g_buffs_random_lifetime;
 222
 223         Send_Effect(EFFECT_ELECTRO_COMBO, oldbufforigin + ((ent.mins + ent.maxs) * 0.5), '0 0 0', 1);
 224         Send_Effect(EFFECT_ELECTRO_COMBO, CENTER_OR_VIEWOFS(ent), '0 0 0', 1);
 225
 226         WaypointSprite_Ping(ent.buff_waypoint);
 227
 228         sound(ent, CH_TRIGGER, SND_KA_RESPAWN, VOL_BASE, ATTEN_NONE); // ATTEN_NONE (it's a sound intended to be heard anywhere)
 229 }
 230
 231 void buff_Touch()
 232 {SELFPARAM();
 233         if(gameover) { return; }
 234
 235         if(ITEM_TOUCH_NEEDKILL())
 236         {
 237                 buff_Respawn(self);
 238                 return;
 239         }
 240
 241         if((self.team && DIFF_TEAM(other, self))
 242         || (other.frozen)
 243         || (other.vehicle)
 244         || (!self.buff_active)
 245         )
 246         {
 247                 // can't touch this
 248                 return;
 249         }
 250
 251         if(MUTATOR_CALLHOOK(BuffTouch, self, other))
 252                 return;
 253
 254         if(!IS_PLAYER(other))
 255                 return; // incase mutator changed other
 256
 257         if (other.buffs)
 258         {
 259                 if (other.cvar_cl_buffs_autoreplace && other.buffs != self.buffs)
 260                 {
 261                         int buffid = buff_FirstFromFlags(other.buffs).m_id;
 262                         //Send_Notification(NOTIF_ONE, other, MSG_MULTI, ITEM_BUFF_DROP, other.buffs);
 263                         Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_ITEM_BUFF_LOST, other.netname, buffid);
 264
 265                         other.buffs = 0;
 266                         //sound(other, CH_TRIGGER, SND_BUFF_LOST, VOL_BASE, ATTN_NORM);
 267                 }
 268                 else { return; } // do nothing
 269         }
 270
 271         self.owner = other;
 272         self.buff_active = false;
 273         self.lifetime = 0;
 274         int buffid = buff_FirstFromFlags(self.buffs).m_id;
 275         Send_Notification(NOTIF_ONE, other, MSG_MULTI, ITEM_BUFF_GOT, buffid);
 276         Send_Notification(NOTIF_ALL_EXCEPT, other, MSG_INFO, INFO_ITEM_BUFF, other.netname, buffid);
 277
 278         Send_Effect(EFFECT_ITEM_PICKUP, CENTER_OR_VIEWOFS(self), '0 0 0', 1);
 279         sound(other, CH_TRIGGER, SND_SHIELD_RESPAWN, VOL_BASE, ATTN_NORM);
 280         other.buffs |= (self.buffs);
 281 }
 282
 283 float buff_Available(entity buff)
 284 {
 285         if (buff == BUFF_Null)
 286                 return false;
 287         if (buff == BUFF_AMMO && ((start_items & IT_UNLIMITED_WEAPON_AMMO) || (start_items & IT_UNLIMITED_AMMO) || (cvar("g_melee_only"))))
 288                 return false;
 289         if (buff == BUFF_VAMPIRE && cvar("g_vampire"))
 290                 return false;
 291         return cvar(strcat("g_buffs_", buff.m_name));
 292 }
 293
 294 .int buff_seencount;
 295
 296 void buff_NewType(entity ent, float cb)
 297 {
 298         RandomSelection_Init();
 299         FOREACH(Buffs, buff_Available(it), LAMBDA(
 300                 it.buff_seencount += 1;
 301                 // if it's already been chosen, give it a lower priority
 302                 RandomSelection_Add(world, it.m_itemid, string_null, 1, max(0.2, 1 / it.buff_seencount));
 303         ));
 304         ent.buffs = RandomSelection_chosen_float;
 305 }
 306
 307 void buff_Think()
 308 {SELFPARAM();
 309         if(self.buffs != self.oldbuffs)
 310         {
 311                 entity buff = buff_FirstFromFlags(self.buffs);
 312                 self.color = buff.m_color;
 313                 self.glowmod = buff_GlowColor(buff);
 314                 self.skin = buff.m_skin;
 315
 316                 setmodel(self, MDL_BUFF);
 317
 318                 if(self.buff_waypoint)
 319                 {
 320                         //WaypointSprite_Disown(self.buff_waypoint, 1);
 321                         WaypointSprite_Kill(self.buff_waypoint);
 322                         buff_Waypoint_Spawn(self);
 323                         if(self.buff_activetime)
 324                                 WaypointSprite_UpdateBuildFinished(self.buff_waypoint, time + self.buff_activetime - frametime);
 325                 }
 326
 327                 self.oldbuffs = self.buffs;
 328         }
 329
 330         if(!gameover)
 331         if((round_handler_IsActive() && !round_handler_IsRoundStarted()) || time >= game_starttime)
 332         if(!self.buff_activetime_updated)
 333         {
 334                 buff_SetCooldown(self.buff_activetime);
 335                 self.buff_activetime_updated = true;
 336         }
 337
 338         if(!self.buff_active && !self.buff_activetime)
 339         if(!self.owner || self.owner.frozen || self.owner.deadflag != DEAD_NO || !self.owner.iscreature || !(self.owner.buffs & self.buffs))
 340         {
 341                 buff_SetCooldown(autocvar_g_buffs_cooldown_respawn + frametime);
 342                 self.owner = world;
 343                 if(autocvar_g_buffs_randomize)
 344                         buff_NewType(self, self.buffs);
 345
 346                 if(autocvar_g_buffs_random_location || (self.spawnflags & 64))
 347                         buff_Respawn(self);
 348         }
 349
 350         if(self.buff_activetime)
 351         if(!gameover)
 352         if((round_handler_IsActive() && !round_handler_IsRoundStarted()) || time >= game_starttime)
 353         {
 354                 self.buff_activetime = max(0, self.buff_activetime - frametime);
 355
 356                 if(!self.buff_activetime)
 357                 {
 358                         self.buff_active = true;
 359                         sound(self, CH_TRIGGER, SND_STRENGTH_RESPAWN, VOL_BASE, ATTN_NORM);
 360                         Send_Effect(EFFECT_ITEM_RESPAWN, CENTER_OR_VIEWOFS(self), '0 0 0', 1);
 361                 }
 362         }
 363
 364         if(self.buff_active)
 365         {
 366                 if(self.team && !self.buff_waypoint)
 367                         buff_Waypoint_Spawn(self);
 368
 369                 if(self.lifetime)
 370                 if(time >= self.lifetime)
 371                         buff_Respawn(self);
 372         }
 373
 374         self.nextthink = time;
 375         //self.angles_y = time * 110.1;
 376 }
 377
 378 void buff_Waypoint_Reset()
 379 {SELFPARAM();
 380         WaypointSprite_Kill(self.buff_waypoint);
 381
 382         if(self.buff_activetime) { buff_Waypoint_Spawn(self); }
 383 }
 384
 385 void buff_Reset()
 386 {SELFPARAM();
 387         if(autocvar_g_buffs_randomize)
 388                 buff_NewType(self, self.buffs);
 389         self.owner = world;
 390         buff_SetCooldown(autocvar_g_buffs_cooldown_activate);
 391         buff_Waypoint_Reset();
 392         self.buff_activetime_updated = false;
 393
 394         if(autocvar_g_buffs_random_location || (self.spawnflags & 64))
 395                 buff_Respawn(self);
 396 }
 397
 398 float buff_Customize()
 399 {SELFPARAM();
 400         entity player = WaypointSprite_getviewentity(other);
 401         if(!self.buff_active || (self.team && DIFF_TEAM(player, self)))
 402         {
 403                 self.alpha = 0.3;
 404                 if(self.effects & EF_FULLBRIGHT) { self.effects &= ~(EF_FULLBRIGHT); }
 405                 self.pflags = 0;
 406         }
 407         else
 408         {
 409                 self.alpha = 1;
 410                 if(!(self.effects & EF_FULLBRIGHT)) { self.effects |= EF_FULLBRIGHT; }
 411                 self.light_lev = 220 + 36 * sin(time);
 412                 self.pflags = PFLAGS_FULLDYNAMIC;
 413         }
 414         return true;
 415 }
 416
 417 void buff_Init(entity ent)
 418 {SELFPARAM();
 419         if(!cvar("g_buffs")) { remove(ent); return; }
 420
 421         if(!teamplay && ent.team) { ent.team = 0; }
 422
 423         entity buff = buff_FirstFromFlags(self.buffs);
 424
 425         setself(ent);
 426         if(!self.buffs || buff_Available(buff))
 427                 buff_NewType(self, 0);
 428
 429         self.classname = "item_buff";
 430         self.solid = SOLID_TRIGGER;
 431         self.flags = FL_ITEM;
 432         self.think = buff_Think;
 433         self.touch = buff_Touch;
 434         self.reset = buff_Reset;
 435         self.nextthink = time + 0.1;
 436         self.gravity = 1;
 437         self.movetype = MOVETYPE_TOSS;
 438         self.scale = 1;
 439         self.skin = buff.m_skin;
 440         self.effects = EF_FULLBRIGHT | EF_STARDUST | EF_NOSHADOW;
 441         self.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY;
 442         self.customizeentityforclient = buff_Customize;
 443         //self.gravity = 100;
 444         self.color = buff.m_color;
 445         self.glowmod = buff_GlowColor(self);
 446         buff_SetCooldown(autocvar_g_buffs_cooldown_activate + game_starttime);
 447         self.buff_active = !self.buff_activetime;
 448         self.pflags = PFLAGS_FULLDYNAMIC;
 449
 450         if(self.spawnflags & 1)
 451                 self.noalign = true;
 452
 453         if(self.noalign)
 454                 self.movetype = MOVETYPE_NONE; // reset by random location
 455
 456         setmodel(self, MDL_BUFF);
 457         setsize(self, BUFF_MIN, BUFF_MAX);
 458
 459         if(cvar("g_buffs_random_location") || (self.spawnflags & 64))
 460                 buff_Respawn(self);
 461
 462         setself(this);
 463 }
 464
 465 void buff_Init_Compat(entity ent, entity replacement)
 466 {
 467         if (ent.spawnflags & 2)
 468                 ent.team = NUM_TEAM_1;
 469         else if (ent.spawnflags & 4)
 470                 ent.team = NUM_TEAM_2;
 471
 472         ent.buffs = replacement.m_itemid;
 473
 474         buff_Init(ent);
 475 }
 476
 477 void buff_SpawnReplacement(entity ent, entity old)
 478 {
 479         setorigin(ent, old.origin);
 480         ent.angles = old.angles;
 481         ent.noalign = (old.noalign || (old.spawnflags & 1));
 482
 483         buff_Init(ent);
 484 }
 485
 486 void buff_Vengeance_DelayedDamage()
 487 {SELFPARAM();
 488         if(self.enemy)
 489                 Damage(self.enemy, self.owner, self.owner, self.dmg, DEATH_BUFF.m_id, self.enemy.origin, '0 0 0');
 490
 491         remove(self);
 492         return;
 493 }
 494
 495 float buff_Inferno_CalculateTime(float x, float offset_x, float offset_y, float intersect_x, float intersect_y, float base)
 496 {
 497         return offset_y + (intersect_y - offset_y) * logn(((x - offset_x) * ((base - 1) / intersect_x)) + 1, base);
 498 }
 499
 500 // mutator hooks
 501 MUTATOR_HOOKFUNCTION(buffs, PlayerDamage_SplitHealthArmor)
 502 {
 503         if(frag_deathtype == DEATH_BUFF.m_id) { return false; }
 504
 505         if(frag_target.buffs & BUFF_RESISTANCE.m_itemid)
 506         {
 507                 vector v = healtharmor_applydamage(50, autocvar_g_buffs_resistance_blockpercent, frag_deathtype, frag_damage);
 508                 damage_take = v.x;
 509                 damage_save = v.y;
 510         }
 511
 512         return false;
 513 }
 514
 515 MUTATOR_HOOKFUNCTION(buffs, PlayerDamage_Calculate)
 516 {
 517         if(frag_deathtype == DEATH_BUFF.m_id) { return false; }
 518
 519         if(frag_target.buffs & BUFF_SPEED.m_itemid)
 520         if(frag_target != frag_attacker)
 521                 frag_damage *= autocvar_g_buffs_speed_damage_take;
 522
 523         if(frag_target.buffs & BUFF_MEDIC.m_itemid)
 524         if((frag_target.health - frag_damage) <= 0)
 525         if(!ITEM_DAMAGE_NEEDKILL(frag_deathtype))
 526         if(frag_attacker)
 527         if(random() <= autocvar_g_buffs_medic_survive_chance)
 528                 frag_damage = max(5, frag_target.health - autocvar_g_buffs_medic_survive_health);
 529
 530         if(frag_target.buffs & BUFF_JUMP.m_itemid)
 531         if(frag_deathtype == DEATH_FALL.m_id)
 532                 frag_damage = 0;
 533
 534         if(frag_target.buffs & BUFF_VENGEANCE.m_itemid)
 535         if(frag_attacker)
 536         if(frag_attacker != frag_target)
 537         if(!ITEM_DAMAGE_NEEDKILL(frag_deathtype))
 538         {
 539                 entity dmgent = spawn();
 540
 541                 dmgent.dmg = frag_damage * autocvar_g_buffs_vengeance_damage_multiplier;
 542                 dmgent.enemy = frag_attacker;
 543                 dmgent.owner = frag_target;
 544                 dmgent.think = buff_Vengeance_DelayedDamage;
 545                 dmgent.nextthink = time + 0.1;
 546         }
 547
 548         if(frag_target.buffs & BUFF_BASH.m_itemid)
 549         if(frag_attacker != frag_target)
 550         if(vlen(frag_force))
 551                 frag_force = '0 0 0';
 552
 553         if(frag_attacker.buffs & BUFF_BASH.m_itemid)
 554         if(vlen(frag_force))
 555         if(frag_attacker == frag_target)
 556                 frag_force *= autocvar_g_buffs_bash_force_self;
 557         else
 558                 frag_force *= autocvar_g_buffs_bash_force;
 559
 560         if(frag_attacker.buffs & BUFF_DISABILITY.m_itemid)
 561         if(frag_target != frag_attacker)
 562                 frag_target.buff_disability_time = time + autocvar_g_buffs_disability_slowtime;
 563
 564         if(frag_attacker.buffs & BUFF_MEDIC.m_itemid)
 565         if(DEATH_WEAPONOF(frag_deathtype) != WEP_ARC)
 566         if(SAME_TEAM(frag_attacker, frag_target))
 567         if(frag_attacker != frag_target)
 568         {
 569                 frag_target.health = min(g_pickup_healthmega_max, frag_target.health + frag_damage);
 570                 frag_damage = 0;
 571         }
 572
 573         if(frag_attacker.buffs & BUFF_INFERNO.m_itemid)
 574         if(frag_target != frag_attacker) {
 575                 float time = buff_Inferno_CalculateTime(
 576                         frag_damage,
 577                         0,
 578                         autocvar_g_buffs_inferno_burntime_min_time,
 579                         autocvar_g_buffs_inferno_burntime_target_damage,
 580                         autocvar_g_buffs_inferno_burntime_target_time,
 581                         autocvar_g_buffs_inferno_burntime_factor
 582                 );
 583                 Fire_AddDamage(frag_target, frag_attacker, (frag_damage * autocvar_g_buffs_inferno_damagemultiplier) * time, time, DEATH_BUFF.m_id);
 584         }
 585
 586         // this... is ridiculous (TODO: fix!)
 587         if(frag_attacker.buffs & BUFF_VAMPIRE.m_itemid)
 588         if(!frag_target.vehicle)
 589         if(DEATH_WEAPONOF(frag_deathtype) != WEP_ARC)
 590         if(!ITEM_DAMAGE_NEEDKILL(frag_deathtype))
 591         if(frag_target.deadflag == DEAD_NO)
 592         if(IS_PLAYER(frag_target) || IS_MONSTER(frag_target))
 593         if(frag_attacker != frag_target)
 594         if(!frag_target.frozen)
 595         if(frag_target.takedamage)
 596         if(DIFF_TEAM(frag_attacker, frag_target))
 597         {
 598                 frag_attacker.health = bound(0, frag_attacker.health + bound(0, frag_damage * autocvar_g_buffs_vampire_damage_steal, frag_target.health), g_pickup_healthsmall_max);
 599                 if(frag_target.armorvalue)
 600                         frag_attacker.armorvalue = bound(0, frag_attacker.armorvalue + bound(0, frag_damage * autocvar_g_buffs_vampire_damage_steal, frag_target.armorvalue), g_pickup_armorsmall_max);
 601         }
 602
 603         return false;
 604 }
 605
 606 MUTATOR_HOOKFUNCTION(buffs,PlayerSpawn)
 607 {SELFPARAM();
 608         self.buffs = 0;
 609         // reset timers here to prevent them continuing after re-spawn
 610         self.buff_disability_time = 0;
 611         self.buff_disability_effect_time = 0;
 612         return false;
 613 }
 614
 615 .float stat_sv_maxspeed;
 616 .float stat_sv_airspeedlimit_nonqw;
 617 .float stat_sv_jumpvelocity;
 618
 619 MUTATOR_HOOKFUNCTION(buffs, PlayerPhysics)
 620 {SELFPARAM();
 621         if(self.buffs & BUFF_SPEED.m_itemid)
 622         {
 623                 self.stat_sv_maxspeed *= autocvar_g_buffs_speed_speed;
 624                 self.stat_sv_airspeedlimit_nonqw *= autocvar_g_buffs_speed_speed;
 625         }
 626
 627         if(time < self.buff_disability_time)
 628         {
 629                 self.stat_sv_maxspeed *= autocvar_g_buffs_disability_speed;
 630                 self.stat_sv_airspeedlimit_nonqw *= autocvar_g_buffs_disability_speed;
 631         }
 632
 633         if(self.buffs & BUFF_JUMP.m_itemid)
 634         {
 635                 // automatically reset, no need to worry
 636                 self.stat_sv_jumpvelocity = autocvar_g_buffs_jump_height;
 637         }
 638
 639         return false;
 640 }
 641
 642 MUTATOR_HOOKFUNCTION(buffs, PlayerJump)
 643 {SELFPARAM();
 644         if(self.buffs & BUFF_JUMP.m_itemid)
 645                 player_jumpheight = autocvar_g_buffs_jump_height;
 646
 647         return false;
 648 }
 649
 650 MUTATOR_HOOKFUNCTION(buffs, MonsterMove)
 651 {SELFPARAM();
 652         if(time < self.buff_disability_time)
 653         {
 654                 monster_speed_walk *= autocvar_g_buffs_disability_speed;
 655                 monster_speed_run *= autocvar_g_buffs_disability_speed;
 656         }
 657
 658         return false;
 659 }
 660
 661 MUTATOR_HOOKFUNCTION(buffs, PlayerDies)
 662 {SELFPARAM();
 663         if(self.buffs)
 664         {
 665                 int buffid = buff_FirstFromFlags(self.buffs).m_id;
 666                 Send_Notification(NOTIF_ALL_EXCEPT, self, MSG_INFO, INFO_ITEM_BUFF_LOST, self.netname, buffid);
 667                 self.buffs = 0;
 668
 669                 if(self.buff_model)
 670                 {
 671                         remove(self.buff_model);
 672                         self.buff_model = world;
 673                 }
 674         }
 675         return false;
 676 }
 677
 678 MUTATOR_HOOKFUNCTION(buffs, PlayerUseKey, CBC_ORDER_FIRST)
 679 {SELFPARAM();
 680         if(MUTATOR_RETURNVALUE || gameover) { return false; }
 681         if(self.buffs)
 682         {
 683                 int buffid = buff_FirstFromFlags(self.buffs).m_id;
 684                 Send_Notification(NOTIF_ONE, self, MSG_MULTI, ITEM_BUFF_DROP, buffid);
 685                 Send_Notification(NOTIF_ALL_EXCEPT, self, MSG_INFO, INFO_ITEM_BUFF_LOST, self.netname, buffid);
 686
 687                 self.buffs = 0;
 688                 sound(self, CH_TRIGGER, SND_BUFF_LOST, VOL_BASE, ATTN_NORM);
 689                 return true;
 690         }
 691         return false;
 692 }
 693
 694 MUTATOR_HOOKFUNCTION(buffs, ForbidThrowCurrentWeapon)
 695 {SELFPARAM();
 696         if(MUTATOR_RETURNVALUE || gameover) { return false; }
 697
 698         if(self.buffs & BUFF_SWAPPER.m_itemid)
 699         {
 700                 float best_distance = autocvar_g_buffs_swapper_range;
 701                 entity closest = world;
 702                 entity player;
 703                 FOR_EACH_PLAYER(player)
 704                 if(DIFF_TEAM(self, player))
 705                 if(player.deadflag == DEAD_NO && !player.frozen && !player.vehicle)
 706                 if(vlen(self.origin - player.origin) <= best_distance)
 707                 {
 708                         best_distance = vlen(self.origin - player.origin);
 709                         closest = player;
 710                 }
 711
 712                 if(closest)
 713                 {
 714                         vector my_org, my_vel, my_ang, their_org, their_vel, their_ang;
 715
 716                         my_org = self.origin;
 717                         my_vel = self.velocity;
 718                         my_ang = self.angles;
 719                         their_org = closest.origin;
 720                         their_vel = closest.velocity;
 721                         their_ang = closest.angles;
 722
 723                         Drop_Special_Items(closest);
 724
 725                         MUTATOR_CALLHOOK(PortalTeleport, self); // initiate flag dropper
 726
 727                         setorigin(self, their_org);
 728                         setorigin(closest, my_org);
 729
 730                         closest.velocity = my_vel;
 731                         closest.angles = my_ang;
 732                         closest.fixangle = true;
 733                         closest.oldorigin = my_org;
 734                         closest.oldvelocity = my_vel;
 735                         self.velocity = their_vel;
 736                         self.angles = their_ang;
 737                         self.fixangle = true;
 738                         self.oldorigin = their_org;
 739                         self.oldvelocity = their_vel;
 740
 741                         // set pusher so self gets the kill if they fall into void
 742                         closest.pusher = self;
 743                         closest.pushltime = time + autocvar_g_maxpushtime;
 744                         closest.istypefrag = closest.BUTTON_CHAT;
 745
 746                         Send_Effect(EFFECT_ELECTRO_COMBO, their_org, '0 0 0', 1);
 747                         Send_Effect(EFFECT_ELECTRO_COMBO, my_org, '0 0 0', 1);
 748
 749                         sound(self, CH_TRIGGER, SND_KA_RESPAWN, VOL_BASE, ATTEN_NORM);
 750                         sound(closest, CH_TRIGGER, SND_KA_RESPAWN, VOL_BASE, ATTEN_NORM);
 751
 752                         // TODO: add a counter to handle how many times one can teleport, and a delay to prevent spam
 753                         self.buffs = 0;
 754                         return true;
 755                 }
 756         }
 757         return false;
 758 }
 759
 760 bool buffs_RemovePlayer(entity player)
 761 {
 762         if(player.buff_model)
 763         {
 764                 remove(player.buff_model);
 765                 player.buff_model = world;
 766         }
 767
 768         // also reset timers here to prevent them continuing after spectating
 769         player.buff_disability_time = 0;
 770         player.buff_disability_effect_time = 0;
 771
 772         return false;
 773 }
 774 MUTATOR_HOOKFUNCTION(buffs, MakePlayerObserver) { return buffs_RemovePlayer(self); }
 775 MUTATOR_HOOKFUNCTION(buffs, ClientDisconnect) { return buffs_RemovePlayer(self); }
 776
 777 MUTATOR_HOOKFUNCTION(buffs, CustomizeWaypoint)
 778 {SELFPARAM();
 779         entity e = WaypointSprite_getviewentity(other);
 780
 781         // if you have the invisibility powerup, sprites ALWAYS are restricted to your team
 782         // but only apply this to real players, not to spectators
 783         if((self.owner.flags & FL_CLIENT) && (self.owner.buffs & BUFF_INVISIBLE.m_itemid) && (e == other))
 784         if(DIFF_TEAM(self.owner, e))
 785                 return true;
 786
 787         return false;
 788 }
 789
 790 MUTATOR_HOOKFUNCTION(buffs, OnEntityPreSpawn, CBC_ORDER_LAST)
 791 {SELFPARAM();
 792         if(autocvar_g_buffs_replace_powerups)
 793         switch(self.classname)
 794         {
 795                 case "item_strength":
 796                 case "item_invincible":
 797                 {
 798                         entity e = spawn();
 799                         buff_SpawnReplacement(e, self);
 800                         return true;
 801                 }
 802         }
 803         return false;
 804 }
 805
 806 MUTATOR_HOOKFUNCTION(buffs, WeaponRateFactor)
 807 {SELFPARAM();
 808         if(self.buffs & BUFF_SPEED.m_itemid)
 809                 weapon_rate *= autocvar_g_buffs_speed_rate;
 810
 811         if(time < self.buff_disability_time)
 812                 weapon_rate *= autocvar_g_buffs_disability_rate;
 813
 814         return false;
 815 }
 816
 817 MUTATOR_HOOKFUNCTION(buffs, WeaponSpeedFactor)
 818 {SELFPARAM();
 819         if(self.buffs & BUFF_SPEED.m_itemid)
 820                 ret_float *= autocvar_g_buffs_speed_weaponspeed;
 821
 822         if(time < self.buff_disability_time)
 823                 ret_float *= autocvar_g_buffs_disability_weaponspeed;
 824
 825         return false;
 826 }
 827
 828 MUTATOR_HOOKFUNCTION(buffs, PlayerPreThink)
 829 {SELFPARAM();
 830         if(gameover || self.deadflag != DEAD_NO) { return false; }
 831
 832         if(time < self.buff_disability_time)
 833         if(time >= self.buff_disability_effect_time)
 834         {
 835                 Send_Effect(EFFECT_SMOKING, self.origin + ((self.mins + self.maxs) * 0.5), '0 0 0', 1);
 836                 self.buff_disability_effect_time = time + 0.5;
 837         }
 838
 839         // handle buff lost status
 840         // 1: notify everyone else
 841         // 2: notify carrier as well
 842         int buff_lost = 0;
 843
 844         if(self.buff_time)
 845         if(time >= self.buff_time)
 846                 buff_lost = 2;
 847
 848         if(self.frozen) { buff_lost = 1; }
 849
 850         if(buff_lost)
 851         {
 852                 if(self.buffs)
 853                 {
 854                         int buffid = buff_FirstFromFlags(self.buffs).m_id;
 855                         Send_Notification(NOTIF_ALL_EXCEPT, self, MSG_INFO, INFO_ITEM_BUFF_LOST, self.netname, buffid);
 856                         if(buff_lost >= 2)
 857                         {
 858                                 Send_Notification(NOTIF_ONE, self, MSG_MULTI, ITEM_BUFF_DROP, buffid); // TODO: special timeout message?
 859                                 sound(self, CH_TRIGGER, SND_BUFF_LOST, VOL_BASE, ATTN_NORM);
 860                         }
 861                         self.buffs = 0;
 862                 }
 863         }
 864
 865         if(self.buffs & BUFF_MAGNET.m_itemid)
 866         {
 867                 vector pickup_size = '1 1 1' * autocvar_g_buffs_magnet_range_item;
 868                 for(other = world; (other = findflags(other, flags, FL_ITEM)); )
 869                 if(boxesoverlap(self.absmin - pickup_size, self.absmax + pickup_size, other.absmin, other.absmax))
 870                 {
 871                         setself(other);
 872                         other = this;
 873                         if(self.touch)
 874                                 self.touch();
 875                         other = self;
 876                         setself(this);
 877                 }
 878         }
 879
 880         if(self.buffs & BUFF_AMMO.m_itemid)
 881         if(self.clip_size)
 882                 self.clip_load = self.(weapon_load[self.switchweapon]) = self.clip_size;
 883
 884         if((self.buffs & BUFF_INVISIBLE.m_itemid) && (self.oldbuffs & BUFF_INVISIBLE.m_itemid))
 885         if(self.alpha != autocvar_g_buffs_invisible_alpha)
 886                 self.alpha = autocvar_g_buffs_invisible_alpha; // powerups reset alpha, so we must enforce this (TODO)
 887
 888 #define BUFF_ONADD(b) if ( (self.buffs & (b).m_itemid) && !(self.oldbuffs & (b).m_itemid))
 889 #define BUFF_ONREM(b) if (!(self.buffs & (b).m_itemid) &&  (self.oldbuffs & (b).m_itemid))
 890
 891         if(self.buffs != self.oldbuffs)
 892         {
 893                 entity buff = buff_FirstFromFlags(self.buffs);
 894                 float bufftime = buff != BUFF_Null ? buff.m_time(buff) : 0;
 895                 self.buff_time = (bufftime) ? time + bufftime : 0;
 896
 897                 BUFF_ONADD(BUFF_AMMO)
 898                 {
 899                         self.buff_ammo_prev_infitems = (self.items & IT_UNLIMITED_WEAPON_AMMO);
 900                         self.items |= IT_UNLIMITED_WEAPON_AMMO;
 901
 902                         if(self.clip_load)
 903                                 self.buff_ammo_prev_clipload = self.clip_load;
 904                         self.clip_load = self.(weapon_load[self.switchweapon]) = self.clip_size;
 905                 }
 906
 907                 BUFF_ONREM(BUFF_AMMO)
 908                 {
 909                         if(self.buff_ammo_prev_infitems)
 910                                 self.items |= IT_UNLIMITED_WEAPON_AMMO;
 911                         else
 912                                 self.items &= ~IT_UNLIMITED_WEAPON_AMMO;
 913
 914                         if(self.buff_ammo_prev_clipload)
 915                                 self.clip_load = self.buff_ammo_prev_clipload;
 916                 }
 917
 918                 BUFF_ONADD(BUFF_INVISIBLE)
 919                 {
 920                         if(time < self.strength_finished && g_instagib)
 921                                 self.alpha = autocvar_g_instagib_invis_alpha;
 922                         else
 923                                 self.alpha = self.buff_invisible_prev_alpha;
 924                         self.alpha = autocvar_g_buffs_invisible_alpha;
 925                 }
 926
 927                 BUFF_ONREM(BUFF_INVISIBLE)
 928                         self.alpha = self.buff_invisible_prev_alpha;
 929
 930                 BUFF_ONADD(BUFF_FLIGHT)
 931                 {
 932                         self.buff_flight_prev_gravity = self.gravity;
 933                         self.gravity = autocvar_g_buffs_flight_gravity;
 934                 }
 935
 936                 BUFF_ONREM(BUFF_FLIGHT)
 937                         self.gravity = self.buff_flight_prev_gravity;
 938
 939                 self.oldbuffs = self.buffs;
 940                 if(self.buffs)
 941                 {
 942                         if(!self.buff_model)
 943                                 buffs_BuffModel_Spawn(self);
 944
 945                         self.buff_model.color = buff.m_color;
 946                         self.buff_model.glowmod = buff_GlowColor(self.buff_model);
 947                         self.buff_model.skin = buff.m_skin;
 948
 949                         self.effects |= EF_NOSHADOW;
 950                 }
 951                 else
 952                 {
 953                         remove(self.buff_model);
 954                         self.buff_model = world;
 955
 956                         self.effects &= ~(EF_NOSHADOW);
 957                 }
 958         }
 959
 960         if(self.buff_model)
 961         {
 962                 self.buff_model.effects = self.effects;
 963                 self.buff_model.effects |= EF_LOWPRECISION;
 964                 self.buff_model.effects = self.buff_model.effects & EFMASK_CHEAP; // eat performance
 965
 966                 self.buff_model.alpha = self.alpha;
 967         }
 968
 969 #undef BUFF_ONADD
 970 #undef BUFF_ONREM
 971         return false;
 972 }
 973
 974 MUTATOR_HOOKFUNCTION(buffs, SpectateCopy)
 975 {SELFPARAM();
 976         self.buffs = other.buffs;
 977         return false;
 978 }
 979
 980 MUTATOR_HOOKFUNCTION(buffs, VehicleEnter)
 981 {
 982         vh_vehicle.buffs = vh_player.buffs;
 983         vh_player.buffs = 0;
 984         vh_vehicle.buff_time = vh_player.buff_time - time;
 985         vh_player.buff_time = 0;
 986         return false;
 987 }
 988
 989 MUTATOR_HOOKFUNCTION(buffs, VehicleExit)
 990 {
 991         vh_player.buffs = vh_player.oldbuffs = vh_vehicle.buffs;
 992         vh_vehicle.buffs = 0;
 993         vh_player.buff_time = time + vh_vehicle.buff_time;
 994         vh_vehicle.buff_time = 0;
 995         return false;
 996 }
 997
 998 MUTATOR_HOOKFUNCTION(buffs, PlayerRegen)
 999 {SELFPARAM();
1000         if(self.buffs & BUFF_MEDIC.m_itemid)
1001         {
1002                 regen_mod_rot = autocvar_g_buffs_medic_rot;
1003                 regen_mod_limit = regen_mod_max = autocvar_g_buffs_medic_max;
1004                 regen_mod_regen = autocvar_g_buffs_medic_regen;
1005         }
1006
1007         if(self.buffs & BUFF_SPEED.m_itemid)
1008                 regen_mod_regen = autocvar_g_buffs_speed_regen;
1009
1010         return false;
1011 }
1012
1013 MUTATOR_HOOKFUNCTION(buffs, GetCvars)
1014 {
1015         GetCvars_handleFloat(get_cvars_s, get_cvars_f, cvar_cl_buffs_autoreplace, "cl_buffs_autoreplace");
1016         return false;
1017 }
1018
1019 MUTATOR_HOOKFUNCTION(buffs, BuildMutatorsString)
1020 {
1021         ret_string = strcat(ret_string, ":Buffs");
1022         return false;
1023 }
1024
1025 MUTATOR_HOOKFUNCTION(buffs, BuildMutatorsPrettyString)
1026 {
1027         ret_string = strcat(ret_string, ", Buffs");
1028         return false;
1029 }
1030
1031 void buffs_DelayedInit()
1032 {
1033         if(autocvar_g_buffs_spawn_count > 0)
1034         if(find(world, classname, "item_buff") == world)
1035         {
1036                 float i;
1037                 for(i = 0; i < autocvar_g_buffs_spawn_count; ++i)
1038                 {
1039                         entity e = spawn();
1040                         e.spawnflags |= 64; // always randomize
1041                         e.velocity = randomvec() * 250; // this gets reset anyway if random location works
1042                         buff_Init(e);
1043                 }
1044         }
1045 }
1046 #endif