data/qcsrc/server/mode_onslaught.qc

   1
   2 .string target2;
   3 .float iscaptured;
   4 .float islinked;
   5 .float isshielded;
   6 void() onslaught_updatelinks =
   7 {
   8         local entity l, links;
   9         local float stop, t1, t2, t3, t4;
  10         // first check if the game has ended
  11         dprint("--- updatelinks ---\n");
  12         links = findchain(classname, "onslaught_link");
  13         // mark generators as being shielded and networked
  14         l = findchain(classname, "onslaught_generator");
  15         while (l)
  16         {
  17                 if (l.iscaptured)
  18                         dprint(etos(l), " (generator) belongs to team ", ftos(l.team), "\n");
  19                 else
  20                         dprint(etos(l), " (generator) is destroyed\n");
  21                 l.islinked = l.iscaptured;
  22                 l.isshielded = l.iscaptured;
  23                 l = l.chain;
  24         }
  25         // mark points as shielded and not networked
  26         l = findchain(classname, "onslaught_controlpoint");
  27         while (l)
  28         {
  29                 l.islinked = FALSE;
  30                 l.isshielded = TRUE;
  31                 dprint(etos(l), " (point) belongs to team ", ftos(l.team), "\n");
  32                 l = l.chain;
  33         }
  34         // flow power outward from the generators through the network
  35         l = links;
  36         while (l)
  37         {
  38                 dprint(etos(l), " (link) connects ", etos(l.goalentity), " with ", etos(l.enemy), "\n");
  39                 l = l.chain;
  40         }
  41         stop = FALSE;
  42         while (!stop)
  43         {
  44                 stop = TRUE;
  45                 l = links;
  46                 while (l)
  47                 {
  48                         // if both points are captured by the same team, and only one of
  49                         // them is powered, mark the other one as powered as well
  50                         if (l.enemy.iscaptured && l.goalentity.iscaptured)
  51                         if (l.enemy.islinked != l.goalentity.islinked)
  52                         if (l.enemy.team == l.goalentity.team)
  53                         {
  54                                 if (!l.goalentity.islinked)
  55                                 {
  56                                         stop = FALSE;
  57                                         l.goalentity.islinked = TRUE;
  58                                         dprint(etos(l), " (link) is marking ", etos(l.goalentity), " (point) because its team matches ", etos(l.enemy), " (point)\n");
  59                                 }
  60                                 else if (!l.enemy.islinked)
  61                                 {
  62                                         stop = FALSE;
  63                                         l.enemy.islinked = TRUE;
  64                                         dprint(etos(l), " (link) is marking ", etos(l.enemy), " (point) because its team matches ", etos(l.goalentity), " (point)\n");
  65                                 }
  66                         }
  67                         l = l.chain;
  68                 }
  69         }
  70         // now that we know which points are powered we can mark their neighbors
  71         // as unshielded if team differs
  72         l = links;
  73         while (l)
  74         {
  75                 if (l.goalentity.team != l.enemy.team)
  76                 {
  77                         if (l.goalentity.islinked)
  78                         {
  79                                 dprint(etos(l), " (link) is unshielding ", etos(l.enemy), " (point) because its team does not match ", etos(l.goalentity), " (point)\n");
  80                                 l.enemy.isshielded = FALSE;
  81                         }
  82                         if (l.enemy.islinked)
  83                         {
  84                                 dprint(etos(l), " (link) is unshielding ", etos(l.goalentity), " (point) because its team does not match ", etos(l.enemy), " (point)\n");
  85                                 l.goalentity.isshielded = FALSE;
  86                         }
  87                 }
  88                 l = l.chain;
  89         }
  90         // now update the takedamage and alpha variables on generator shields
  91         l = findchain(classname, "onslaught_generator");
  92         while (l)
  93         {
  94                 if (l.isshielded)
  95                 {
  96                         dprint(etos(l), " (generator) is shielded\n");
  97                         l.enemy.alpha = 1;
  98                         l.takedamage = DAMAGE_NO;
  99                         l.bot_attack = FALSE;
 100                 }
 101                 else
 102                 {
 103                         dprint(etos(l), " (generator) is not shielded\n");
 104                         l.enemy.alpha = -1;
 105                         l.takedamage = DAMAGE_AIM;
 106                         l.bot_attack = TRUE;
 107                 }
 108                 l = l.chain;
 109         }
 110         // now update the takedamage and alpha variables on control point icons
 111         l = findchain(classname, "onslaught_controlpoint");
 112         while (l)
 113         {
 114                 if (l.isshielded)
 115                 {
 116                         dprint(etos(l), " (point) is shielded\n");
 117                         l.enemy.alpha = 1;
 118                         if (l.goalentity)
 119                         {
 120                                 l.goalentity.takedamage = DAMAGE_NO;
 121                                 l.goalentity.bot_attack = FALSE;
 122                         }
 123                 }
 124                 else
 125                 {
 126                         dprint(etos(l), " (point) is not shielded\n");
 127                         l.enemy.alpha = -1;
 128                         if (l.goalentity)
 129                         {
 130                                 l.goalentity.takedamage = DAMAGE_AIM;
 131                                 l.goalentity.bot_attack = TRUE;
 132                         }
 133                 }
 134                 l = l.chain;
 135         }
 136         // count generators owned by each team
 137         t1 = t2 = t3 = t4 = 0;
 138         l = findchain(classname, "onslaught_generator");
 139         while (l)
 140         {
 141                 if (l.iscaptured)
 142                 {
 143                         if (l.team == COLOR_TEAM1) t1 = 1;
 144                         if (l.team == COLOR_TEAM2) t2 = 1;
 145                         if (l.team == COLOR_TEAM3) t3 = 1;
 146                         if (l.team == COLOR_TEAM4) t4 = 1;
 147                 }
 148                 l = l.chain;
 149         }
 150         // see if multiple teams remain (if not, it's game over)
 151         if (t1 + t2 + t3 + t4 < 2)
 152                 dprint("--- game over ---\n");
 153         else
 154                 dprint("--- done updating links ---\n");
 155 };
 156
 157 void() onslaught_generator_think =
 158 {
 159         local float d;
 160         local entity e;
 161         self.nextthink = ceil(time + 1);
 162         if (cvar("timelimit"))
 163         if (time > cvar("timelimit") * 60 - 60)
 164         {
 165                 // self.max_health / 300 gives 5 minutes of overtime.
 166                 // control points reduce the overtime duration.
 167                 sound(self, CHAN_AUTO, "sound/onslaught/generator_decay.wav", 1, ATTN_NORM);
 168                 d = 1;
 169                 e = findchain(classname, "onslaught_controlpoint");
 170                 while (e)
 171                 {
 172                         if (e.team != self.team)
 173                         if (e.islinked)
 174                                 d = d + 1;
 175                         e = e.chain;
 176                 }
 177                 d = d * self.max_health / 300;
 178                 Damage(self, self, self, d, DEATH_HURTTRIGGER, self.origin, '0 0 0');
 179         }
 180 };
 181
 182 void() onslaught_generator_deaththink =
 183 {
 184         local vector org;
 185         if (self.count > 0)
 186         {
 187                 self.nextthink = time + 0.1;
 188                 self.count = self.count - 1;
 189                 org = randompos(self.origin + self.mins + '8 8 8', self.origin + self.maxs + '-8 -8 -8');
 190                 pointparticles(particleeffectnum("onslaught_generator_smallexplosion"), org, '0 0 0', 1);
 191                 sound(self, CHAN_AUTO, "sound/weapons/grenade_impact.wav", 1, ATTN_NORM);
 192         }
 193         else
 194         {
 195                 org = self.origin;
 196                 pointparticles(particleeffectnum("onslaught_generator_finalexplosion"), org, '0 0 0', 1);
 197                 sound(self, CHAN_AUTO, "sound/weapons/rocket_impact.wav", 1, ATTN_NORM);
 198         }
 199 };
 200
 201 void(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force) onslaught_generator_damage =
 202 {
 203         if (damage <= 0)
 204                 return;
 205         if (attacker != self)
 206         {
 207                 if (self.isshielded)
 208                 {
 209                         // this is protected by a shield, so ignore the damage
 210                         if (time > self.pain_finished)
 211                         if (attacker.classname == "player")
 212                         {
 213                                 play2(attacker, "sound/onslaught/damageblockedbyshield.wav");
 214                                 self.pain_finished = time + 1;
 215                         }
 216                         return;
 217                 }
 218                 if (time > self.pain_finished)
 219                 {
 220                         self.pain_finished = time + 5;
 221                         bprint(ColoredTeamName(self.team), " generator under attack!\n");
 222                         play2team(self.team, "sound/onslaught/generator_underattack.wav");
 223                 }
 224         }
 225         self.health = self.health - damage;
 226         // choose an animation frame based on health
 227         self.frame = 10 * bound(0, (1 - self.health / self.max_health), 1);
 228         // see if the generator is still functional, or dying
 229         if (self.health > 0)
 230                 bprint(ColoredTeamName(self.team), " generator has ", ftos(floor(self.health)), " health remaining\n");
 231         else
 232         {
 233                 if (attacker == self)
 234                         bprint(ColoredTeamName(self.team), " generator spontaneously exploded due to overtime!\n");
 235                 else
 236                         bprint(ColoredTeamName(self.team), " generator destroyed by ", ColoredTeamName(attacker.team), "!\n");
 237                 self.iscaptured = FALSE;
 238                 self.islinked = FALSE;
 239                 self.isshielded = FALSE;
 240                 self.takedamage = DAMAGE_NO; // can't be hurt anymore
 241                 self.event_damage = SUB_Null; // won't do anything if hurt
 242                 self.count = 30; // 30 explosions
 243                 self.think = onslaught_generator_deaththink; // explosion sequence
 244                 self.nextthink = time; // start exploding immediately
 245                 self.think(); // do the first explosion now
 246                 onslaught_updatelinks();
 247         }
 248 };
 249
 250 // update links after a delay
 251 void() onslaught_generator_delayed =
 252 {
 253         onslaught_updatelinks();
 254         // now begin normal thinking
 255         self.think = onslaught_generator_think;
 256         self.nextthink = time;
 257 };
 258
 259 /*QUAKED onslaught_generator (0 .5 .8) (-32 -32 -24) (32 32 64)
 260 Base generator.
 261
 262 onslaught_link entities can target this.
 263
 264 keys:
 265 "team" - team that owns this generator (5 = red, 14 = blue, etc), MUST BE SET.
 266 "targetname" - name that onslaught_link entities will use to target this.
 267 */
 268 void() onslaught_generator =
 269 {
 270         if (!g_onslaught)
 271         {
 272                 remove(self);
 273                 return;
 274         }
 275         local entity e;
 276         precache_model("models/onslaught/generator.md3");
 277         precache_model("models/onslaught/generator_shield.md3");
 278         precache_sound("sound/onslaught/generator_decay.wav");
 279         precache_sound("sound/weapons/grenade_impact.wav");
 280         precache_sound("sound/weapons/rocket_impact.wav");
 281         precache_sound("sound/onslaught/generator_underattack.wav");
 282         if (!self.team)
 283                 objerror("team must be set");
 284         self.colormap = 1024 + (self.team - 1) * 17;
 285         self.solid = SOLID_BSP;
 286         self.movetype = MOVETYPE_NONE;
 287         self.max_health = self.health = 3000;
 288         setmodel(self, "models/onslaught/generator.md3");
 289         //setsize(self, '-32 -32 -24', '32 32 64');
 290         setorigin(self, self.origin);
 291         self.takedamage = DAMAGE_AIM;
 292         self.bot_attack = TRUE;
 293         self.event_damage = onslaught_generator_damage;
 294         self.iscaptured = TRUE;
 295         self.islinked = TRUE;
 296         self.isshielded = TRUE;
 297         // spawn shield model which indicates whether this can be damaged
 298         self.enemy = e = spawn();
 299         e.solid = SOLID_NOT;
 300         e.movetype = MOVETYPE_NONE;
 301         e.effects = EF_ADDITIVE;
 302         setmodel(e, "models/onslaught/generator_shield.md3");
 303         //setsize(e, '-32 -32 0', '32 32 128');
 304         setorigin(e, self.origin);
 305         e.colormap = self.colormap;
 306         e.team = self.team;
 307
 308         // use our "target"s (spawn points linked to generator for Morphed..)
 309         activator = self;
 310         SUB_UseTargets();
 311
 312         self.think = onslaught_generator_delayed;
 313         self.nextthink = time + 0.2;
 314 };
 315
 316 void(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force) onslaught_controlpoint_icon_damage =
 317 {
 318         entity oself;
 319         if (damage <= 0)
 320                 return;
 321         if (self.owner.isshielded)
 322         {
 323                 // this is protected by a shield, so ignore the damage
 324                 if (time > self.pain_finished)
 325                 if (attacker.classname == "player")
 326                 {
 327                         play2(attacker, "sound/onslaught/damageblockedbyshield.wav");
 328                         self.pain_finished = time + 1;
 329                 }
 330                 return;
 331         }
 332         if (time > self.pain_finished)
 333         if (attacker.classname == "player")
 334         {
 335                 play2team(self.team, "sound/onslaught/controlpoint_underattack.wav");
 336                 self.pain_finished = time + 5;
 337         }
 338         self.health = self.health - damage;
 339         self.alpha = self.health / self.max_health;
 340         self.pain_finished = time + 1;
 341         // colormod flash when shot
 342         self.colormod = '2 2 2';
 343         if (self.health < 0)
 344         {
 345                 sound(self, CHAN_AUTO, "sound/weapons/grenade_impact.wav", 1, ATTN_NORM);
 346                 pointparticles(particleeffectnum("onslaught_controlpoint_explosion"), self.origin, '0 0 0', 1);
 347                 bprint(ColoredTeamName(self.team), " ", self.message, " control point destroyed by ", ColoredTeamName(attacker.team), "\n");
 348                 self.owner.goalentity = world;
 349                 self.owner.islinked = FALSE;
 350                 self.owner.iscaptured = FALSE;
 351                 self.owner.team = 0;
 352                 self.owner.colormap = 1024;
 353                 onslaught_updatelinks();
 354
 355                 // Use targets now (somebody make sure this is in the right place..)
 356                 oself = self;
 357                 self = self.owner;
 358                 activator = self.owner;
 359                 SUB_UseTargets ();
 360                 self = oself;
 361
 362                 remove(self);
 363         }
 364 };
 365
 366 void() onslaught_controlpoint_icon_think =
 367 {
 368         self.nextthink = time + 0.1;
 369         if (time > self.pain_finished + 1)
 370         {
 371                 self.health = self.health + self.count;
 372                 if (self.health >= self.max_health)
 373                         self.health = self.max_health;
 374         }
 375         self.alpha = self.health / self.max_health;
 376         // colormod flash when shot
 377         self.colormod = '1 1 1' * (2 - bound(0, (self.pain_finished - time) / 10, 1));
 378 };
 379
 380 void() onslaught_controlpoint_icon_buildthink =
 381 {
 382         local entity oself;
 383
 384         self.nextthink = time + 0.1;
 385         self.health = self.health + self.count;
 386         if (self.health >= self.max_health)
 387         {
 388                 self.health = self.max_health;
 389                 self.count = self.count * 0.2; // slow repair rate from now on
 390                 self.think = onslaught_controlpoint_icon_think;
 391                 sound(self, CHAN_BODY, "sound/onslaught/controlpoint_built.wav", 1, ATTN_NORM);
 392                 bprint(ColoredTeamName(self.team), " captured ", self.owner.message, " control point\n");
 393                 self.owner.iscaptured = TRUE;
 394                 onslaught_updatelinks();
 395
 396                 // Use targets now (somebody make sure this is in the right place..)
 397                 oself = self;
 398                 self = self.owner;
 399                 activator = self;
 400                 SUB_UseTargets ();
 401                 self = oself;
 402         }
 403         self.alpha = self.health / self.max_health;
 404         // colormod flash when shot
 405         self.colormod = '1 1 1' * (2 - bound(0, (self.pain_finished - time) / 10, 1));
 406 };
 407
 408 void() onslaught_controlpoint_touch =
 409 {
 410         local entity e;
 411         if (other.classname != "player")
 412                 return;
 413         // if there's already an icon built, nothing happens
 414         if (self.goalentity)
 415         {
 416                 dprint("a\n");
 417                 return;
 418         }
 419         // shielded points are definitely off-limits
 420         if (self.isshielded)
 421         {
 422                 dprint("b\n");
 423                 return;
 424         }
 425         // check to see if this player has a legitimate claim to capture this
 426         // control point - more specifically that there is a captured path of
 427         // points leading back to the team generator
 428         e = findchain(classname, "onslaught_link");
 429         while (e)
 430         {
 431                 if (e.goalentity == self)
 432                 {
 433                         dprint(etos(e), " (link) connects to ", etos(e.enemy), " (point)");
 434                         if (e.enemy.islinked)
 435                         {
 436                                 dprint(" which is linked");
 437                                 if (e.enemy.team == other.team)
 438                                 {
 439                                         dprint(" and has the correct team!\n");
 440                                         break;
 441                                 }
 442                                 else
 443                                         dprint(" but has the wrong team\n");
 444                         }
 445                         else
 446                                 dprint("\n");
 447                 }
 448                 else if (e.enemy == self)
 449                 {
 450                         dprint(etos(e), " (link) connects to ", etos(e.goalentity), " (point)");
 451                         if (e.goalentity.islinked)
 452                         {
 453                                 dprint(" which is linked");
 454                                 if (e.goalentity.team == other.team)
 455                                 {
 456                                         dprint(" and has a team!\n");
 457                                         break;
 458                                 }
 459                                 else
 460                                         dprint(" but has the wrong team\n");
 461                         }
 462                         else
 463                                 dprint("\n");
 464                 }
 465                 e = e.chain;
 466         }
 467         if (!e)
 468         {
 469                 dprint("c\n");
 470                 return;
 471         }
 472         // we've verified that this player has a legitimate claim to this point,
 473         // so start building the captured point icon (which only captures this
 474         // point if it successfully builds without being destroyed first)
 475         self.goalentity = e = spawn();
 476         e.owner = self;
 477         e.max_health = 1000;
 478         e.health = e.max_health * 0.1;
 479         e.alpha = e.health / e.max_health;
 480         e.solid = SOLID_BBOX;
 481         e.movetype = MOVETYPE_NONE;
 482         setmodel(e, "models/onslaught/controlpoint_icon.md3");
 483         setsize(e, '-32 -32 -32', '32 32 32');
 484         setorigin(e, self.origin + '0 0 96');
 485         e.takedamage = DAMAGE_AIM;
 486         e.bot_attack = TRUE;
 487         e.event_damage = onslaught_controlpoint_icon_damage;
 488         e.team = other.team;
 489         e.colormap = 1024 + (e.team - 1) * 17;
 490         e.think = onslaught_controlpoint_icon_buildthink;
 491         e.nextthink = time + 0.1;
 492         e.count = e.max_health / 50; // how long it takes to build
 493         sound(e, CHAN_BODY, "sound/onslaught/controlpoint_build.wav", 1, ATTN_NORM);
 494         self.team = e.team;
 495         self.colormap = e.colormap;
 496 };
 497
 498 /*QUAKED onslaught_controlpoint (0 .5 .8) (-32 -32 0) (32 32 128)
 499 Control point.  Be sure to give this enough clearance so that the shootable part has room to exist
 500
 501 This should link to an onslaught_controlpoint entity or onslaught_generator entity.
 502
 503 keys:
 504 "targetname" - name that onslaught_link entities will use to target this.
 505 "target" - target any entities that are tied to this control point, such as vehicles and buildable structure entities.
 506 "message" - name of this control point (should reflect the location in the map, such as "center bridge", "north tower", etc)
 507 */
 508 void() onslaught_controlpoint =
 509 {
 510         local entity e;
 511         if (!g_onslaught)
 512         {
 513                 remove(self);
 514                 return;
 515         }
 516         precache_model("models/onslaught/controlpoint_pad.md3");
 517         precache_model("models/onslaught/controlpoint_shield.md3");
 518         precache_model("models/onslaught/controlpoint_icon.md3");
 519         precache_sound("sound/onslaught/controlpoint_build.wav");
 520         precache_sound("sound/onslaught/controlpoint_built.wav");
 521         precache_sound("sound/weapons/grenade_impact.wav");
 522         precache_sound("sound/onslaught/damageblockedbyshield.wav");
 523         precache_sound("sound/onslaught/controlpoint_underattack.wav");
 524         self.solid = SOLID_BSP;
 525         self.movetype = MOVETYPE_NONE;
 526         setmodel(self, "models/onslaught/controlpoint_pad.md3");
 527         //setsize(self, '-32 -32 0', '32 32 8');
 528         setorigin(self, self.origin);
 529         self.touch = onslaught_controlpoint_touch;
 530         self.team = 0;
 531         self.colormap = 1024;
 532         self.iscaptured = FALSE;
 533         self.islinked = FALSE;
 534         self.isshielded = TRUE;
 535         // spawn shield model which indicates whether this can be damaged
 536         self.enemy = e = spawn();
 537         e.solid = SOLID_NOT;
 538         e.movetype = MOVETYPE_NONE;
 539         e.effects = EF_ADDITIVE;
 540         setmodel(e, "models/onslaught/controlpoint_shield.md3");
 541         //setsize(e, '-32 -32 0', '32 32 128');
 542         setorigin(e, self.origin);
 543         e.colormap = self.colormap;
 544         onslaught_updatelinks();
 545 };
 546
 547 void() onslaught_link_delayed =
 548 {
 549         self.goalentity = find(world, targetname, self.target);
 550         self.enemy = find(world, targetname, self.target2);
 551         if (!self.goalentity)
 552                 objerror("can not find target\n");
 553         if (!self.enemy)
 554                 objerror("can not find target2\n");
 555         dprint(etos(self.goalentity), " linked with ", etos(self.enemy), "\n");
 556 }
 557
 558 /*QUAKED onslaught_link (0 .5 .8) (-16 -16 -16) (16 16 16)
 559 Link between control points.
 560
 561 This entity targets two different onslaught_controlpoint or onslaught_generator entities, and suppresses shielding on both if they are owned by different teams.
 562
 563 keys:
 564 "target" - first control point.
 565 "target2" - second control point.
 566 */
 567 void() onslaught_link =
 568 {
 569         if (!g_onslaught)
 570         {
 571                 remove(self);
 572                 return;
 573         }
 574         if (self.target == "" || self.target2 == "")
 575                 objerror("target and target2 must be set\n");
 576         self.think = onslaught_link_delayed;
 577         self.nextthink = time + 0.1;
 578 };