qcsrc/server/mutators/gamemode_towerdefense.qc

   1 // Tower Defense
   2 // Gamemode by Mario
   3
   4 void spawnfunc_td_controller()
   5 {
   6         if not(g_td) { remove(self); return; }
   7
   8         if(autocvar_g_td_force_settings)
   9         {
  10                 // TODO: find a better way to do this?
  11                 self.dontend = FALSE;
  12                 self.maxwaves = 0;
  13                 self.monstercount = 0;
  14                 self.startwave = 0;
  15                 self.maxturrets = 0;
  16                 self.buildtime = 0;
  17                 self.mspeed_walk = 0;
  18                 self.mspeed_run = 0;
  19                 self.spawndelay = 0;
  20                 self.maxcurrent = 0;
  21                 self.ignoreturrets = 0;
  22         }
  23
  24         self.netname = "Tower Defense controller entity";
  25         self.classname = "td_controller";
  26
  27         gensurvived = FALSE;
  28
  29         td_dont_end = ((self.dontend == 0) ? autocvar_g_td_generator_dontend : self.dontend);
  30         max_waves = ((self.maxwaves == 0) ? autocvar_g_td_max_waves : self.maxwaves);
  31         totalmonsters = ((self.monstercount == 0) ? autocvar_g_td_monster_count : self.monstercount);
  32         wave_count = ((self.startwave == 0) ? autocvar_g_td_start_wave : self.startwave);
  33         max_turrets = ((self.maxturrets == 0) ? autocvar_g_td_turret_max : self.maxturrets);
  34         build_time = ((self.buildtime == 0) ? autocvar_g_td_buildphase_time : self.buildtime);
  35         m_speed_walk = ((self.mspeed_walk == 0) ? autocvar_g_td_monsters_speed_walk : self.mspeed_walk);
  36         m_speed_run = ((self.mspeed_run == 0) ? autocvar_g_td_monsters_speed_run : self.mspeed_run);
  37         spawn_delay = ((self.spawndelay == 0) ? autocvar_g_td_monsters_spawn_delay : self.spawndelay);
  38         max_current = ((self.maxcurrent == 0) ? autocvar_g_td_current_monsters : self.maxcurrent);
  39         ignore_turrets = ((self.ignoreturrets == 0) ? autocvar_g_td_monsters_ignore_turrets : self.ignoreturrets);
  40
  41         if(autocvar_g_td_monsters_skill_start)
  42                 monster_skill = autocvar_g_td_monsters_skill_start;
  43
  44         wave_end(TRUE);
  45 }
  46
  47 void td_generator_die()
  48 {
  49         if(autocvar_sv_eventlog)
  50                 GameLogEcho(":gendestroyed");
  51
  52         gendestroyed = TRUE;
  53
  54         pointparticles(particleeffectnum("explosion_medium"), self.origin, '0 0 0', 1);
  55
  56         Send_Notification(NOTIF_ALL, world, MSG_MULTI, MULTI_TD_GENDESTROYED);
  57
  58         self.solid                      = SOLID_NOT;
  59         self.takedamage         = DAMAGE_NO;
  60         self.event_damage   = func_null;
  61         self.enemy                      = world;
  62         td_gencount                     -= 1;
  63
  64         WaypointSprite_Kill(self.sprite);
  65 }
  66
  67 void td_generator_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
  68 {
  69         if(IS_PLAYER(attacker) || attacker.turrcaps_flags & TFL_TURRCAPS_ISTURRET || attacker.vehicle_flags & VHF_ISVEHICLE)
  70                 return;
  71
  72         if (time > self.pain_finished)
  73         {
  74                 self.pain_finished = time + 10;
  75                 play2all("onslaught/generator_underattack.wav");
  76         }
  77
  78         Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_TD_GENDAMAGED);
  79
  80         self.health -= damage;
  81
  82         WaypointSprite_UpdateHealth(self.sprite, self.health);
  83
  84         if(self.health <= 0)
  85                 td_generator_die();
  86
  87         self.SendFlags |= MSF_STATUS;
  88 }
  89
  90 void td_generator_think()
  91 {
  92         self.think = td_generator_think;
  93         self.nextthink = time + 0.5;
  94 }
  95
  96 void td_generator_setup()
  97 {
  98         self.think = td_generator_think;
  99         self.nextthink = time + 0.1;
 100
 101         self.solid                  = SOLID_BBOX;
 102         self.takedamage     = DAMAGE_AIM;
 103         self.event_damage   = td_generator_damage;
 104         self.enemy                  = world;
 105         self.max_health     = self.health;
 106         self.movetype       = MOVETYPE_NONE;
 107         self.monster_attack = TRUE;
 108         self.netname            = "Generator";
 109
 110         self.SendFlags |= MSF_SETUP;
 111
 112         WaypointSprite_SpawnFixed(self.netname, self.origin + '0 0 60', self, sprite, RADARICON_OBJECTIVE, '1 0.5 0');
 113         WaypointSprite_UpdateMaxHealth(self.sprite, self.max_health);
 114         WaypointSprite_UpdateHealth(self.sprite, self.health);
 115 }
 116
 117 void spawnfunc_td_generator()
 118 {
 119         if not(g_td) { remove(self); return; }
 120
 121         gendestroyed = FALSE;
 122
 123         if not(self.health)
 124                 self.health = autocvar_g_td_generator_health;
 125
 126         self.classname = "td_generator";
 127         td_gencount += 1;
 128
 129         setsize(self, GENERATOR_MIN, GENERATOR_MAX);
 130
 131         droptofloor();
 132
 133         generator_link(td_generator_setup);
 134 }
 135
 136 entity PickGenerator()
 137 {
 138         entity generator, head;
 139         if(td_gencount == 1)
 140                 generator = find(world, classname, "td_generator");
 141         else
 142         {
 143                 RandomSelection_Init();
 144                 for(head = world;(head = find(head, classname, "td_generator")); )
 145                 {
 146                         RandomSelection_Add(head, 0, string_null, 1, 1);
 147                 }
 148                 generator = RandomSelection_chosen_ent;
 149         }
 150         return generator;
 151 }
 152
 153 void spawn_td_fuel(float fuel_size)
 154 {
 155         if not(g_td) {remove(self); return; }
 156
 157         self.ammo_fuel = fuel_size * monster_skill;
 158         StartItem("models/items/g_fuel.md3", "misc/itempickup.wav", g_pickup_respawntime_ammo, g_pickup_respawntimejitter_ammo, "Turret Fuel", IT_FUEL, 0, 0, commodity_pickupevalfunc, BOT_PICKUP_RATING_LOW);
 159
 160         self.velocity = randomvec() * 175 + '0 0 325';
 161 }
 162
 163 void spawnfunc_td_waypoint()
 164 {
 165         if not(g_td) { remove(self); return; }
 166
 167         self.classname = "td_waypoint";
 168 }
 169
 170 void spawnfunc_monster_swarm()
 171 {
 172         if not(g_td) { remove(self); return; }
 173
 174         self.flags = SWARM_NORMAL; // marked as a spawnpoint
 175         self.classname = "monster_swarm";
 176
 177         if(self.spawntype == SWARM_SWIM) waterspawns_count += 1;
 178         if(self.spawntype == SWARM_FLY) flyspawns_count += 1;
 179
 180         WaypointSprite_SpawnFixed("Monsters", self.origin + '0 0 60', self, sprite, RADARICON_HERE, '0 0 1');
 181
 182         if(self.target == "")
 183                 dprint("Warning: monster_swarm entity without a set target\n");
 184 }
 185
 186 void barricade_touch()
 187 {
 188         if not(other.flags & FL_MONSTER)
 189                 return;
 190
 191         if(time < self.dmg_time)
 192                 return;
 193
 194         Damage(other, self, self, autocvar_g_td_barricade_damage, DEATH_HURTTRIGGER, self.origin, '0 0 0');
 195
 196         self.dmg_time = time + 1;
 197 }
 198
 199 void barricade_die()
 200 {
 201         self.takedamage = DAMAGE_NO;
 202         self.event_damage = func_null;
 203
 204         WaypointSprite_Kill(self.sprite);
 205
 206         pointparticles(particleeffectnum("explosion_medium"), self.origin, '0 0 0', 1);
 207         sound(self, CH_SHOTS, "weapons/rocket_impact.wav", VOL_BASE, ATTN_NORM);
 208
 209         if(self.realowner)
 210                 self.realowner.turret_cnt -= 1;
 211
 212         self.think = SUB_Remove;
 213         self.nextthink = time;
 214 }
 215
 216 void barricade_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
 217 {
 218         if not(attacker.flags & FL_MONSTER) return;
 219
 220         self.health -= damage;
 221
 222         WaypointSprite_UpdateHealth(self.sprite, self.health);
 223
 224         if(self.health < 1)
 225                 barricade_die();
 226 }
 227
 228 void spawn_barricade()
 229 {
 230         self.health = 2000;
 231         self.max_health = self.health;
 232         self.dmg_time = time;
 233         self.touch = barricade_touch;
 234         self.think = func_null;
 235         self.nextthink = -1;
 236         self.takedamage = DAMAGE_AIM;
 237         self.turrcaps_flags = TFL_TURRCAPS_ISTURRET; // for turretremove commands etc.
 238         self.solid = SOLID_CORPSE; // hax
 239         self.event_damage = barricade_damage;
 240         self.netname = "Barricade";
 241
 242         WaypointSprite_Spawn(self.netname, 0, 1200, self, '0 0 110', world, 0, self, sprite, FALSE, RADARICON_DOMPOINT, '1 1 0');
 243         WaypointSprite_UpdateMaxHealth(self.sprite, self.max_health);
 244         WaypointSprite_UpdateHealth(self.sprite, self.health);
 245
 246         precache_model("models/td/barricade.md3");
 247         setmodel(self, "models/td/barricade.md3");
 248
 249         droptofloor();
 250
 251         self.movetype = MOVETYPE_NONE;
 252 }
 253
 254 float td_checkfuel(entity ent, string tur)
 255 {
 256         float turcost = cvar(strcat("g_td_turret_", tur, "_cost"));
 257
 258         if(ent.ammo_fuel < turcost)
 259         {
 260                 Send_Notification(NOTIF_ONE, ent, MSG_INFO, INFO_TD_NOFUEL);
 261                 return FALSE;
 262         }
 263
 264         ent.ammo_fuel -= turcost;
 265
 266         return TRUE;
 267 }
 268
 269 void spawnturret(entity spawnedby, entity own, string turet, vector orig)
 270 {
 271         if not(IS_PLAYER(spawnedby)) { dprint("Warning: A non-player entity tried to spawn a turret\n"); return; }
 272         if not(td_checkfuel(spawnedby, turet)) { return; }
 273
 274         entity oldself;
 275
 276         oldself = self;
 277         self = spawn();
 278
 279         setorigin(self, orig);
 280         self.spawnflags = TSL_NO_RESPAWN;
 281         self.monster_attack = TRUE;
 282         self.realowner = own;
 283         self.playerid = own.playerid;
 284         self.angles_y = spawnedby.v_angle_y;
 285         spawnedby.turret_cnt += 1;
 286         self.colormap = spawnedby.colormap;
 287         self.colormod = '1 1 1';
 288
 289         switch(turet)
 290         {
 291                 case "plasma": spawnfunc_turret_plasma(); break;
 292                 case "mlrs": spawnfunc_turret_mlrs(); break;
 293                 case "walker": spawnfunc_turret_walker(); break;
 294                 case "flac": spawnfunc_turret_flac(); break;
 295                 case "towerbuff": spawnfunc_turret_fusionreactor(); break;
 296                 case "barricade": spawn_barricade(); break;
 297                 default: Send_Notification(NOTIF_ONE, spawnedby, MSG_INFO, INFO_TD_INVALID); remove(self); self = oldself; return;
 298         }
 299
 300         Send_Notification(NOTIF_ONE, spawnedby, MSG_INFO, INFO_TD_SPAWN);
 301
 302         self = oldself;
 303 }
 304
 305 void buffturret (entity tur, float buff)
 306 {
 307         tur.turret_buff           += 1;
 308         tur.max_health            *= buff;
 309         tur.tur_health             = tur.max_health;
 310         tur.health                         = tur.max_health;
 311         tur.ammo_max              *= buff;
 312         tur.ammo_recharge     *= buff;
 313     tur.shot_dmg          *= buff;
 314     tur.shot_refire       -= buff * 0.2;
 315     tur.shot_radius       *= buff;
 316     tur.shot_speed        *= buff;
 317     tur.shot_spread       *= buff;
 318     tur.shot_force        *= buff;
 319 }
 320
 321 void AnnounceSpawn(string anounce)
 322 {
 323         Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_TD_ANNOUNCE_SPAWN, anounce);
 324 }
 325
 326 entity PickSpawn (float strngth, float type)
 327 {
 328         entity e;
 329         RandomSelection_Init();
 330         for(e = world;(e = find(e, classname, "monster_swarm")); )
 331         {
 332                 if(flyspawns_count > 0 && type == SWARM_FLY && e.spawntype != SWARM_FLY) continue;
 333                 if(waterspawns_count > 0 && type == SWARM_SWIM && e.spawntype != SWARM_SWIM) continue;
 334
 335                 RandomSelection_Add(e, 0, string_null, 1, 1);
 336         }
 337
 338         return RandomSelection_chosen_ent;
 339 }
 340
 341 void TD_SpawnMonster(string mnster, float strngth, float type)
 342 {
 343         entity e, mon;
 344
 345         e = PickSpawn(strngth, type);
 346
 347         if(e == world) // couldn't find anything for our class, so check for normal spawns
 348                 e = PickSpawn(SWARM_NORMAL, SWARM_NORMAL);
 349
 350         if(e == world)
 351         {
 352                 dprint("Warning: couldn't find any monster_swarm spawnpoints, no monsters will spawn!\n");
 353                 return;
 354         }
 355
 356         mon = spawnmonster(mnster, e, e, e.origin, FALSE, 0);
 357         if(e.target2)
 358         {
 359                 if(random() > 0.5)
 360                         mon.target2 = e.target2;
 361                 else
 362                         mon.target2 = e.target;
 363         }
 364         else
 365                 mon.target2 = e.target;
 366 }
 367
 368 float Monster_GetStrength(string mnster)
 369 {
 370         switch(mnster)
 371         {
 372                 case "knight":
 373                 case "wizard":
 374                 case "soldier":
 375                 case "zombie":
 376                 case "tarbaby":
 377                 case "dog":
 378                 case "spider":
 379                 case "fish":
 380                         return SWARM_WEAK;
 381                 case "ogre":
 382                 case "shambler":
 383                 case "shalrath":
 384                 case "hellknight":
 385                 case "demon":
 386                         return SWARM_STRONG;
 387                 default:
 388                         return SWARM_NORMAL;
 389         }
 390 }
 391
 392 float Monster_GetType(string mnster)
 393 {
 394         switch(mnster)
 395         {
 396                 default:
 397                 case "knight":
 398                 case "soldier":
 399                 case "zombie":
 400                 case "spider":
 401                 case "tarbaby":
 402                 case "dog":
 403                 case "ogre":
 404                 case "shambler":
 405                 case "shalrath":
 406                 case "hellknight":
 407                 case "demon":
 408                         return SWARM_NORMAL;
 409                 case "wizard":
 410                         return SWARM_FLY;
 411                 case "fish":
 412                         return SWARM_SWIM;
 413         }
 414 }
 415
 416 string RandomMonster()
 417 {
 418         RandomSelection_Init();
 419
 420         if(n_demons) RandomSelection_Add(world, 0, "demon", 1, 1);
 421         if(n_shalraths) RandomSelection_Add(world, 0, "vore", 1, 1);
 422         if(n_soldiers) RandomSelection_Add(world, 0, "soldier", 1, 1);
 423         if(n_hknights) RandomSelection_Add(world, 0, "hellknight", 1, 1);
 424         if(n_zombies) RandomSelection_Add(world, 0, "zombie", 1, 1);
 425         if(n_spiders) RandomSelection_Add(world, 0, "spider", 1, 1);
 426         if(n_ogres) RandomSelection_Add(world, 0, "ogre", 1, 1);
 427         if(n_dogs) RandomSelection_Add(world, 0, "dog", 1, 1);
 428         if(n_knights) RandomSelection_Add(world, 0, "knight", 1, 1);
 429         if(n_shamblers) RandomSelection_Add(world, 0, "shambler", 0.2, 0.2);
 430         if(n_tarbabies) RandomSelection_Add(world, 0, "spawn", 0.2, 0.2);
 431         if(n_wizards && flyspawns_count) RandomSelection_Add(world, 0, "scrag", 1, 1);
 432         if(n_fish && waterspawns_count) RandomSelection_Add(world, 0, "fish", 0.2, 0.2);
 433
 434         return RandomSelection_chosen_string;
 435 }
 436
 437 void combat_phase()
 438 {
 439         string whichmon;
 440         float mstrength, montype;
 441
 442         current_phase = PHASE_COMBAT;
 443
 444         if(monster_count <= 0)
 445         {
 446                 wave_end(FALSE);
 447                 return;
 448         }
 449
 450         self.think = combat_phase;
 451
 452         whichmon = RandomMonster();
 453
 454         mstrength = Monster_GetStrength(whichmon);
 455         montype = Monster_GetType(whichmon);
 456
 457         if(current_monsters <= max_current && whichmon != "")
 458         {
 459                 TD_SpawnMonster(whichmon, mstrength, montype);
 460                 self.nextthink = time + spawn_delay;
 461         }
 462         else
 463                 self.nextthink = time + 6;
 464 }
 465
 466 void queue_monsters(float maxmonsters)
 467 {
 468         float mc = 10; // note: shambler + tarbaby = 1
 469
 470         if(waterspawns_count > 0)
 471                 mc += 1;
 472         if(flyspawns_count > 0)
 473                 mc += 1;
 474
 475         DistributeEvenly_Init(maxmonsters, mc);
 476         n_demons        = DistributeEvenly_Get(1);
 477         n_ogres         = DistributeEvenly_Get(1);
 478         n_dogs          = DistributeEvenly_Get(1);
 479         n_knights   = DistributeEvenly_Get(1);
 480         n_shalraths = DistributeEvenly_Get(1);
 481         n_soldiers  = DistributeEvenly_Get(1);
 482         n_hknights  = DistributeEvenly_Get(1);
 483         n_zombies   = DistributeEvenly_Get(1);
 484         n_spiders   = DistributeEvenly_Get(1);
 485         n_tarbabies = DistributeEvenly_Get(0.7);
 486         n_shamblers = DistributeEvenly_Get(0.3);
 487         if(flyspawns_count > 0)
 488                 n_wizards = DistributeEvenly_Get(1);
 489         if(waterspawns_count > 0)
 490                 n_fish = DistributeEvenly_Get(1);
 491 }
 492
 493 void combat_phase_begin()
 494 {
 495         monster_count = totalmonsters;
 496         entity gen;
 497
 498         Send_Notification(NOTIF_ALL, world, MSG_MULTI, MULTI_TD_PHASE_COMBAT);
 499
 500         if(autocvar_sv_eventlog)
 501                 GameLogEcho(":combatphase");
 502
 503         self.think = combat_phase;
 504         self.nextthink = time + 1;
 505
 506         for(gen = world;(gen = find(gen, classname, "td_generator")); )
 507                 gen.takedamage = DAMAGE_AIM;
 508 }
 509
 510 float cphase_updates;
 511 void combat_phase_announce() // TODO: clean up these fail nextthinks...
 512 {
 513         cphase_updates += 1;
 514
 515         if(cphase_updates == 0)
 516                 Announce("prepareforbattle");
 517         else if(cphase_updates == 3)
 518                 Announce("3");
 519         else if(cphase_updates == 4)
 520                 Announce("2");
 521         else if(cphase_updates == 5)
 522                 Announce("1");
 523         else if(cphase_updates == 6)
 524         {
 525                 Announce("begin");
 526                 combat_phase_begin();
 527         }
 528
 529         if(cphase_updates >= 6)
 530                 return;
 531
 532         self.think = combat_phase_announce;
 533         self.nextthink = time + 1;
 534 }
 535
 536 void build_phase()
 537 {
 538         entity head;
 539         float n_players = 0, gen_washealed = FALSE, mcount, mskill;
 540
 541         current_phase = PHASE_BUILD;
 542
 543         for(head = world;(head = find(head, classname, "td_generator")); )
 544         {
 545                 if(head.health <= 15 && head.max_health > 100)
 546                         Announce("lastsecond");
 547
 548                 if(head.health < head.max_health)
 549                 {
 550                         gen_washealed = TRUE;
 551                         head.health = head.max_health;
 552                         WaypointSprite_UpdateHealth(head.sprite, head.health);
 553                 }
 554                 head.takedamage = DAMAGE_NO;
 555         }
 556
 557         FOR_EACH_PLAYER(head)
 558         {
 559                 if(head.health < 100) head.health = 100;
 560                 if(gen_washealed) PlayerScore_Add(head, SP_TD_SCORE, -autocvar_g_td_generator_damaged_points);
 561
 562         n_players += 1;
 563         }
 564
 565         mcount = autocvar_g_td_monster_count_increment * wave_count;
 566         mskill = n_players * 0.02;
 567
 568         totalmonsters += mcount;
 569         monster_skill += autocvar_g_td_monsters_skill_increment;
 570         monster_skill += mskill;
 571
 572         if(monster_skill < 1) monster_skill = 1;
 573         if(totalmonsters < 1) totalmonsters = ((autocvar_g_td_monster_count > 0) ? autocvar_g_td_monster_count : 10);
 574         if(wave_count < 1) wave_count = 1;
 575
 576         Send_Notification(NOTIF_ALL, world, MSG_MULTI, MULTI_TD_PHASE_BUILD, wave_count, totalmonsters, build_time);
 577
 578     FOR_EACH_MONSTER(head)
 579     {
 580                 if(head.health <= 0)
 581                         continue;
 582
 583         dprint(strcat("Warning: Monster still alive during build phase! Monster name: ", head.netname, "\n"));
 584
 585                 WaypointSprite_Kill(head.sprite);
 586         remove(head);
 587     }
 588
 589         monsters_total = totalmonsters;
 590         monsters_killed = 0;
 591
 592         queue_monsters(totalmonsters);
 593
 594         cphase_updates = -1;
 595
 596         if(autocvar_sv_eventlog)
 597         GameLogEcho(strcat(":buildphase:", ftos(wave_count), ":", ftos(totalmonsters)));
 598
 599         self.think = combat_phase_announce;
 600         self.nextthink = time + build_time - 6;
 601 }
 602
 603 void wave_end(float starting)
 604 {
 605         if not(starting)
 606         {
 607                 Send_Notification(NOTIF_ALL, world, MSG_MULTI, MULTI_TD_VICTORY, ((wave_count >= max_waves) ? "Level" : "Wave"));
 608
 609                 if(autocvar_sv_eventlog)
 610             GameLogEcho(strcat(":wave:", ftos(wave_count), ":victory"));
 611         }
 612
 613         if(wave_count >= max_waves)
 614         {
 615                 gensurvived = TRUE;
 616                 return;
 617         }
 618
 619         if not(starting)
 620                 wave_count += 1;
 621
 622         self.think = build_phase;
 623         self.nextthink = time + 3;
 624 }
 625
 626 void td_ScoreRules()
 627 {
 628         ScoreInfo_SetLabel_PlayerScore(SP_TD_SCORE,             "score",         SFL_SORT_PRIO_PRIMARY);
 629         ScoreInfo_SetLabel_PlayerScore(SP_TD_KILLS,             "kills",         SFL_LOWER_IS_BETTER);
 630         ScoreInfo_SetLabel_PlayerScore(SP_TD_TURKILLS,  "frags",         SFL_LOWER_IS_BETTER);
 631         ScoreInfo_SetLabel_PlayerScore(SP_TD_DEATHS,    "deaths",    SFL_LOWER_IS_BETTER);
 632         ScoreInfo_SetLabel_PlayerScore(SP_TD_SUICIDES,  "suicides",  SFL_LOWER_IS_BETTER | SFL_ALLOW_HIDE);
 633         ScoreRules_basics_end();
 634 }
 635
 636 void td_SpawnController()
 637 {
 638         entity oldself = self;
 639         self = spawn();
 640         self.classname = "td_controller";
 641         spawnfunc_td_controller();
 642         self = oldself;
 643 }
 644
 645 void td_DelayedInit()
 646 {
 647         if(find(world, classname, "td_controller") == world)
 648         {
 649                 print("No ""td_controller"" entity found on this map, creating it anyway.\n");
 650                 td_SpawnController();
 651         }
 652
 653         td_ScoreRules();
 654 }
 655
 656 void td_Initialize()
 657 {
 658         InitializeEntity(world, td_DelayedInit, INITPRIO_GAMETYPE);
 659 }
 660
 661 MUTATOR_HOOKFUNCTION(td_TurretValidateTarget)
 662 {
 663         if(turret_flags & TFL_TARGETSELECT_MISSILESONLY)
 664     if(turret_target.flags & FL_PROJECTILE)
 665         if(turret_target.owner.flags & FL_MONSTER)
 666         return TRUE; // flac support
 667
 668         if(turret.turrcaps_flags & TFL_TURRCAPS_SUPPORT && turret_target.turrcaps_flags & TFL_TURRCAPS_ISTURRET)
 669                 return TRUE;
 670         if not(turret_target.flags & FL_MONSTER)
 671                 turret_target = world;
 672
 673         return FALSE;
 674 }
 675
 676 MUTATOR_HOOKFUNCTION(td_PlayerThink)
 677 {
 678         self.stat_current_wave = wave_count;
 679         self.stat_totalwaves = max_waves;
 680
 681         return FALSE;
 682 }
 683
 684 MUTATOR_HOOKFUNCTION(td_PlayerSpawn)
 685 {
 686         self.bot_attack = FALSE;
 687
 688         return FALSE;
 689 }
 690
 691 MUTATOR_HOOKFUNCTION(td_PlayerDies)
 692 {
 693         if(frag_attacker.flags & FL_MONSTER)
 694                 PlayerScore_Add(frag_target, SP_TD_DEATHS, 1);
 695
 696         if(frag_target == frag_attacker)
 697                 PlayerScore_Add(frag_attacker, SP_TD_SUICIDES, 1);
 698
 699         return FALSE;
 700 }
 701
 702 MUTATOR_HOOKFUNCTION(td_GiveFragsForKill)
 703 {
 704         frag_score = 0;
 705
 706         return TRUE; // no frags counted in td
 707 }
 708
 709 MUTATOR_HOOKFUNCTION(td_PlayerDamage)
 710 {
 711         if(frag_attacker.realowner == frag_target)
 712                 frag_damage = 0;
 713
 714         if(frag_target.flags & FL_MONSTER && time < frag_target.spawnshieldtime)
 715                 frag_damage = 0;
 716
 717         if(frag_target.vehicle_flags & VHF_ISVEHICLE && !(frag_attacker.flags & FL_MONSTER))
 718                 frag_damage = 0;
 719
 720         if(frag_attacker.vehicle_flags & VHF_ISVEHICLE && !(frag_target.flags & FL_MONSTER))
 721                 frag_damage = 0;
 722
 723         if(!autocvar_g_td_pvp && frag_attacker != frag_target && IS_PLAYER(frag_target) && IS_PLAYER(frag_attacker))
 724                 frag_damage = 0;
 725
 726         if(frag_attacker.turrcaps_flags & TFL_TURRCAPS_ISTURRET && IS_PLAYER(frag_target))
 727                 frag_damage = 0;
 728
 729         if((frag_target.turrcaps_flags & TFL_TURRCAPS_ISTURRET) && !(frag_attacker.flags & FL_MONSTER || frag_attacker.turrcaps_flags & TFL_TURRCAPS_SUPPORT))
 730                 frag_damage = 0;
 731
 732         return TRUE;
 733 }
 734
 735 MUTATOR_HOOKFUNCTION(td_TurretDies)
 736 {
 737         if(self.realowner)
 738                 self.realowner.turret_cnt -= 1;
 739
 740         return FALSE;
 741 }
 742
 743 MUTATOR_HOOKFUNCTION(td_MonsterCheckBossFlag)
 744 {
 745         // No minibosses in tower defense
 746         return TRUE;
 747 }
 748
 749 MUTATOR_HOOKFUNCTION(td_MonsterMove)
 750 {
 751         entity player;
 752         float n_players = 0;
 753         FOR_EACH_PLAYER(player) { ++n_players; }
 754
 755         if(n_players < 1) // no players online, so do nothing
 756         {
 757                 monster_target = world;
 758                 monster_speed_run = monster_speed_walk = 0;
 759                 return FALSE;
 760         }
 761
 762         if not(self.enemy) // don't change targets while attacking
 763         if((vlen(self.goalentity.origin - self.origin) <= 100 && self.goalentity.classname == "td_waypoint") || (vlen(self.goalentity.origin - self.origin) <= 200 && (self.flags & FL_FLY) && self.goalentity.classname == "td_waypoint"))
 764         {
 765                 if(self.goalentity.target2)
 766                 {
 767                         if(random() > 0.5)
 768                                 self.target2 = self.goalentity.target2;
 769                         else
 770                                 self.target2 = self.goalentity.target;
 771                 }
 772                 else
 773                         self.target2 = self.goalentity.target;
 774
 775                 self.goalentity = find(world, targetname, self.target2);
 776
 777                 if(self.goalentity == world)
 778                         self.goalentity = PickGenerator();
 779         }
 780
 781         monster_speed_run = m_speed_run * monster_skill;
 782         monster_speed_walk = m_speed_walk * monster_skill;
 783
 784         return FALSE;
 785 }
 786
 787 MUTATOR_HOOKFUNCTION(td_MonsterSpawn)
 788 {
 789         if(self.realowner == world) // nothing spawned it, so kill it
 790         {
 791                 WaypointSprite_Kill(self.sprite);
 792                 remove(self);
 793                 return TRUE;
 794         }
 795
 796         current_monsters += 1;
 797
 798         self.spawnshieldtime = time + autocvar_g_td_monsters_spawnshield_time;
 799
 800         self.drop_size = self.health * 0.05;
 801
 802         self.target_range = 600;
 803
 804         if(self.drop_size < 1) self.drop_size = 1;
 805
 806         self.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_CORPSE | DPCONTENTS_BODY;
 807
 808         self.origin += '0 0 25'; // hopefully this fixes monsters falling through the floor
 809
 810         switch(self.monsterid)
 811         {
 812                 case MONSTER_ZOMBIE: n_zombies -= 1; break;
 813                 case MONSTER_OGRE: n_ogres -= 1; break;
 814                 case MONSTER_DEMON: n_demons -= 1; break;
 815                 case MONSTER_SHAMBLER: n_shamblers -= 1; break;
 816                 case MONSTER_KNIGHT: n_knights -= 1; break;
 817                 case MONSTER_MARINE: n_soldiers -= 1; break;
 818                 case MONSTER_SCRAG: n_wizards -= 1; break;
 819                 case MONSTER_DOG: n_dogs -= 1; break;
 820                 case MONSTER_TARBABY: n_tarbabies -= 1; break;
 821                 case MONSTER_HELLKNIGHT: n_hknights -= 1; break;
 822                 case MONSTER_FISH: n_fish -= 1; break;
 823                 case MONSTER_MAGE: n_shalraths -= 1; break;
 824                 case MONSTER_SPIDER: n_spiders -= 1; break;
 825         }
 826
 827         return TRUE;
 828 }
 829
 830 MUTATOR_HOOKFUNCTION(td_MonsterDies)
 831 {
 832         entity oldself;
 833         vector backuporigin;
 834
 835         monster_count -= 1;
 836         current_monsters -= 1;
 837         monsters_killed += 1;
 838
 839         if(IS_PLAYER(frag_attacker))
 840         {
 841                 PlayerScore_Add(frag_attacker, SP_TD_SCORE, autocvar_g_td_kill_points);
 842                 PlayerScore_Add(frag_attacker, SP_TD_KILLS, 1);
 843         }
 844         else if(IS_PLAYER(frag_attacker.realowner) && frag_attacker.turrcaps_flags & TFL_TURRCAPS_ISTURRET)
 845         {
 846                 PlayerScore_Add(frag_attacker.realowner, SP_TD_SCORE, autocvar_g_td_turretkill_points);
 847                 PlayerScore_Add(frag_attacker.realowner, SP_TD_TURKILLS, 1);
 848         }
 849
 850         backuporigin = self.origin;
 851         oldself = self;
 852         self = spawn();
 853
 854         self.gravity = 1;
 855         setorigin(self, backuporigin + '0 0 5');
 856         spawn_td_fuel(oldself.drop_size);
 857         self.touch = M_Item_Touch;
 858         if(self == world)
 859         {
 860                 self = oldself;
 861                 return FALSE;
 862         }
 863         SUB_SetFade(self, time + 5, 1);
 864
 865         self = oldself;
 866
 867         return FALSE;
 868 }
 869
 870 MUTATOR_HOOKFUNCTION(td_MonsterFindTarget)
 871 {
 872         float n_players = 0;
 873         entity player;
 874         local entity e;
 875
 876         FOR_EACH_PLAYER(player) { ++n_players; }
 877
 878         if(n_players < 1) // no players online, so do nothing
 879         {
 880                 self.enemy = world;
 881                 return TRUE;
 882         }
 883
 884         for(e = world;(e = findflags(e, monster_attack, TRUE)); )
 885         {
 886                 if(ignore_turrets)
 887                 if(e.turrcaps_flags & TFL_TURRCAPS_ISTURRET)
 888                         continue;
 889
 890                 if(monster_isvalidtarget(e, self))
 891                 if((vlen(trace_endpos - self.origin) < 200 && e.turrcaps_flags & TFL_TURRCAPS_ISTURRET) || (vlen(trace_endpos - self.origin) < 200 && e.classname != "td_generator") || (vlen(trace_endpos - self.origin) < 500 && e.classname == "td_generator"))
 892                 {
 893                         self.enemy = e;
 894                 }
 895         }
 896
 897         return TRUE;
 898 }
 899
 900 MUTATOR_HOOKFUNCTION(td_SetStartItems)
 901 {
 902         start_ammo_fuel = 150; // to be nice...
 903
 904         return FALSE;
 905 }
 906
 907 MUTATOR_HOOKFUNCTION(td_TurretSpawn)
 908 {
 909         if(self.realowner == world)
 910                 return TRUE; // wasn't spawned by a player
 911
 912         self.bot_attack = FALSE;
 913         self.turret_buff = 1;
 914
 915         return FALSE;
 916 }
 917
 918 MUTATOR_HOOKFUNCTION(td_DisableVehicles)
 919 {
 920         // you shall not spawn!
 921         return TRUE;
 922 }
 923
 924 MUTATOR_HOOKFUNCTION(td_PlayerCommand)
 925 {
 926         if(MUTATOR_RETURNVALUE) { return FALSE; } // command was already handled?
 927
 928         makevectors(self.v_angle);
 929         WarpZone_TraceLine(self.origin + self.view_ofs, self.origin + self.view_ofs + v_forward * 100, MOVE_HITMODEL, self);
 930
 931         if(cmd_name == "turretspawn")
 932         {
 933                 if(argv(1) == "list")
 934                 {
 935                         Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_TD_LIST, "mlrs walker plasma towerbuff flac barricade");
 936                         return TRUE;
 937                 }
 938                 if(!IS_PLAYER(self) || self.health <= 0)
 939                 {
 940                         Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_TD_CANTSPAWN);
 941                         return TRUE;
 942                 }
 943                 if(max_turrets <= 0)
 944                 {
 945                         Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_TD_TURRETS_DISABLED);
 946                         return TRUE;
 947                 }
 948                 if(self.turret_cnt >= max_turrets)
 949                 {
 950                         Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_TD_MAXTURRETS, max_turrets);
 951                         return TRUE;
 952                 }
 953
 954                 spawnturret(self, self, argv(1), trace_endpos);
 955
 956                 return TRUE;
 957         }
 958         if(cmd_name == "repairturret")
 959         {
 960                 if((trace_ent.playerid != self.playerid || trace_ent.realowner != self) || !(trace_ent.turrcaps_flags & TFL_TURRCAPS_ISTURRET))
 961                 {
 962                         Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_TD_AIM_REPAIR);
 963                         return TRUE;
 964                 }
 965                 if(self.ammo_fuel < autocvar_g_td_turret_repair_cost)
 966                 {
 967                         Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_TD_NOFUEL_REPAIR, autocvar_g_td_turret_repair_cost);
 968                         return TRUE;
 969                 }
 970                 if(trace_ent.health >= trace_ent.max_health)
 971                 {
 972                         Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_TD_MAXHEALTH);
 973                         return TRUE;
 974                 }
 975
 976                 self.ammo_fuel -= autocvar_g_td_turret_repair_cost;
 977                 trace_ent.SendFlags |= TNSF_STATUS;
 978                 trace_ent.health = bound(1, trace_ent.health + 100, trace_ent.max_health);
 979                 WaypointSprite_UpdateHealth(trace_ent.sprite, trace_ent.health);
 980                 Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_TD_REPAIR);
 981
 982                 return TRUE;
 983         }
 984         if(cmd_name == "buffturret")
 985         {
 986                 if((trace_ent.playerid != self.playerid || trace_ent.realowner != self) || !(trace_ent.turrcaps_flags & TFL_TURRCAPS_ISTURRET))
 987                 {
 988                         Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_TD_AIM_UPGRADE);
 989                         return TRUE;
 990                 }
 991                 if(self.ammo_fuel < autocvar_g_td_turret_upgrade_cost)
 992                 {
 993                         Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_TD_NOFUEL_UPGRADE, autocvar_g_td_turret_upgrade_cost);
 994                         return TRUE;
 995                 }
 996                 if(trace_ent.turret_buff >= 3)
 997                 {
 998                         Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_TD_MAXPOWER);
 999                         return TRUE;
