qcsrc/server/mutators/mutator_buffs.qc

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