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