1000                 }
1001
1002                 self.ammo_fuel -= autocvar_g_td_turret_upgrade_cost;
1003                 trace_ent.SendFlags |= TNSF_STATUS;
1004                 buffturret(trace_ent, 1.2);
1005                 WaypointSprite_UpdateHealth(trace_ent.sprite, trace_ent.health);
1006                 Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_TD_UPGRADE);
1007
1008                 return TRUE;
1009         }
1010         if(cmd_name == "turretremove")
1011         {
1012                 if((trace_ent.turrcaps_flags & TFL_TURRCAPS_ISTURRET) && (trace_ent.playerid == self.playerid || trace_ent.realowner == self))
1013                 {
1014                         self.turret_cnt -= 1;
1015                         Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_TD_REMOVE);
1016                         WaypointSprite_Kill(trace_ent.sprite);
1017                         remove(trace_ent.tur_head);
1018                         remove(trace_ent);
1019                         return TRUE;
1020                 }
1021                 Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_TD_AIM_REMOVE);
1022                 return TRUE;
1023         }
1024
1025         return FALSE;
1026 }
1027
1028 MUTATOR_HOOKFUNCTION(td_ClientConnect)
1029 {
1030         entity t;
1031
1032         self.turret_cnt = 0;
1033
1034         for(t = world; (t = findflags(t, turrcaps_flags, TFL_TURRCAPS_ISTURRET)); )
1035         if(t.playerid == self.playerid)
1036         {
1037                 t.realowner = self;
1038                 self.turret_cnt += 1;
1039         }
1040
1041         return FALSE;
1042 }
1043
1044 MUTATOR_DEFINITION(gamemode_td)
1045 {
1046         MUTATOR_HOOK(MonsterSpawn, td_MonsterSpawn, CBC_ORDER_ANY);
1047         MUTATOR_HOOK(MonsterDies, td_MonsterDies, CBC_ORDER_ANY);
1048         MUTATOR_HOOK(MonsterMove, td_MonsterMove, CBC_ORDER_ANY);
1049         MUTATOR_HOOK(MonsterFindTarget, td_MonsterFindTarget, CBC_ORDER_ANY);
1050         MUTATOR_HOOK(MonsterCheckBossFlag, td_MonsterCheckBossFlag, CBC_ORDER_ANY);
1051         MUTATOR_HOOK(SetStartItems, td_SetStartItems, CBC_ORDER_ANY);
1052         MUTATOR_HOOK(TurretValidateTarget, td_TurretValidateTarget, CBC_ORDER_ANY);
1053         MUTATOR_HOOK(TurretSpawn, td_TurretSpawn, CBC_ORDER_ANY);
1054         MUTATOR_HOOK(TurretDies, td_TurretDies, CBC_ORDER_ANY);
1055         MUTATOR_HOOK(GiveFragsForKill, td_GiveFragsForKill, CBC_ORDER_ANY);
1056         MUTATOR_HOOK(PlayerPreThink, td_PlayerThink, CBC_ORDER_ANY);
1057         MUTATOR_HOOK(PlayerDies, td_PlayerDies, CBC_ORDER_ANY);
1058         MUTATOR_HOOK(PlayerDamage_Calculate, td_PlayerDamage, CBC_ORDER_ANY);
1059         MUTATOR_HOOK(PlayerSpawn, td_PlayerSpawn, CBC_ORDER_ANY);
1060         MUTATOR_HOOK(VehicleSpawn, td_DisableVehicles, CBC_ORDER_ANY);
1061         MUTATOR_HOOK(SV_ParseClientCommand, td_PlayerCommand, CBC_ORDER_ANY);
1062         MUTATOR_HOOK(ClientConnect, td_ClientConnect, CBC_ORDER_ANY);
1063
1064         MUTATOR_ONADD
1065         {
1066                 if(time > 1) // game loads at time 1
1067                         error("This is a game type and it cannot be added at runtime.");
1068                 cvar_settemp("g_monsters", "1");
1069                 cvar_settemp("g_turrets", "1");
1070                 td_Initialize();
1071         }
1072
1073         MUTATOR_ONROLLBACK_OR_REMOVE
1074         {
1075                 // we actually cannot roll back td_Initialize here
1076                 // BUT: we don't need to! If this gets called, adding always
1077                 // succeeds.
1078         }
1079
1080         MUTATOR_ONREMOVE
1081         {
1082                 error("This is a game type and it cannot be removed at runtime.");
1083                 return -1;
1084         }
1085
1086         return FALSE;
1087 }