qcsrc/server/mutators/gamemode_onslaught.qc

   1 float autocvar_g_onslaught_spawn_at_controlpoints;
   2 float autocvar_g_onslaught_spawn_at_generator;
   3 float autocvar_g_onslaught_controlpoints_proxycap;
   4 float autocvar_g_onslaught_controlpoints_proxycap_distance = 512;
   5 float autocvar_g_onslaught_controlpoints_proxycap_dps = 100;
   6
   7 void onslaught_generator_updatesprite(entity e);
   8 void onslaught_controlpoint_updatesprite(entity e);
   9 void onslaught_link_checkupdate();
  10
  11 .entity sprite;
  12 .string target2;
  13 .float iscaptured;
  14 .float islinked;
  15 .float isgenneighbor_red;
  16 .float isgenneighbor_blue;
  17 .float iscpneighbor_red;
  18 .float iscpneighbor_blue;
  19 .float isshielded;
  20 .float lasthealth;
  21 .float lastteam;
  22 .float lastshielded;
  23 .float lastcaptured;
  24
  25 entity ons_red_generator;
  26 entity ons_blue_generator;
  27
  28 void ons_gib_damage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector vforce)
  29 {
  30         self.velocity = self.velocity + vforce;
  31 }
  32
  33 .float giblifetime;
  34 void ons_throwgib_think()
  35 {
  36         float d;
  37
  38         self.nextthink = time + 0.05;
  39
  40         d = self.giblifetime - time;
  41
  42         if(d<0)
  43         {
  44                 self.think = SUB_Remove;
  45                 return;
  46         }
  47         if(d<1)
  48                 self.alpha = d;
  49
  50         if(d>2)
  51         if(random()<0.6)
  52                 pointparticles(particleeffectnum("onslaught_generator_gib_flame"), self.origin, '0 0 0', 1);
  53 }
  54
  55 void ons_throwgib(vector v_from, vector v_to, string smodel, float f_lifetime, float b_burn)
  56 {
  57         entity gib;
  58
  59         gib = spawn();
  60
  61         setmodel(gib, smodel);
  62         setorigin(gib, v_from);
  63         gib.solid = SOLID_BBOX;
  64         gib.movetype = MOVETYPE_BOUNCE;
  65         gib.takedamage = DAMAGE_YES;
  66         gib.event_damage = ons_gib_damage;
  67         gib.health = -1;
  68         gib.effects = EF_LOWPRECISION;
  69         gib.flags = FL_NOTARGET;
  70         gib.velocity = v_to;
  71         gib.giblifetime = time + f_lifetime;
  72
  73         if (b_burn)
  74         {
  75                 gib.think = ons_throwgib_think;
  76                 gib.nextthink = time + 0.05;
  77         }
  78         else
  79                 SUB_SetFade(gib, gib.giblifetime, 2);
  80 }
  81
  82 void onslaught_updatelinks()
  83 {
  84         entity l, links;
  85         float stop, t1, t2, t3, t4;
  86         // first check if the game has ended
  87         dprint("--- updatelinks ---\n");
  88         links = findchain(classname, "onslaught_link");
  89         // mark generators as being shielded and networked
  90         l = findchain(classname, "onslaught_generator");
  91         while (l)
  92         {
  93                 if (l.iscaptured)
  94                         dprint(etos(l), " (generator) belongs to team ", ftos(l.team), "\n");
  95                 else
  96                         dprint(etos(l), " (generator) is destroyed\n");
  97                 l.islinked = l.iscaptured;
  98                 l.isshielded = l.iscaptured;
  99                 l = l.chain;
 100         }
 101         // mark points as shielded and not networked
 102         l = findchain(classname, "onslaught_controlpoint");
 103         while (l)
 104         {
 105                 l.islinked = FALSE;
 106                 l.isshielded = TRUE;
 107                 l.isgenneighbor_red = FALSE;
 108                 l.isgenneighbor_blue = FALSE;
 109                 l.iscpneighbor_red = FALSE;
 110                 l.iscpneighbor_blue = FALSE;
 111                 dprint(etos(l), " (point) belongs to team ", ftos(l.team), "\n");
 112                 l = l.chain;
 113         }
 114         // flow power outward from the generators through the network
 115         l = links;
 116         while (l)
 117         {
 118                 dprint(etos(l), " (link) connects ", etos(l.goalentity), " with ", etos(l.enemy), "\n");
 119                 l = l.chain;
 120         }
 121         stop = FALSE;
 122         while (!stop)
 123         {
 124                 stop = TRUE;
 125                 l = links;
 126                 while (l)
 127                 {
 128                         // if both points are captured by the same team, and only one of
 129                         // them is powered, mark the other one as powered as well
 130                         if (l.enemy.iscaptured && l.goalentity.iscaptured)
 131                                 if (l.enemy.islinked != l.goalentity.islinked)
 132                                         if (l.enemy.team == l.goalentity.team)
 133                                         {
 134                                                 if (!l.goalentity.islinked)
 135                                                 {
 136                                                         stop = FALSE;
 137                                                         l.goalentity.islinked = TRUE;
 138                                                         dprint(etos(l), " (link) is marking ", etos(l.goalentity), " (point) because its team matches ", etos(l.enemy), " (point)\n");
 139                                                 }
 140                                                 else if (!l.enemy.islinked)
 141                                                 {
 142                                                         stop = FALSE;
 143                                                         l.enemy.islinked = TRUE;
 144                                                         dprint(etos(l), " (link) is marking ", etos(l.enemy), " (point) because its team matches ", etos(l.goalentity), " (point)\n");
 145                                                 }
 146                                         }
 147                         l = l.chain;
 148                 }
 149         }
 150         // now that we know which points are powered we can mark their neighbors
 151         // as unshielded if team differs
 152         l = links;
 153         while (l)
 154         {
 155                 if (l.goalentity.islinked)
 156                 {
 157                         if (l.goalentity.team != l.enemy.team)
 158                         {
 159                                 dprint(etos(l), " (link) is unshielding ", etos(l.enemy), " (point) because its team does not match ", etos(l.goalentity), " (point)\n");
 160                                 l.enemy.isshielded = FALSE;
 161                         }
 162                         if(l.goalentity.classname == "onslaught_generator")
 163                         {
 164                                 if(l.goalentity.team == COLOR_TEAM1)
 165                                         l.enemy.isgenneighbor_red = TRUE;
 166                                 else if(l.goalentity.team == COLOR_TEAM2)
 167                                         l.enemy.isgenneighbor_blue = TRUE;
 168                         }
 169                         else
 170                         {
 171                                 if(l.goalentity.team == COLOR_TEAM1)
 172                                         l.enemy.iscpneighbor_red = TRUE;
 173                                 else if(l.goalentity.team == COLOR_TEAM2)
 174                                         l.enemy.iscpneighbor_blue = TRUE;
 175                         }
 176                 }
 177                 if (l.enemy.islinked)
 178                 {
 179                         if (l.goalentity.team != l.enemy.team)
 180                         {
 181                                 dprint(etos(l), " (link) is unshielding ", etos(l.goalentity), " (point) because its team does not match ", etos(l.enemy), " (point)\n");
 182                                 l.goalentity.isshielded = FALSE;
 183                         }
 184                         if(l.enemy.classname == "onslaught_generator")
 185                         {
 186                                 if(l.enemy.team == COLOR_TEAM1)
 187                                         l.goalentity.isgenneighbor_red = TRUE;
 188                                 else if(l.enemy.team == COLOR_TEAM2)
 189                                         l.goalentity.isgenneighbor_blue = TRUE;
 190                         }
 191                         else
 192                         {
 193                                 if(l.enemy.team == COLOR_TEAM1)
 194                                         l.goalentity.iscpneighbor_red = TRUE;
 195                                 else if(l.enemy.team == COLOR_TEAM2)
 196                                         l.goalentity.iscpneighbor_blue = TRUE;
 197                         }
 198                 }
 199                 l = l.chain;
 200         }
 201         // now update the takedamage and alpha variables on generator shields
 202         l = findchain(classname, "onslaught_generator");
 203         while (l)
 204         {
 205                 if (l.isshielded)
 206                 {
 207                         dprint(etos(l), " (generator) is shielded\n");
 208                         l.enemy.alpha = 1;
 209                         l.takedamage = DAMAGE_NO;
 210                         l.bot_attack = FALSE;
 211                 }
 212                 else
 213                 {
 214                         dprint(etos(l), " (generator) is not shielded\n");
 215                         l.enemy.alpha = -1;
 216                         l.takedamage = DAMAGE_AIM;
 217                         l.bot_attack = TRUE;
 218                 }
 219                 l = l.chain;
 220         }
 221         // now update the takedamage and alpha variables on control point icons
 222         l = findchain(classname, "onslaught_controlpoint");
 223         while (l)
 224         {
 225                 if (l.isshielded)
 226                 {
 227                         dprint(etos(l), " (point) is shielded\n");
 228                         l.enemy.alpha = 1;
 229                         if (l.goalentity)
 230                         {
 231                                 l.goalentity.takedamage = DAMAGE_NO;
 232                                 l.goalentity.bot_attack = FALSE;
 233                         }
 234                 }
 235                 else
 236                 {
 237                         dprint(etos(l), " (point) is not shielded\n");
 238                         l.enemy.alpha = -1;
 239                         if (l.goalentity)
 240                         {
 241                                 l.goalentity.takedamage = DAMAGE_AIM;
 242                                 l.goalentity.bot_attack = TRUE;
 243                         }
 244                 }
 245                 onslaught_controlpoint_updatesprite(l);
 246                 l = l.chain;
 247         }
 248         // count generators owned by each team
 249         t1 = t2 = t3 = t4 = 0;
 250         l = findchain(classname, "onslaught_generator");
 251         while (l)
 252         {
 253                 if (l.iscaptured)
 254                 {
 255                         if (l.team == COLOR_TEAM1) t1 = 1;
 256                         if (l.team == COLOR_TEAM2) t2 = 1;
 257                         if (l.team == COLOR_TEAM3) t3 = 1;
 258                         if (l.team == COLOR_TEAM4) t4 = 1;
 259                 }
 260                 onslaught_generator_updatesprite(l);
 261                 l = l.chain;
 262         }
 263         // see if multiple teams remain (if not, it's game over)
 264         if (t1 + t2 + t3 + t4 < 2)
 265                 dprint("--- game over ---\n");
 266         else
 267                 dprint("--- done updating links ---\n");
 268 }
 269
 270 float onslaught_controlpoint_can_be_linked(entity cp, float t)
 271 {
 272         if(t == COLOR_TEAM1)
 273         {
 274                 if(cp.isgenneighbor_red)
 275                         return 2;
 276                 if(cp.iscpneighbor_red)
 277                         return 1;
 278         }
 279         else if(t == COLOR_TEAM2)
 280         {
 281                 if(cp.isgenneighbor_blue)
 282                         return 2;
 283                 if(cp.iscpneighbor_blue)
 284                         return 1;
 285         }
 286         return 0;
 287         /*
 288            entity e;
 289         // check to see if this player has a legitimate claim to capture this
 290         // control point - more specifically that there is a captured path of
 291         // points leading back to the team generator
 292         e = findchain(classname, "onslaught_link");
 293         while (e)
 294         {
 295         if (e.goalentity == cp)
 296         {
 297         dprint(etos(e), " (link) connects to ", etos(e.enemy), " (point)");
 298         if (e.enemy.islinked)
 299         {
 300         dprint(" which is linked");
 301         if (e.enemy.team == t)
 302         {
 303         dprint(" and has the correct team!\n");
 304         return 1;
 305         }
 306         else
 307         dprint(" but has the wrong team\n");
 308         }
 309         else
 310         dprint("\n");
 311         }
 312         else if (e.enemy == cp)
 313         {
 314         dprint(etos(e), " (link) connects to ", etos(e.goalentity), " (point)");
 315         if (e.goalentity.islinked)
 316         {
 317         dprint(" which is linked");
 318         if (e.goalentity.team == t)
 319         {
 320         dprint(" and has a team!\n");
 321         return 1;
 322         }
 323         else
 324         dprint(" but has the wrong team\n");
 325         }
 326         else
 327         dprint("\n");
 328         }
 329         e = e.chain;
 330         }
 331         return 0;
 332          */
 333 }
 334
 335 float onslaught_controlpoint_attackable(entity cp, float t)
 336         // -2: SAME TEAM, attackable by enemy!
 337         // -1: SAME TEAM!
 338         // 0: off limits
 339         // 1: attack it
 340         // 2: touch it
 341         // 3: attack it (HIGH PRIO)
 342         // 4: touch it (HIGH PRIO)
 343 {
 344         float a;
 345
 346         if(cp.isshielded)
 347         {
 348                 return 0;
 349         }
 350         else if(cp.goalentity)
 351         {
 352                 // if there's already an icon built, nothing happens
 353                 if(cp.team == t)
 354                 {
 355                         a = onslaught_controlpoint_can_be_linked(cp, COLOR_TEAM1 + COLOR_TEAM2 - t);
 356                         if(a) // attackable by enemy?
 357                                 return -2; // EMERGENCY!
 358                         return -1;
 359                 }
 360                 // we know it can be linked, so no need to check
 361                 // but...
 362                 a = onslaught_controlpoint_can_be_linked(cp, t);
 363                 if(a == 2) // near our generator?
 364                         return 3; // EMERGENCY!
 365                 return 1;
 366         }
 367         else
 368         {
 369                 // free point
 370                 if(onslaught_controlpoint_can_be_linked(cp, t))
 371                 {
 372                         a = onslaught_controlpoint_can_be_linked(cp, COLOR_TEAM1 + COLOR_TEAM2 - t);
 373                         if(a == 2)
 374                                 return 4; // GET THIS ONE NOW!
 375                         else
 376                                 return 2; // TOUCH ME
 377                 }
 378         }
 379         return 0;
 380 }
 381
 382 float overtime_msg_time;
 383 void onslaught_generator_think()
 384 {
 385         float d;
 386         entity e;
 387         self.nextthink = ceil(time + 1);
 388         if (!gameover)
 389         {
 390                 if (autocvar_timelimit && time > game_starttime + autocvar_timelimit * 60)
 391                 {
 392                         if (!overtime_msg_time)
 393                         {
 394                                 FOR_EACH_PLAYER(e)
 395                                         centerprint(e, "^3Now playing ^1OVERTIME^3!\n^3Generators start now to decay.\n^3The more control points your team holds,\n^3the faster the enemy generator decays.");
 396                                 overtime_msg_time = time;
 397                         }
 398                         // self.max_health / 300 gives 5 minutes of overtime.
 399                         // control points reduce the overtime duration.
 400                         sound(self, CH_TRIGGER, "onslaught/generator_decay.wav", VOL_BASE, ATTN_NORM);
 401                         d = 1;
 402                         e = findchain(classname, "onslaught_controlpoint");
 403                         while (e)
 404                         {
 405                                 if (e.team != self.team)
 406                                         if (e.islinked)
 407                                                 d = d + 1;
 408                                 e = e.chain;
 409                         }
 410
 411                         if(autocvar_g_campaign && autocvar__campaign_testrun)
 412                                 d = d * self.max_health;
 413                         else
 414                                 d = d * self.max_health / max(30, 60 * autocvar_timelimit_suddendeath);
 415
 416                         Damage(self, self, self, d, DEATH_HURTTRIGGER, self.origin, '0 0 0');
 417                 }
 418                 else if (overtime_msg_time)
 419                         overtime_msg_time = 0;
 420
 421         if(!self.isshielded && self.wait < time)
 422         {
 423             self.wait = time + 5;
 424             FOR_EACH_PLAYER(e)
 425             {
 426                 if(e.team == self.team)
 427                 {
 428                     centerprint(e, "^1Your generator is NOT shielded!\n^7Re-capture controlpoints to shield it!");
 429                     soundto(MSG_ONE, e, CHAN_AUTO, "kh/alarm.wav", VOL_BASE, ATTN_NONE);    // FIXME: Uniqe sound?
 430                 }
 431             }
 432         }
 433         }
 434 }
 435
 436 void onslaught_generator_ring_spawn(vector org)
 437 {
 438         modeleffect_spawn("models/onslaught/shockwavetransring.md3", 0, 0, org, '0 0 0', '0 0 0', '0 0 0', 0, -16, 0.1, 1.25, 0.25);
 439 }
 440
 441 void onslaught_generator_ray_think()
 442 {
 443         self.nextthink = time + 0.05;
 444         if(self.count > 10)
 445         {
 446                 self.think = SUB_Remove;
 447                 return;
 448         }
 449
 450         if(self.count > 5)
 451                 self.alpha -= 0.1;
 452         else
 453                 self.alpha += 0.1;
 454
 455         self.scale += 0.2;
 456         self.count +=1;
 457 }
 458
 459 void onslaught_generator_ray_spawn(vector org)
 460 {
 461         entity e;
 462         e = spawn();
 463         setmodel(e, "models/onslaught/ons_ray.md3");
 464         setorigin(e, org);
 465         e.angles = randomvec() * 360;
 466         e.alpha = 0;
 467         e.scale = random() * 5 + 8;
 468         e.think = onslaught_generator_ray_think;
 469         e.nextthink = time + 0.05;
 470 }
 471
 472 void onslaught_generator_shockwave_spawn(vector org)
 473 {
 474         shockwave_spawn("models/onslaught/shockwave.md3", org, -64, 0.75, 0.5);
 475 }
 476
 477 void onslaught_generator_damage_think()
 478 {
 479         if(self.owner.health < 0)
 480         {
 481                 self.think = SUB_Remove;
 482                 return;
 483         }
 484         self.nextthink = time+0.1;
 485
 486         // damaged fx (less probable the more damaged is the generator)
 487         if(random() < 0.9 - self.owner.health / self.owner.max_health)
 488                 if(random() < 0.01)
 489                 {
 490                         pointparticles(particleeffectnum("electro_ballexplode"), self.origin + randompos('-50 -50 -20', '50 50 50'), '0 0 0', 1);
 491                         sound(self, CH_TRIGGER, "onslaught/electricity_explode.wav", VOL_BASE, ATTN_NORM);
 492                 }
 493                 else
 494                         pointparticles(particleeffectnum("torch_small"), self.origin + randompos('-60 -60 -20', '60 60 60'), '0 0 0', 1);
 495 }
 496
 497 void onslaught_generator_damage_spawn(entity gd_owner)
 498 {
 499         entity e;
 500         e = spawn();
 501         e.owner = gd_owner;
 502         e.health = self.owner.health;
 503         setorigin(e, gd_owner.origin);
 504         e.think = onslaught_generator_damage_think;
 505         e.nextthink = time+1;
 506 }
 507
 508 void onslaught_generator_deaththink()
 509 {
 510         vector org;
 511         float i;
 512
 513         if not (self.count)
 514                 self.count = 40;
 515
 516         // White shockwave
 517         if(self.count==40||self.count==20)
 518         {
 519                 onslaught_generator_ring_spawn(self.origin);
 520                 sound(self, CH_TRIGGER, "onslaught/shockwave.wav", VOL_BASE, ATTN_NORM);
 521         }
 522
 523         // Throw some gibs
 524         if(random() < 0.3)
 525         {
 526                 i = random();
 527                 if(i < 0.3)
 528                         ons_throwgib(self.origin + '0 0 40', (100 * randomvec() - '1 1 1') * 11 + '0 0 20', "models/onslaught/gen_gib1.md3", 6, TRUE);
 529                 else if(i > 0.7)
 530                         ons_throwgib(self.origin + '0 0 40', (100 * randomvec() - '1 1 1') * 12 + '0 0 20', "models/onslaught/gen_gib2.md3", 6, TRUE);
 531                 else
 532                         ons_throwgib(self.origin + '0 0 40', (100 * randomvec() - '1 1 1') * 13 + '0 0 20', "models/onslaught/gen_gib3.md3", 6, TRUE);
 533         }
 534
 535         // Spawn fire balls
 536         for(i=0;i < 10;++i)
 537         {
 538                 org = self.origin + randompos('-30 -30 -30' * i + '0 0 -20', '30 30 30' * i + '0 0 20');
 539                 pointparticles(particleeffectnum("onslaught_generator_gib_explode"), org, '0 0 0', 1);
 540         }
 541
 542         // Short explosion sound + small explosion
 543         if(random() < 0.25)
 544         {
 545                 te_explosion(self.origin);
 546                 sound(self, CH_TRIGGER, "weapons/grenade_impact.wav", VOL_BASE, ATTN_NORM);
 547         }
 548
 549         // Particles
 550         org = self.origin + randompos(self.mins + '8 8 8', self.maxs + '-8 -8 -8');
 551         pointparticles(particleeffectnum("onslaught_generator_smallexplosion"), org, '0 0 0', 1);
 552
 553         // rays
 554         if(random() > 0.25 )
 555         {
 556                 onslaught_generator_ray_spawn(self.origin);
 557         }
 558
 559         // Final explosion
 560         if(self.count==1)
 561         {
 562                 org = self.origin;
 563                 te_explosion(org);
 564                 onslaught_generator_shockwave_spawn(org);
 565                 pointparticles(particleeffectnum("onslaught_generator_finalexplosion"), org, '0 0 0', 1);
 566                 sound(self, CH_TRIGGER, "weapons/rocket_impact.wav", VOL_BASE, ATTN_NORM);
 567         }
 568         else
 569                 self.nextthink = time + 0.05;
 570
 571         self.count = self.count - 1;
 572 }
 573
 574 void onslaught_generator_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
 575 {
 576         float i;
 577         if (damage <= 0)
 578                 return;
 579         if(inWarmupStage)
 580                 return;
 581         if (attacker != self)
 582         {
 583                 if (self.isshielded)
 584                 {
 585                         // this is protected by a shield, so ignore the damage
 586                         if (time > self.pain_finished)
 587                                 if (attacker.classname == "player")
 588                                 {
 589                                         play2(attacker, "onslaught/damageblockedbyshield.wav");
 590                                         self.pain_finished = time + 1;
 591                                 }
 592                         return;
 593                 }
 594                 if (time > self.pain_finished)
 595                 {
 596                         self.pain_finished = time + 10;
 597                         bprint(ColoredTeamName(self.team), " generator under attack!\n");
 598                         play2team(self.team, "onslaught/generator_underattack.wav");
 599                 }
 600         }
 601         self.health = self.health - damage;
 602         WaypointSprite_UpdateHealth(self.sprite, self.health);
 603         // choose an animation frame based on health
 604         self.frame = 10 * bound(0, (1 - self.health / self.max_health), 1);
 605         // see if the generator is still functional, or dying
 606         if (self.health > 0)
 607         {
 608 #ifdef ONSLAUGHT_SPAM
 609                 float h, lh;
 610                 lh = ceil(self.lasthealth / 100) * 100;
 611                 h = ceil(self.health / 100) * 100;
 612                 if(lh != h)
 613                         bprint(ColoredTeamName(self.team), " generator has less than ", ftos(h), " health remaining\n");
 614 #endif
 615                 self.lasthealth = self.health;
 616         }
 617         else if not(inWarmupStage)
 618         {
 619                 if (attacker == self)
 620                         bprint(ColoredTeamName(self.team), " generator spontaneously exploded due to overtime!\n");
 621                 else
 622                 {
 623                         string t;
 624                         t = ColoredTeamName(attacker.team);
 625                         bprint(ColoredTeamName(self.team), " generator destroyed by ", t, "!\n");
 626                 }
 627                 self.iscaptured = FALSE;
 628                 self.islinked = FALSE;
 629                 self.isshielded = FALSE;
 630                 self.takedamage = DAMAGE_NO; // can't be hurt anymore
 631                 self.event_damage = func_null; // won't do anything if hurt
 632                 self.count = 0; // reset counter
 633                 self.think = onslaught_generator_deaththink; // explosion sequence
 634                 self.nextthink = time; // start exploding immediately
 635                 self.think(); // do the first explosion now
 636
 637                 WaypointSprite_UpdateMaxHealth(self.sprite, 0);
 638
 639                 onslaught_updatelinks();
 640         }
 641
 642         if(self.health <= 0)
 643                 setmodel(self, "models/onslaught/generator_dead.md3");
 644         else if(self.health < self.max_health * 0.10)
 645                 setmodel(self, "models/onslaught/generator_dmg9.md3");
 646         else if(self.health < self.max_health * 0.20)
 647                 setmodel(self, "models/onslaught/generator_dmg8.md3");
 648         else if(self.health < self.max_health * 0.30)
 649                 setmodel(self, "models/onslaught/generator_dmg7.md3");
 650         else if(self.health < self.max_health * 0.40)
 651                 setmodel(self, "models/onslaught/generator_dmg6.md3");
 652         else if(self.health < self.max_health * 0.50)
 653                 setmodel(self, "models/onslaught/generator_dmg5.md3");
 654         else if(self.health < self.max_health * 0.60)
 655                 setmodel(self, "models/onslaught/generator_dmg4.md3");
 656         else if(self.health < self.max_health * 0.70)
 657                 setmodel(self, "models/onslaught/generator_dmg3.md3");
 658         else if(self.health < self.max_health * 0.80)
 659                 setmodel(self, "models/onslaught/generator_dmg2.md3");
 660         else if(self.health < self.max_health * 0.90)
 661                 setmodel(self, "models/onslaught/generator_dmg1.md3");
 662         setsize(self, '-52 -52 -14', '52 52 75');
 663
 664         // Throw some flaming gibs on damage, more damage = more chance for gib
 665         if(random() < damage/220)
 666         {
 667                 sound(self, CH_TRIGGER, "weapons/rocket_impact.wav", VOL_BASE, ATTN_NORM);
 668                 i = random();
 669                 if(i < 0.3)
 670                         ons_throwgib(hitloc + '0 0 20', force * -1, "models/onslaught/gen_gib1.md3", 5, TRUE);
 671                 else if(i > 0.7)
 672                         ons_throwgib(hitloc + '0 0 20', force * -1, "models/onslaught/gen_gib2.md3", 5, TRUE);
 673                 else
 674                         ons_throwgib(hitloc + '0 0 20', force * -1, "models/onslaught/gen_gib3.md3", 5, TRUE);
 675         }
 676         else
 677         {
 678                 // particles on every hit
 679                 pointparticles(particleeffectnum("sparks"), hitloc, force * -1, 1);
 680
 681                 //sound on every hit
 682                 if (random() < 0.5)
 683                         sound(self, CH_TRIGGER, "onslaught/ons_hit1.wav", VOL_BASE, ATTN_NORM);
 684                 else
 685                         sound(self, CH_TRIGGER, "onslaught/ons_hit2.wav", VOL_BASE, ATTN_NORM);
 686         }
 687
 688         //throw some gibs on damage
 689         if(random() < damage/200+0.2)
 690                 if(random() < 0.5)
 691                         ons_throwgib(hitloc + '0 0 20', randomvec()*360, "models/onslaught/gen_gib1.md3", 5, FALSE);
 692 }
 693
 694 // update links after a delay
 695 void onslaught_generator_delayed()
 696 {
 697         onslaught_updatelinks();
 698         // now begin normal thinking
 699         self.think = onslaught_generator_think;
 700         self.nextthink = time;
 701 }
 702
 703 string onslaught_generator_waypointsprite_for_team(entity e, float t)
 704 {
 705         if(t == e.team)
 706         {
 707                 if(e.team == COLOR_TEAM1)
 708                         return "ons-gen-red";
 709                 else if(e.team == COLOR_TEAM2)
 710                         return "ons-gen-blue";
 711         }
 712         if(e.isshielded)
 713                 return "ons-gen-shielded";
 714         if(e.team == COLOR_TEAM1)
 715                 return "ons-gen-red";
 716         else if(e.team == COLOR_TEAM2)
 717                 return "ons-gen-blue";
 718         return "";
 719 }
 720
 721 void onslaught_generator_updatesprite(entity e)
 722 {
 723         string s1, s2, s3;
 724         s1 = onslaught_generator_waypointsprite_for_team(e, COLOR_TEAM1);
 725         s2 = onslaught_generator_waypointsprite_for_team(e, COLOR_TEAM2);
 726         s3 = onslaught_generator_waypointsprite_for_team(e, -1);
 727         WaypointSprite_UpdateSprites(e.sprite, s1, s2, s3);
 728
 729         if(e.lastteam != e.team + 2 || e.lastshielded != e.isshielded)
 730         {
 731                 e.lastteam = e.team + 2;
 732                 e.lastshielded = e.isshielded;
 733                 if(e.lastshielded)
 734                 {
 735                         if(e.team == COLOR_TEAM1 || e.team == COLOR_TEAM2)
 736                                 WaypointSprite_UpdateTeamRadar(e.sprite, RADARICON_GENERATOR, 0.5 * colormapPaletteColor(e.team - 1, FALSE));
 737                         else
 738                                 WaypointSprite_UpdateTeamRadar(e.sprite, RADARICON_GENERATOR, '0.5 0.5 0.5');
 739                 }
 740                 else
 741                 {
 742                         if(e.team == COLOR_TEAM1 || e.team == COLOR_TEAM2)
 743                                 WaypointSprite_UpdateTeamRadar(e.sprite, RADARICON_GENERATOR, colormapPaletteColor(e.team - 1, FALSE));
 744                         else
 745                                 WaypointSprite_UpdateTeamRadar(e.sprite, RADARICON_GENERATOR, '0.75 0.75 0.75');
 746                 }
 747                 WaypointSprite_Ping(e.sprite);
 748         }
 749 }
 750
 751 string onslaught_controlpoint_waypointsprite_for_team(entity e, float t)
 752 {
 753         float a;
 754         if(t != -1)
 755         {
 756                 a = onslaught_controlpoint_attackable(e, t);
 757                 if(a == 3 || a == 4) // ATTACK/TOUCH THIS ONE NOW
 758                 {
 759                         if(e.team == COLOR_TEAM1)
 760                                 return "ons-cp-atck-red";
 761                         else if(e.team == COLOR_TEAM2)
 762                                 return "ons-cp-atck-blue";
 763                         else
 764                                 return "ons-cp-atck-neut";
 765                 }
 766                 else if(a == -2) // DEFEND THIS ONE NOW
 767                 {
 768                         if(e.team == COLOR_TEAM1)
 769                                 return "ons-cp-dfnd-red";
 770                         else if(e.team == COLOR_TEAM2)
 771                                 return "ons-cp-dfnd-blue";
 772                 }
 773                 else if(e.team == t || a == -1 || a == 1) // own point, or fire at it
 774                 {
 775                         if(e.team == COLOR_TEAM1)
 776                                 return "ons-cp-red";
 777                         else if(e.team == COLOR_TEAM2)
 778                                 return "ons-cp-blue";
 779                 }
 780                 else if(a == 2) // touch it
 781                         return "ons-cp-neut";
 782         }
 783         else
 784         {
 785                 if(e.team == COLOR_TEAM1)
 786                         return "ons-cp-red";
 787                 else if(e.team == COLOR_TEAM2)
 788                         return "ons-cp-blue";
 789                 else
 790                         return "ons-cp-neut";
 791         }
 792         return "";
 793 }
 794
 795 void onslaught_controlpoint_updatesprite(entity e)
 796 {
 797         string s1, s2, s3;
 798         s1 = onslaught_controlpoint_waypointsprite_for_team(e, COLOR_TEAM1);
 799         s2 = onslaught_controlpoint_waypointsprite_for_team(e, COLOR_TEAM2);
 800         s3 = onslaught_controlpoint_waypointsprite_for_team(e, -1);
 801         WaypointSprite_UpdateSprites(e.sprite, s1, s2, s3);
 802
 803         float sh;
 804         sh = !(onslaught_controlpoint_can_be_linked(e, COLOR_TEAM1) || onslaught_controlpoint_can_be_linked(e, COLOR_TEAM2));
 805
 806         if(e.lastteam != e.team + 2 || e.lastshielded != sh || e.iscaptured != e.lastcaptured)
 807         {
 808                 if(e.iscaptured) // don't mess up build bars!
 809                 {
 810                         if(sh)
 811                         {
 812                                 WaypointSprite_UpdateMaxHealth(e.sprite, 0);
 813                         }
 814                         else
 815                         {
 816                                 WaypointSprite_UpdateMaxHealth(e.sprite, e.goalentity.max_health);
 817                                 WaypointSprite_UpdateHealth(e.sprite, e.goalentity.health);
 818                         }
 819                 }
 820                 if(e.lastshielded)
 821                 {
 822                         if(e.team == COLOR_TEAM1 || e.team == COLOR_TEAM2)
 823                                 WaypointSprite_UpdateTeamRadar(e.sprite, RADARICON_CONTROLPOINT, 0.5 * colormapPaletteColor(e.team - 1, FALSE));
 824                         else
 825                                 WaypointSprite_UpdateTeamRadar(e.sprite, RADARICON_CONTROLPOINT, '0.5 0.5 0.5');
 826                 }
 827                 else
 828                 {
 829                         if(e.team == COLOR_TEAM1 || e.team == COLOR_TEAM2)
 830                                 WaypointSprite_UpdateTeamRadar(e.sprite, RADARICON_CONTROLPOINT, colormapPaletteColor(e.team - 1, FALSE));
 831                         else
 832                                 WaypointSprite_UpdateTeamRadar(e.sprite, RADARICON_CONTROLPOINT, '0.75 0.75 0.75');
 833                 }
 834                 WaypointSprite_Ping(e.sprite);
 835
 836                 e.lastteam = e.team + 2;
 837                 e.lastshielded = sh;
 838                 e.lastcaptured = e.iscaptured;
 839         }
 840 }
 841
 842 void onslaught_generator_reset()
 843 {
 844         self.team = self.team_saved;
 845         self.lasthealth = self.max_health = self.health = autocvar_g_onslaught_gen_health;
 846         self.takedamage = DAMAGE_AIM;
 847         self.bot_attack = TRUE;
 848         self.iscaptured = TRUE;
 849         self.islinked = TRUE;
 850         self.isshielded = TRUE;
 851         self.enemy.solid = SOLID_NOT;
 852         self.think = onslaught_generator_delayed;
 853         self.nextthink = time + 0.2;
 854         setmodel(self, "models/onslaught/generator.md3");
 855         setsize(self, '-52 -52 -14', '52 52 75');
 856
 857         if (!self.noalign)
 858         droptofloor();
 859
 860         WaypointSprite_UpdateMaxHealth(self.sprite, self.max_health);
 861         WaypointSprite_UpdateHealth(self.sprite, self.health);
 862 }
 863
 864 /*QUAKED spawnfunc_onslaught_generator (0 .5 .8) (-32 -32 -24) (32 32 64)
 865   Base generator.
 866
 867   spawnfunc_onslaught_link entities can target this.
 868
 869 keys:
 870 "team" - team that owns this generator (5 = red, 14 = blue, etc), MUST BE SET.
 871 "targetname" - name that spawnfunc_onslaught_link entities will use to target this.
 872  */
 873 void spawnfunc_onslaught_generator()
 874 {
 875         if (!g_onslaught)
 876         {
 877                 remove(self);
 878                 return;
 879         }
 880
 881         //entity e;
 882         precache_model("models/onslaught/generator.md3");
 883         precache_model("models/onslaught/generator_shield.md3");
 884         precache_model("models/onslaught/generator_dmg1.md3");
 885         precache_model("models/onslaught/generator_dmg2.md3");
 886         precache_model("models/onslaught/generator_dmg3.md3");
 887         precache_model("models/onslaught/generator_dmg4.md3");
 888         precache_model("models/onslaught/generator_dmg5.md3");
 889         precache_model("models/onslaught/generator_dmg6.md3");
 890         precache_model("models/onslaught/generator_dmg7.md3");
 891         precache_model("models/onslaught/generator_dmg8.md3");
 892         precache_model("models/onslaught/generator_dmg9.md3");
 893         precache_model("models/onslaught/generator_dead.md3");
 894         precache_model("models/onslaught/shockwave.md3");
 895         precache_model("models/onslaught/shockwavetransring.md3");
 896         precache_model("models/onslaught/gen_gib1.md3");
 897         precache_model("models/onslaught/gen_gib2.md3");
 898         precache_model("models/onslaught/gen_gib3.md3");
 899         precache_model("models/onslaught/ons_ray.md3");
 900         precache_sound("onslaught/generator_decay.wav");
 901         precache_sound("weapons/grenade_impact.wav");
 902         precache_sound("weapons/rocket_impact.wav");
 903         precache_sound("onslaught/generator_underattack.wav");
 904         precache_sound("onslaught/shockwave.wav");
 905         precache_sound("onslaught/ons_hit1.wav");
 906         precache_sound("onslaught/ons_hit2.wav");
 907         precache_sound("onslaught/electricity_explode.wav");
 908         if (!self.team)
 909                 objerror("team must be set");
 910
 911         if(self.team == COLOR_TEAM1)
 912         ons_red_generator = self;
 913
 914         if(self.team == COLOR_TEAM2)
 915         ons_blue_generator = self;
 916
 917         self.team_saved = self.team;
 918         self.colormap = 1024 + (self.team - 1) * 17;
 919         self.solid = SOLID_BBOX;
 920         self.movetype = MOVETYPE_NONE;
 921         self.lasthealth = self.max_health = self.health = autocvar_g_onslaught_gen_health;
 922         setmodel(self, "models/onslaught/generator.md3");
 923         setsize(self, '-52 -52 -14', '52 52 75');
 924         setorigin(self, self.origin);
 925         self.takedamage = DAMAGE_AIM;
 926         self.bot_attack = TRUE;
 927         self.event_damage = onslaught_generator_damage;
 928         self.iscaptured = TRUE;
 929         self.islinked = TRUE;
 930         self.isshielded = TRUE;
 931         // helper entity that create fx when generator is damaged
 932         onslaught_generator_damage_spawn(self);
 933         // spawn shield model which indicates whether this can be damaged
 934         self.enemy = spawn();
 935         setattachment(self.enemy , self, "");
 936         self.enemy.classname = "onslaught_generator_shield";
 937         self.enemy.solid = SOLID_NOT;
 938         self.enemy.movetype = MOVETYPE_NONE;
 939         self.enemy.effects = EF_ADDITIVE;
 940         setmodel(self.enemy, "models/onslaught/generator_shield.md3");
 941         //setorigin(e, self.origin);
 942         self.enemy.colormap = self.colormap;
 943         self.enemy.team = self.team;
 944         //self.think = onslaught_generator_delayed;
 945         //self.nextthink = time + 0.2;
 946         InitializeEntity(self, onslaught_generator_delayed, INITPRIO_LAST);
 947
 948         WaypointSprite_SpawnFixed(string_null, self.origin + '0 0 128', self, sprite, RADARICON_NONE, '0 0 0');
 949         WaypointSprite_UpdateRule(self.sprite, COLOR_TEAM2, SPRITERULE_TEAMPLAY);
 950         WaypointSprite_UpdateMaxHealth(self.sprite, self.max_health);
 951         WaypointSprite_UpdateHealth(self.sprite, self.health);
 952
 953         waypoint_spawnforitem(self);
 954
 955         onslaught_updatelinks();
 956
 957         self.reset = onslaught_generator_reset;
 958 }
 959
 960 .float waslinked;
 961 .float cp_bob_spd;
 962 .vector cp_origin, cp_bob_origin, cp_bob_dmg;
 963
 964 float ons_notification_time_team1;
 965 float ons_notification_time_team2;
 966
 967 void onslaught_controlpoint_icon_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
 968 {
 969         entity oself;
 970         float nag;
 971
 972         if (damage <= 0)
 973                 return;
 974         if (self.owner.isshielded)
 975         {
 976                 // this is protected by a shield, so ignore the damage
 977                 if (time > self.pain_finished)
 978                         if (attacker.classname == "player")
 979                         {
 980                                 play2(attacker, "onslaught/damageblockedbyshield.wav");
 981                                 self.pain_finished = time + 1;
 982                         }
 983                 return;
 984         }
 985
 986         if (attacker.classname == "player")
 987         {
 988                 nag = FALSE;
 989                 if(self.team == COLOR_TEAM1)
 990                 {
 991                         if(time - ons_notification_time_team1 > 10)
 992                         {
 993                                 nag = TRUE;
 994                                 ons_notification_time_team1 = time;
 995                         }
 996                 }
 997                 else if(self.team == COLOR_TEAM2)
 998                 {
 999                         if(time - ons_notification_time_team2 > 10)
1000                         {
1001                                 nag = TRUE;
1002                                 ons_notification_time_team2 = time;
1003                         }
1004                 }
1005                 else
1006                         nag = TRUE;
1007
1008                 if(nag)
1009                         play2team(self.team, "onslaught/controlpoint_underattack.wav");
1010         }
1011
1012         self.health = self.health - damage;
1013         if(self.owner.iscaptured)
1014                 WaypointSprite_UpdateHealth(self.owner.sprite, self.health);
1015         else
1016                 WaypointSprite_UpdateBuildFinished(self.owner.sprite, time + (self.max_health - self.health) / (self.count / sys_frametime));
1017         self.pain_finished = time + 1;
1018         self.punchangle = (2 * randomvec() - '1 1 1') * 45;
1019         self.cp_bob_dmg_z = (2 * random() - 1) * 15;
1020         // colormod flash when shot
1021         self.colormod = '2 2 2';
1022         // particles on every hit
1023         pointparticles(particleeffectnum("sparks"), hitloc, force*-1, 1);
1024         //sound on every hit
1025         if (random() < 0.5)
1026                 sound(self, CH_TRIGGER, "onslaught/ons_hit1.wav", VOL_BASE+0.3, ATTN_NORM);
1027         else
1028                 sound(self, CH_TRIGGER, "onslaught/ons_hit2.wav", VOL_BASE+0.3, ATTN_NORM);
1029
1030         if (self.health < 0)
1031         {
1032                 sound(self, CH_TRIGGER, "weapons/grenade_impact.wav", VOL_BASE, ATTN_NORM);
1033                 pointparticles(particleeffectnum("rocket_explode"), self.origin, '0 0 0', 1);
1034                 {
1035                         string t;
1036                         t = ColoredTeamName(attacker.team);
1037                         bprint(ColoredTeamName(self.team), " ", self.message, " control point destroyed by ", t, "\n");
1038                         ons_throwgib(self.origin, (2 * randomvec() - '1 1 1') * 25, "models/onslaught/controlpoint_icon_gib1.md3", 3, FALSE);
1039                         ons_throwgib(self.origin, (2 * randomvec() - '1 1 1') * 45, "models/onslaught/controlpoint_icon_gib2.md3", 3, FALSE);
1040                         ons_throwgib(self.origin, (2 * randomvec() - '1 1 1') * 45, "models/onslaught/controlpoint_icon_gib2.md3", 3, FALSE);
1041                         ons_throwgib(self.origin, (2 * randomvec() - '1 1 1') * 75, "models/onslaught/controlpoint_icon_gib4.md3", 3, FALSE);
1042                         ons_throwgib(self.origin, (2 * randomvec() - '1 1 1') * 75, "models/onslaught/controlpoint_icon_gib4.md3", 3, FALSE);
1043                         ons_throwgib(self.origin, (2 * randomvec() - '1 1 1') * 75, "models/onslaught/controlpoint_icon_gib4.md3", 3, FALSE);
1044                         ons_throwgib(self.origin, (2 * randomvec() - '1 1 1') * 75, "models/onslaught/controlpoint_icon_gib4.md3", 3, FALSE);
1045                 }
1046                 self.owner.goalentity = world;
1047                 self.owner.islinked = FALSE;
1048                 self.owner.iscaptured = FALSE;
1049                 self.owner.team = 0;
1050                 self.owner.colormap = 1024;
1051
1052                 WaypointSprite_UpdateMaxHealth(self.owner.sprite, 0);
1053
1054                 onslaught_updatelinks();
1055
1056                 // Use targets now (somebody make sure this is in the right place..)
1057                 oself = self;
1058                 self = self.owner;
1059                 activator = self;
1060                 SUB_UseTargets ();
1061                 self = oself;
1062
1063
1064                 self.owner.waslinked = self.owner.islinked;
1065                 if(self.owner.model != "models/onslaught/controlpoint_pad.md3")
1066                         setmodel(self.owner, "models/onslaught/controlpoint_pad.md3");
1067                 //setsize(self, '-32 -32 0', '32 32 8');
1068
1069                 remove(self);
1070         }
1071 }
1072
1073 void onslaught_controlpoint_icon_think()
1074 {
1075         entity oself;
1076         self.nextthink = time + sys_frametime;
1077
1078         if(autocvar_g_onslaught_controlpoints_proxycap)
1079         {
1080         float _enemy_count = 0;
1081         float _friendly_count = 0;
1082         float _dist;
1083         entity _player;
1084
1085         FOR_EACH_PLAYER(_player)
1086         {
1087             if(!_player.deadflag)
1088             {
1089                 _dist = vlen(_player.origin - self.origin);
1090                 if(_dist < autocvar_g_onslaught_controlpoints_proxycap_distance)
1091                 {
1092                     if(_player.team == self.team)
1093                         ++_friendly_count;
1094                     else
1095                         ++_enemy_count;
1096                 }
1097             }
1098         }
1099
1100         _friendly_count = _friendly_count * (autocvar_g_onslaught_controlpoints_proxycap_dps * sys_frametime);
1101         _enemy_count = _enemy_count * (autocvar_g_onslaught_controlpoints_proxycap_dps * sys_frametime);
1102
1103         self.health = bound(0, self.health + (_friendly_count - _enemy_count), self.max_health);
1104         if(self.health <= 0)
1105         {
1106             onslaught_controlpoint_icon_damage(self, self, 1, 0, self.origin, '0 0 0');
1107             return;
1108         }
1109     }
1110
1111         if (time > self.pain_finished + 5)
1112         {
1113                 if(self.health < self.max_health)
1114                 {
1115                         self.health = self.health + self.count;
1116                         if (self.health >= self.max_health)
1117                                 self.health = self.max_health;
1118                         WaypointSprite_UpdateHealth(self.owner.sprite, self.health);
1119                 }
1120         }
1121         if (self.health < self.max_health * 0.25)
1122                 setmodel(self, "models/onslaught/controlpoint_icon_dmg3.md3");
1123         else if (self.health < self.max_health * 0.50)
1124                 setmodel(self, "models/onslaught/controlpoint_icon_dmg2.md3");
1125         else if (self.health < self.max_health * 0.75)
1126                 setmodel(self, "models/onslaught/controlpoint_icon_dmg1.md3");
1127         else if (self.health < self.max_health * 0.90)
1128                 setmodel(self, "models/onslaught/controlpoint_icon.md3");
1129         // colormod flash when shot
1130         self.colormod = '1 1 1' * (2 - bound(0, (self.pain_finished - time) / 10, 1));
1131
1132         if(self.owner.islinked != self.owner.waslinked)
1133         {
1134                 // unteam the spawnpoint if needed
1135                 float t;
1136                 t = self.owner.team;
1137                 if(!self.owner.islinked)
1138                         self.owner.team = 0;
1139
1140                 oself = self;
1141                 self = self.owner;
1142                 activator = self;
1143                 SUB_UseTargets ();
1144                 self = oself;
1145
1146                 self.owner.team = t;
1147
1148                 self.owner.waslinked = self.owner.islinked;
1149         }
1150
1151         if (self.punchangle_x > 0)
1152         {
1153                 self.punchangle_x = self.punchangle_x - 60 * sys_frametime;
1154                 if (self.punchangle_x < 0)
1155                         self.punchangle_x = 0;
1156         }
1157         else if (self.punchangle_x < 0)
1158         {
1159                 self.punchangle_x = self.punchangle_x + 60 * sys_frametime;
1160                 if (self.punchangle_x > 0)
1161                         self.punchangle_x = 0;
1162         }
1163
1164         if (self.punchangle_y > 0)
1165         {
1166                 self.punchangle_y = self.punchangle_y - 60 * sys_frametime;
1167                 if (self.punchangle_y < 0)
1168                         self.punchangle_y = 0;
1169         }
1170         else if (self.punchangle_y < 0)
1171         {
1172                 self.punchangle_y = self.punchangle_y + 60 * sys_frametime;
1173                 if (self.punchangle_y > 0)
1174                         self.punchangle_y = 0;
1175         }
1176
1177         if (self.punchangle_z > 0)
1178         {
1179                 self.punchangle_z = self.punchangle_z - 60 * sys_frametime;
1180                 if (self.punchangle_z < 0)
1181                         self.punchangle_z = 0;
1182         }
1183         else if (self.punchangle_z < 0)
1184         {
1185                 self.punchangle_z = self.punchangle_z + 60 * sys_frametime;
1186                 if (self.punchangle_z > 0)
1187                         self.punchangle_z = 0;
1188         }
1189
1190         self.angles_x = self.punchangle_x;
1191         self.angles_y = self.punchangle_y + self.mangle_y;
1192         self.angles_z = self.punchangle_z;
1193         self.mangle_y = self.mangle_y + 45 * sys_frametime;
1194
1195         self.cp_bob_origin_z = 4 * PI * (1 - cos(self.cp_bob_spd));
1196         self.cp_bob_spd = self.cp_bob_spd + 1.875 * sys_frametime;
1197         if(self.cp_bob_dmg_z > 0)
1198                 self.cp_bob_dmg_z = self.cp_bob_dmg_z - 3 * sys_frametime;
1199         else
1200                 self.cp_bob_dmg_z = 0;
1201         setorigin(self,self.cp_origin + self.cp_bob_origin + self.cp_bob_dmg);
1202
1203         // damaged fx
1204         if(random() < 0.6 - self.health / self.max_health)
1205         {
1206                 pointparticles(particleeffectnum("electricity_sparks"), self.origin + randompos('-10 -10 -20', '10 10 20'), '0 0 0', 1);
1207
1208                 if(random() > 0.8)
1209                         sound(self, CH_PAIN, "onslaught/ons_spark1.wav", VOL_BASE, ATTN_NORM);
1210                 else if (random() > 0.5)
1211                         sound(self, CH_PAIN, "onslaught/ons_spark2.wav", VOL_BASE, ATTN_NORM);
1212         }
1213 }
1214
1215 void onslaught_controlpoint_icon_buildthink()
1216 {
1217         entity oself;
1218         float a;
1219
1220         self.nextthink = time + sys_frametime;
1221
1222         // only do this if there is power
1223         a = onslaught_controlpoint_can_be_linked(self.owner, self.owner.team);
1224         if(!a)
1225                 return;
1226
1227         self.health = self.health + self.count;
1228
1229         if (self.health >= self.max_health)
1230         {
1231                 self.health = self.max_health;
1232                 self.count = autocvar_g_onslaught_cp_regen * sys_frametime; // slow repair rate from now on
1233                 self.think = onslaught_controlpoint_icon_think;
1234                 sound(self, CH_TRIGGER, "onslaught/controlpoint_built.wav", VOL_BASE, ATTN_NORM);
1235                 bprint(ColoredTeamName(self.team), " captured ", self.owner.message, " control point\n");
1236                 self.owner.iscaptured = TRUE;
1237
1238                 WaypointSprite_UpdateMaxHealth(self.owner.sprite, self.max_health);
1239                 WaypointSprite_UpdateHealth(self.owner.sprite, self.health);
1240
1241                 onslaught_updatelinks();
1242
1243                 // Use targets now (somebody make sure this is in the right place..)
1244                 oself = self;
1245                 self = self.owner;
1246                 activator = self;
1247                 SUB_UseTargets ();
1248                 self = oself;
1249                 self.cp_origin = self.origin;
1250                 self.cp_bob_origin = '0 0 0.1';
1251                 self.cp_bob_spd = 0;
1252         }
1253         self.alpha = self.health / self.max_health;
1254         // colormod flash when shot
1255         self.colormod = '1 1 1' * (2 - bound(0, (self.pain_finished - time) / 10, 1));
1256         if(self.owner.model != "models/onslaught/controlpoint_pad2.md3")
1257                 setmodel(self.owner, "models/onslaught/controlpoint_pad2.md3");
1258         //setsize(self, '-32 -32 0', '32 32 8');
1259
1260         if(random() < 0.9 - self.health / self.max_health)
1261                 pointparticles(particleeffectnum("rage"), self.origin + 10 * randomvec(), '0 0 -1', 1);
1262 }
1263
1264
1265
1266
1267 void onslaught_controlpoint_touch()
1268 {
1269         entity e;
1270         float a;
1271         if (other.classname != "player")
1272                 return;
1273         a = onslaught_controlpoint_attackable(self, other.team);
1274         if(a != 2 && a != 4)
1275                 return;
1276         // we've verified that this player has a legitimate claim to this point,
1277         // so start building the captured point icon (which only captures this
1278         // point if it successfully builds without being destroyed first)
1279         self.goalentity = e = spawn();
1280         e.classname = "onslaught_controlpoint_icon";
1281         e.owner = self;
1282         e.max_health = autocvar_g_onslaught_cp_health;
1283         e.health = autocvar_g_onslaught_cp_buildhealth;
1284         e.solid = SOLID_BBOX;
1285         e.movetype = MOVETYPE_NONE;
1286         setmodel(e, "models/onslaught/controlpoint_icon.md3");
1287         setsize(e, '-32 -32 -32', '32 32 32');
1288         setorigin(e, self.origin + '0 0 96');
1289         e.takedamage = DAMAGE_AIM;
1290         e.bot_attack = TRUE;
1291         e.event_damage = onslaught_controlpoint_icon_damage;
1292         e.team = other.team;
1293         e.colormap = 1024 + (e.team - 1) * 17;
1294         e.think = onslaught_controlpoint_icon_buildthink;
1295         e.nextthink = time + sys_frametime;
1296         e.count = (e.max_health - e.health) * sys_frametime / autocvar_g_onslaught_cp_buildtime; // how long it takes to build
1297         sound(e, CH_TRIGGER, "onslaught/controlpoint_build.wav", VOL_BASE, ATTN_NORM);
1298         self.team = e.team;
1299         self.colormap = e.colormap;
1300         WaypointSprite_UpdateBuildFinished(self.sprite, time + (e.max_health - e.health) / (e.count / sys_frametime));
1301         onslaught_updatelinks();
1302 }
1303
1304 void onslaught_controlpoint_reset()
1305 {
1306         if(self.goalentity && self.goalentity != world)
1307                 remove(self.goalentity);
1308         self.goalentity = world;
1309         self.team = 0;
1310         self.colormap = 1024;
1311         self.iscaptured = FALSE;
1312         self.islinked = FALSE;
1313         self.isshielded = TRUE;
1314         self.enemy.solid = SOLID_NOT;
1315         self.enemy.colormap = self.colormap;
1316         self.think = self.enemy.think = func_null;
1317         self.nextthink = 0; // don't like func_null :P
1318         setmodel(self, "models/onslaught/controlpoint_pad.md3");
1319         //setsize(self, '-32 -32 0', '32 32 8');
1320
1321         WaypointSprite_UpdateMaxHealth(self.sprite, 0);
1322
1323         onslaught_updatelinks();
1324
1325         activator = self;
1326         SUB_UseTargets(); // to reset the structures, playerspawns etc.
1327 }
1328
1329 /*QUAKED spawnfunc_onslaught_controlpoint (0 .5 .8) (-32 -32 0) (32 32 128)
1330   Control point. Be sure to give this enough clearance so that the shootable part has room to exist
1331
1332   This should link to an spawnfunc_onslaught_controlpoint entity or spawnfunc_onslaught_generator entity.
1333
1334 keys:
1335 "targetname" - name that spawnfunc_onslaught_link entities will use to target this.
1336 "target" - target any entities that are tied to this control point, such as vehicles and buildable structure entities.
1337 "message" - name of this control point (should reflect the location in the map, such as "center bridge", "north tower", etc)
1338  */
1339
1340 void spawnfunc_onslaught_controlpoint()
1341 {
1342         //entity e;
1343         if (!g_onslaught)
1344         {
1345                 remove(self);
1346                 return;
1347         }
1348         precache_model("models/onslaught/controlpoint_pad.md3");
1349         precache_model("models/onslaught/controlpoint_pad2.md3");
1350         precache_model("models/onslaught/controlpoint_shield.md3");
1351         precache_model("models/onslaught/controlpoint_icon.md3");
1352         precache_model("models/onslaught/controlpoint_icon_dmg1.md3");
1353         precache_model("models/onslaught/controlpoint_icon_dmg2.md3");
1354         precache_model("models/onslaught/controlpoint_icon_dmg3.md3");
1355         precache_model("models/onslaught/controlpoint_icon_gib1.md3");
1356         precache_model("models/onslaught/controlpoint_icon_gib2.md3");
1357         precache_model("models/onslaught/controlpoint_icon_gib4.md3");
1358         precache_sound("onslaught/controlpoint_build.wav");
1359         precache_sound("onslaught/controlpoint_built.wav");
1360         precache_sound("weapons/grenade_impact.wav");
1361         precache_sound("onslaught/damageblockedbyshield.wav");
1362         precache_sound("onslaught/controlpoint_underattack.wav");
1363         precache_sound("onslaught/ons_spark1.wav");
1364         precache_sound("onslaught/ons_spark2.wav");
1365         self.solid = SOLID_BBOX;
1366         self.movetype = MOVETYPE_NONE;
1367         setmodel(self, "models/onslaught/controlpoint_pad.md3");
1368         //setsize(self, '-32 -32 0', '32 32 8');
1369         if (!self.noalign)
1370         droptofloor();
1371
1372         setorigin(self, self.origin);
1373         self.touch = onslaught_controlpoint_touch;
1374         self.team = 0;
1375         self.colormap = 1024;
1376         self.iscaptured = FALSE;
1377         self.islinked = FALSE;
1378         self.isshielded = TRUE;
1379         // spawn shield model which indicates whether this can be damaged
1380         self.enemy = spawn();
1381         self.enemy.classname = "onslaught_controlpoint_shield";
1382         self.enemy.solid = SOLID_NOT;
1383         self.enemy.movetype = MOVETYPE_NONE;
1384         self.enemy.effects = EF_ADDITIVE;
1385         setmodel(self.enemy , "models/onslaught/controlpoint_shield.md3");
1386
1387         setattachment(self.enemy , self, "");
1388         //setsize(e, '-32 -32 0', '32 32 128');
1389
1390         //setorigin(e, self.origin);
1391         self.enemy.colormap = self.colormap;
1392
1393         waypoint_spawnforitem(self);
1394
1395         WaypointSprite_SpawnFixed(string_null, self.origin + '0 0 128', self, sprite, RADARICON_NONE, '0 0 0');
1396         WaypointSprite_UpdateRule(self.sprite, COLOR_TEAM2, SPRITERULE_TEAMPLAY);
1397
1398         onslaught_updatelinks();
1399
1400         self.reset = onslaught_controlpoint_reset;
1401 }
1402
1403 float onslaught_link_send(entity to, float sendflags)
1404 {
1405         WriteByte(MSG_ENTITY, ENT_CLIENT_RADARLINK);
1406         WriteByte(MSG_ENTITY, sendflags);
1407         if(sendflags & 1)
1408         {
1409                 WriteCoord(MSG_ENTITY, self.goalentity.origin_x);
1410                 WriteCoord(MSG_ENTITY, self.goalentity.origin_y);
1411                 WriteCoord(MSG_ENTITY, self.goalentity.origin_z);
1412         }
1413         if(sendflags & 2)
1414         {
1415                 WriteCoord(MSG_ENTITY, self.enemy.origin_x);
1416                 WriteCoord(MSG_ENTITY, self.enemy.origin_y);
1417                 WriteCoord(MSG_ENTITY, self.enemy.origin_z);
1418         }
1419         if(sendflags & 4)
1420         {
1421                 WriteByte(MSG_ENTITY, self.clientcolors); // which is goalentity's color + enemy's color * 16
1422         }
1423         return TRUE;
1424 }
1425
1426 void onslaught_link_checkupdate()
1427 {
1428         // TODO check if the two sides have moved (currently they won't move anyway)
1429         float redpower, bluepower;
1430
1431         redpower = bluepower = 0;
1432         if(self.goalentity.islinked)
1433         {
1434                 if(self.goalentity.team == COLOR_TEAM1)
1435                         redpower = 1;
1436                 else if(self.goalentity.team == COLOR_TEAM2)
1437                         bluepower = 1;
1438         }
1439         if(self.enemy.islinked)
1440         {
1441                 if(self.enemy.team == COLOR_TEAM1)
1442                         redpower = 2;
1443                 else if(self.enemy.team == COLOR_TEAM2)
1444                         bluepower = 2;
1445         }
1446
1447         float cc;
1448         if(redpower == 1 && bluepower == 2)
1449                 cc = (COLOR_TEAM1 - 1) * 0x01 + (COLOR_TEAM2 - 1) * 0x10;
1450         else if(redpower == 2 && bluepower == 1)
1451                 cc = (COLOR_TEAM1 - 1) * 0x10 + (COLOR_TEAM2 - 1) * 0x01;
1452         else if(redpower)
1453                 cc = (COLOR_TEAM1 - 1) * 0x11;
1454         else if(bluepower)
1455                 cc = (COLOR_TEAM2 - 1) * 0x11;
1456         else
1457                 cc = 0;
1458
1459         //print(etos(self), " rp=", ftos(redpower), " bp=", ftos(bluepower), " ");
1460         //print("cc=", ftos(cc), "\n");
1461
1462         if(cc != self.clientcolors)
1463         {
1464                 self.clientcolors = cc;
1465                 self.SendFlags |= 4;
1466         }
1467
1468         self.nextthink = time;
1469 }
1470
1471 void onslaught_link_delayed()
1472 {
1473         self.goalentity = find(world, targetname, self.target);
1474         self.enemy = find(world, targetname, self.target2);
1475         if (!self.goalentity)
1476                 objerror("can not find target\n");
1477         if (!self.enemy)
1478                 objerror("can not find target2\n");
1479         dprint(etos(self.goalentity), " linked with ", etos(self.enemy), "\n");
1480         self.SendFlags |= 3;
1481         self.think = onslaught_link_checkupdate;
1482         self.nextthink = time;
1483 }
1484
1485 /*QUAKED spawnfunc_onslaught_link (0 .5 .8) (-16 -16 -16) (16 16 16)
1486   Link between control points.
1487
1488   This entity targets two different spawnfunc_onslaught_controlpoint or spawnfunc_onslaught_generator entities, and suppresses shielding on both if they are owned by different teams.
1489
1490 keys:
1491 "target" - first control point.
1492 "target2" - second control point.
1493  */
1494 void spawnfunc_onslaught_link()
1495 {
1496         if (!g_onslaught)
1497         {
1498                 remove(self);
1499                 return;
1500         }
1501         if (self.target == "" || self.target2 == "")
1502                 objerror("target and target2 must be set\n");
1503         InitializeEntity(self, onslaught_link_delayed, INITPRIO_FINDTARGET);
1504         Net_LinkEntity(self, FALSE, 0, onslaught_link_send);
1505 }
1506
1507 MUTATOR_HOOKFUNCTION(ons_BuildMutatorsString)
1508 {
1509         ret_string = strcat(ret_string, ":ONS");
1510         return 0;
1511 }
1512
1513 MUTATOR_HOOKFUNCTION(ons_BuildMutatorsPrettyString)
1514 {
1515         ret_string = strcat(ret_string, ", Onslught");
1516         return 0;
1517 }
1518
1519 MUTATOR_HOOKFUNCTION(ons_Spawn_Score)
1520 {
1521
1522     /*
1523     float _neer_home = (random() > 0.5 ? TRUE : FALSE);
1524
1525         RandomSelection_Init();
1526
1527         if(self.team == COLOR_TEAM1)
1528         RandomSelection_Add(ons_red_generator, 0, string_null, 1, 1);
1529
1530         if(self.team == COLOR_TEAM2)
1531         RandomSelection_Add(ons_blue_generator, 0, string_null, 1, 1);
1532
1533         entity _cp = findchain(classname, "onslaught_controlpoint"):
1534         while _cp;
1535         {
1536             if(_cp.team == self.team)
1537             RandomSelection_Add(_cp, 0, string_null, 1, 1);
1538
1539                 _cp = _cp.chain;
1540         }
1541
1542         if(RandomSelection_chosen_ent)
1543         {
1544                 self.tur_head = RandomSelection_chosen_ent;
1545                 spawn_score_x += SPAWN_PRIO_NEAR_TEAMMATE_FOUND;
1546         }
1547         else if(self.team == spawn_spot.team)
1548                 spawn_score_x += SPAWN_PRIO_NEAR_TEAMMATE_SAMETEAM; // prefer same team, if we can't find a spawn near teammate
1549
1550     */
1551
1552         return 0;
1553 }
1554
1555 MUTATOR_HOOKFUNCTION(ons_PlayerSpawn)
1556 {
1557     if(!autocvar_g_onslaught_spawn_at_controlpoints)
1558         return 0;
1559
1560     if(random() < 0.5)  // 50/50 chane to use default spawnsystem.
1561         return 0;
1562
1563     float _close_to_home = ((random() > 0.5) ? TRUE : FALSE);
1564     entity _best = world, _trg_gen = world;
1565     float _score, _best_score = MAX_SHOT_DISTANCE;
1566
1567         RandomSelection_Init();
1568
1569         if(self.team == COLOR_TEAM1)
1570         {
1571             if(!_close_to_home)
1572             _trg_gen = ons_blue_generator;
1573         else
1574             _trg_gen  = ons_red_generator;
1575         }
1576
1577         if(self.team == COLOR_TEAM2)
1578         {
1579             if(_close_to_home)
1580             _trg_gen = ons_blue_generator;
1581         else
1582             _trg_gen  = ons_red_generator;
1583         }
1584
1585         entity _cp = findchain(classname, "onslaught_controlpoint");
1586         while(_cp)
1587         {
1588             if(_cp.team == self.team)
1589         {
1590             _score = vlen(_trg_gen.origin - _cp.origin);
1591             if(_score < _best_score)
1592             {
1593                 _best = _cp;
1594                 _best_score = _score;
1595             }
1596         }
1597                 _cp = _cp.chain;
1598         }
1599
1600     vector _loc;
1601     float i;
1602     if(_best)
1603     {
1604         for(i = 0; i < 10; ++i)
1605         {
1606             _loc = _best.origin + '0 0 96';
1607             _loc += ('0 1 0' * random()) * 128;
1608             tracebox(_loc, PL_MIN, PL_MAX, _loc, MOVE_NORMAL, self);
1609             if(trace_fraction == 1.0 && !trace_startsolid)
1610             {
1611                 setorigin(self, _loc);
1612                 self.angles = normalize(_loc - _best.origin) * RAD2DEG;
1613                 return 0;
1614             }
1615         }
1616     }
1617     else
1618     {
1619         if(!autocvar_g_onslaught_spawn_at_generator)
1620             return 0;
1621
1622         _trg_gen = ((self.team == COLOR_TEAM1) ? ons_red_generator : ons_blue_generator);
1623
1624         for(i = 0; i < 10; ++i)
1625         {
1626             _loc = _trg_gen.origin + '0 0 96';
1627             _loc += ('0 1 0' * random()) * 128;
1628             tracebox(_loc, PL_MIN, PL_MAX, _loc, MOVE_NORMAL, self);
1629             if(trace_fraction == 1.0 && !trace_startsolid)
1630             {
1631                 setorigin(self, _loc);
1632                 self.angles = normalize(_loc - _trg_gen.origin) * RAD2DEG;
1633                 return 0;
1634             }
1635         }
1636     }
1637
1638     return 0;
1639 }
1640
1641 MUTATOR_DEFINITION(gamemode_onslaught)
1642 {
1643         MUTATOR_HOOK(BuildMutatorsPrettyString, ons_BuildMutatorsPrettyString, CBC_ORDER_ANY);
1644         MUTATOR_HOOK(BuildMutatorsString, ons_BuildMutatorsString, CBC_ORDER_ANY);
1645         MUTATOR_HOOK(PlayerSpawn, ons_PlayerSpawn, CBC_ORDER_ANY);
1646         //MUTATOR_HOOK(Spawn_Score, ons_Spawn_Score, CBC_ORDER_ANY);
1647
1648         MUTATOR_ONADD
1649         {
1650                 if(time > 1) // game loads at time 1
1651                         error("This is a game type and it cannot be added at runtime.");
1652         }
1653
1654         MUTATOR_ONREMOVE
1655         {
1656                 print("This is a game type and it cannot be removed at runtime.");
1657                 return -1;
1658         }
1659
1660         return 0;
1661 }