qcsrc/server/mutators/gamemode_freezetag.qc

   1 .float freezetag_frozen_time;
   2 .float freezetag_frozen_timeout;
   3 .float freezetag_revive_progress;
   4 .entity freezetag_ice;
   5 #define ICE_MAX_ALPHA 1
   6 #define ICE_MIN_ALPHA 0.1
   7 float freezetag_teams;
   8
   9 void freezetag_count_alive_players()
  10 {
  11         entity e;
  12         total_players = redalive = bluealive = yellowalive = pinkalive = 0;
  13         FOR_EACH_PLAYER(e) {
  14                 if(e.team == COLOR_TEAM1 && e.health >= 1)
  15                 {
  16                         ++total_players;
  17                         if (!e.freezetag_frozen) ++redalive;
  18                 }
  19                 else if(e.team == COLOR_TEAM2 && e.health >= 1)
  20                 {
  21                         ++total_players;
  22                         if (!e.freezetag_frozen) ++bluealive;
  23                 }
  24                 else if(e.team == COLOR_TEAM3 && e.health >= 1)
  25                 {
  26                         ++total_players;
  27                         if (!e.freezetag_frozen) ++yellowalive;
  28                 }
  29                 else if(e.team == COLOR_TEAM4 && e.health >= 1)
  30                 {
  31                         ++total_players;
  32                         if (!e.freezetag_frozen) ++pinkalive;
  33                 }
  34         }
  35         FOR_EACH_REALCLIENT(e) {
  36                 e.redalive_stat = redalive;
  37                 e.bluealive_stat = bluealive;
  38                 e.yellowalive_stat = yellowalive;
  39                 e.pinkalive_stat = pinkalive;
  40         }
  41 }
  42 #define FREEZETAG_ALIVE_TEAMS() ((redalive > 0) + (bluealive > 0) + (yellowalive > 0) + (pinkalive > 0))
  43 #define FREEZETAG_ALIVE_TEAMS_OK() (FREEZETAG_ALIVE_TEAMS() == freezetag_teams)
  44
  45 float prev_total_players;
  46 float freezetag_CheckTeams()
  47 {
  48         entity e;
  49         if(FREEZETAG_ALIVE_TEAMS_OK())
  50         {
  51                 if(prev_total_players != -1)
  52                 {
  53                         FOR_EACH_REALCLIENT(e)
  54                                 Send_CSQC_Centerprint_Generic_Expire(e, CPID_WAITING_PLAYERS);
  55                 }
  56                 prev_total_players = -1;
  57                 return 1;
  58         }
  59         if(prev_total_players != total_players)
  60         {
  61                 string teams_missing = "";
  62                 if(!redalive)   teams_missing = strcat(teams_missing, ColoredTeamName(COLOR_TEAM1), ", ");
  63                 if(!bluealive)  teams_missing = strcat(teams_missing, ColoredTeamName(COLOR_TEAM2), ", ");
  64                 if(freezetag_teams >= 3)
  65                 if(!yellowalive)        teams_missing = strcat(teams_missing, ColoredTeamName(COLOR_TEAM3), ", ");
  66                 if(freezetag_teams == 4)
  67                 if(!pinkalive)  teams_missing = strcat(teams_missing, ColoredTeamName(COLOR_TEAM4), ", ");
  68                 teams_missing = substring(teams_missing, 0, strlen(teams_missing)-2);
  69
  70                 FOR_EACH_REALCLIENT(e)
  71                         Send_CSQC_Centerprint_Generic(e, CPID_WAITING_PLAYERS, strcat("Waiting for players to join...\n\nNeed active players for: ", teams_missing), -1, 0);
  72                 prev_total_players = total_players;
  73         }
  74         return 0;
  75 }
  76
  77 float freezetag_getWinnerTeam()
  78 {
  79         float winner_team = 0;
  80         if(redalive >= 1)
  81                 winner_team = COLOR_TEAM1;
  82         if(bluealive >= 1)
  83         {
  84                 if(winner_team) return 0;
  85                 winner_team = COLOR_TEAM2;
  86         }
  87         if(yellowalive >= 1)
  88         {
  89                 if(winner_team) return 0;
  90                 winner_team = COLOR_TEAM3;
  91         }
  92         if(pinkalive >= 1)
  93         {
  94                 if(winner_team) return 0;
  95                 winner_team = COLOR_TEAM4;
  96         }
  97         if(winner_team)
  98                 return winner_team;
  99         return -1; // no player left
 100 }
 101
 102 float freezetag_CheckWinner()
 103 {
 104         entity e;
 105         if(round_handler_GetTimeLeft() <= 0)
 106         {
 107                 FOR_EACH_REALCLIENT(e)
 108                         centerprint(e, "Round over, there's no winner");
 109                 bprint("Round over, there's no winner.\n");
 110                 FOR_EACH_PLAYER(e)
 111                         e.freezetag_frozen_timeout = 0;
 112                 round_handler_Init(5, autocvar_g_freezetag_warmup, autocvar_g_freezetag_round_timelimit);
 113                 return 1;
 114         }
 115
 116         if(FREEZETAG_ALIVE_TEAMS() > 1)
 117                 return 0;
 118
 119         float winner_team;
 120         string teamname;
 121         winner_team = freezetag_getWinnerTeam();
 122         if(winner_team > 0)
 123         {
 124                 teamname = ColoredTeamName(winner_team);
 125                 FOR_EACH_REALCLIENT(e)
 126                         centerprint(e, strcat(teamname, "^5 wins the round, all other teams were frozen."));
 127                 bprint(teamname, "^5 wins the round since all the other teams were frozen.\n");
 128                 TeamScore_AddToTeam(winner_team, ST_SCORE, +1);
 129         }
 130         else if(winner_team == -1)
 131         {
 132                 FOR_EACH_REALCLIENT(e)
 133                         centerprint(e, "^5Round tied! All teams were frozen.");
 134                 bprint("^5Round tied! All teams were frozen.\n");
 135         }
 136
 137         FOR_EACH_PLAYER(e)
 138                 e.freezetag_frozen_timeout = 0;
 139         round_handler_Init(5, autocvar_g_freezetag_warmup, autocvar_g_freezetag_round_timelimit);
 140         return 1;
 141 }
 142
 143 // this is needed to allow the player to turn his view around (fixangle can't
 144 // be used to freeze his view, as that also changes the angles), while not
 145 // turning that ice object with the player
 146 void freezetag_Ice_Think()
 147 {
 148         setorigin(self, self.owner.origin - '0 0 16');
 149         self.nextthink = time;
 150 }
 151
 152 void freezetag_Add_Score(entity attacker)
 153 {
 154         if(attacker == self)
 155         {
 156                 // you froze your own dumb self
 157                 // counted as "suicide" already
 158                 PlayerScore_Add(self, SP_SCORE, -1);
 159         }
 160         else if(attacker.classname == "player")
 161         {
 162                 // got frozen by an enemy
 163                 // counted as "kill" and "death" already
 164                 PlayerScore_Add(self, SP_SCORE, -1);
 165                 PlayerScore_Add(attacker, SP_SCORE, +1);
 166         }
 167         // else nothing - got frozen by the game type rules themselves
 168 }
 169
 170 void freezetag_Freeze(entity attacker)
 171 {
 172         if(self.freezetag_frozen)
 173                 return;
 174         self.freezetag_frozen = 1;
 175         self.freezetag_frozen_time = time;
 176         self.freezetag_revive_progress = 0;
 177         self.health = 1;
 178         if(autocvar_g_freezetag_frozen_maxtime > 0)
 179                 self.freezetag_frozen_timeout = time + autocvar_g_freezetag_frozen_maxtime;
 180
 181         freezetag_count_alive_players();
 182
 183         entity ice;
 184         ice = spawn();
 185         ice.owner = self;
 186         ice.classname = "freezetag_ice";
 187         ice.think = freezetag_Ice_Think;
 188         ice.nextthink = time;
 189         ice.frame = floor(random() * 21); // ice model has 20 different looking frames
 190         ice.alpha = ICE_MAX_ALPHA;
 191         ice.colormod = TeamColor(self.team);
 192         ice.glowmod = ice.colormod;
 193         setmodel(ice, "models/ice/ice.md3");
 194
 195         self.freezetag_ice = ice;
 196
 197         RemoveGrapplingHook(self);
 198
 199         // add waypoint
 200         WaypointSprite_Spawn("freezetag_frozen", 0, 0, self, '0 0 64', world, self.team, self, waypointsprite_attached, TRUE, RADARICON_WAYPOINT, '0.25 0.90 1');
 201
 202         freezetag_Add_Score(attacker);
 203 }
 204
 205 void freezetag_Unfreeze(entity attacker)
 206 {
 207         self.freezetag_frozen = 0;
 208         self.freezetag_frozen_time = 0;
 209         self.freezetag_frozen_timeout = 0;
 210         self.freezetag_revive_progress = 0;
 211
 212         remove(self.freezetag_ice);
 213         self.freezetag_ice = world;
 214
 215         if(self.waypointsprite_attached)
 216                 WaypointSprite_Kill(self.waypointsprite_attached);
 217 }
 218
 219
 220 // ================
 221 // Bot player logic
 222 // ================
 223
 224 void() havocbot_role_ft_freeing;
 225 void() havocbot_role_ft_offense;
 226
 227 void havocbot_goalrating_freeplayers(float ratingscale, vector org, float sradius)
 228 {
 229         entity head;
 230         float distance;
 231
 232         FOR_EACH_PLAYER(head)
 233         {
 234                 if ((head != self) && (head.team == self.team))
 235                 {
 236                         if (head.freezetag_frozen)
 237                         {
 238                                 distance = vlen(head.origin - org);
 239                                 if (distance > sradius)
 240                                         continue;
 241                                 navigation_routerating(head, ratingscale, 2000);
 242                         }
 243                         else
 244                         {
 245                                 // If teamate is not frozen still seek them out as fight better
 246                                 // in a group.
 247                                 navigation_routerating(head, ratingscale/3, 2000);
 248                         }
 249                 }
 250         }
 251 }
 252
 253 void havocbot_role_ft_offense()
 254 {
 255         entity head;
 256         float unfrozen;
 257
 258         if(self.deadflag != DEAD_NO)
 259                 return;
 260
 261         if (!self.havocbot_role_timeout)
 262                 self.havocbot_role_timeout = time + random() * 10 + 20;
 263
 264         // Count how many players on team are unfrozen.
 265         unfrozen = 0;
 266         FOR_EACH_PLAYER(head)
 267         {
 268                 if ((head.team == self.team) && (!head.freezetag_frozen))
 269                         unfrozen++;
 270         }
 271
 272         // If only one left on team or if role has timed out then start trying to free players.
 273         if (((unfrozen == 0) && (!self.freezetag_frozen)) || (time > self.havocbot_role_timeout))
 274         {
 275                 dprint("changing role to freeing\n");
 276                 self.havocbot_role = havocbot_role_ft_freeing;
 277                 self.havocbot_role_timeout = 0;
 278                 return;
 279         }
 280
 281         if (time > self.bot_strategytime)
 282         {
 283                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
 284
 285                 navigation_goalrating_start();
 286                 havocbot_goalrating_items(10000, self.origin, 10000);
 287                 havocbot_goalrating_enemyplayers(20000, self.origin, 10000);
 288                 havocbot_goalrating_freeplayers(9000, self.origin, 10000);
 289                 //havocbot_goalrating_waypoints(1, self.origin, 1000);
 290                 navigation_goalrating_end();
 291         }
 292 }
 293
 294 void havocbot_role_ft_freeing()
 295 {
 296         if(self.deadflag != DEAD_NO)
 297                 return;
 298
 299         if (!self.havocbot_role_timeout)
 300                 self.havocbot_role_timeout = time + random() * 10 + 20;
 301
 302         if (time > self.havocbot_role_timeout)
 303         {
 304                 dprint("changing role to offense\n");
 305                 self.havocbot_role = havocbot_role_ft_offense;
 306                 self.havocbot_role_timeout = 0;
 307                 return;
 308         }
 309
 310         if (time > self.bot_strategytime)
 311         {
 312                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
 313
 314                 navigation_goalrating_start();
 315                 havocbot_goalrating_items(8000, self.origin, 10000);
 316                 havocbot_goalrating_enemyplayers(10000, self.origin, 10000);
 317                 havocbot_goalrating_freeplayers(20000, self.origin, 10000);
 318                 //havocbot_goalrating_waypoints(1, self.origin, 1000);
 319                 navigation_goalrating_end();
 320         }
 321 }
 322
 323
 324 // ==============
 325 // Hook Functions
 326 // ==============
 327
 328 MUTATOR_HOOKFUNCTION(freezetag_RemovePlayer)
 329 {
 330         self.health = 0; // neccessary to update correctly alive stats
 331         freezetag_Unfreeze(world);
 332         freezetag_count_alive_players();
 333         return 1;
 334 }
 335
 336 MUTATOR_HOOKFUNCTION(freezetag_PlayerDies)
 337 {
 338         if(round_handler_IsActive())
 339         if(round_handler_CountdownRunning())
 340         {
 341                 if(self.freezetag_frozen)
 342                         freezetag_Unfreeze(world);
 343                 freezetag_count_alive_players();
 344                 return 1; // let the player die so that he can respawn whenever he wants
 345         }
 346
 347         // Cases DEATH_TEAMCHANGE and DEATH_AUTOTEAMCHANGE are needed to fix a bug whe
 348         // you succeed changing team through the menu: you both really die (gibbing) and get frozen
 349         if(ITEM_DAMAGE_NEEDKILL(frag_deathtype)
 350                 || frag_deathtype == DEATH_TEAMCHANGE || frag_deathtype == DEATH_AUTOTEAMCHANGE)
 351         {
 352                 // let the player die, he will be automatically frozen when he respawns
 353                 if(!self.freezetag_frozen)
 354                 {
 355                         freezetag_Add_Score(frag_attacker);
 356                         freezetag_count_alive_players();
 357                 }
 358                 else
 359                         freezetag_Unfreeze(world); // remove ice
 360                 self.freezetag_frozen_timeout = -2; // freeze on respawn
 361                 return 1;
 362         }
 363
 364         if(self.freezetag_frozen)
 365                 return 1;
 366
 367         freezetag_Freeze(frag_attacker);
 368
 369         if(frag_attacker == frag_target || frag_attacker == world)
 370         {
 371                 if(frag_target.classname == STR_PLAYER)
 372                         centerprint(frag_target, "^1You froze yourself.\n");
 373                 bprint("^7", frag_target.netname, "^1 froze himself.\n");
 374         }
 375         else
 376         {
 377                 if(frag_target.classname == STR_PLAYER)
 378                         centerprint(frag_target, strcat("^1You were frozen by ^7", frag_attacker.netname, ".\n"));
 379                 if(frag_attacker.classname == STR_PLAYER)
 380                         centerprint(frag_attacker, strcat("^2You froze ^7", frag_target.netname, ".\n"));
 381                 bprint("^7", frag_target.netname, "^1 was frozen by ^7", frag_attacker.netname, ".\n");
 382         }
 383
 384         frag_target.health = 1; // "respawn" the player :P
 385
 386         return 1;
 387 }
 388
 389 MUTATOR_HOOKFUNCTION(freezetag_PlayerSpawn)
 390 {
 391         if(self.freezetag_frozen_timeout == -1) // if PlayerSpawn is called by reset_map_players
 392                 return 1; // do nothing, round is starting right now
 393
 394         if(self.freezetag_frozen_timeout == -2) // player was dead
 395         {
 396                 freezetag_Freeze(world);
 397                 return 1;
 398         }
 399
 400         freezetag_count_alive_players();
 401
 402         if(round_handler_IsActive())
 403         if(round_handler_IsRoundStarted())
 404         {
 405                 centerprint(self, "^1Round already started, you spawn as frozen.");
 406                 freezetag_Freeze(world);
 407         }
 408
 409         return 1;
 410 }
 411
 412 MUTATOR_HOOKFUNCTION(freezetag_reset_map_players)
 413 {
 414         FOR_EACH_PLAYER(self)
 415         {
 416                 if (self.freezetag_frozen)
 417                         freezetag_Unfreeze(world);
 418                 self.freezetag_frozen_timeout = -1;
 419                 PutClientInServer();
 420                 self.freezetag_frozen_timeout = 0;
 421         }
 422         freezetag_count_alive_players();
 423         return 1;
 424 }
 425
 426 MUTATOR_HOOKFUNCTION(freezetag_GiveFragsForKill)
 427 {
 428         frag_score = 0; // no frags counted in Freeze Tag
 429         return 1;
 430 }
 431
 432 .float reviving; // temp var
 433 MUTATOR_HOOKFUNCTION(freezetag_PlayerPreThink)
 434 {
 435         float n;
 436
 437         if(gameover)
 438                 return 1;
 439
 440         if(self.freezetag_frozen)
 441         {
 442                 // keep health = 1
 443                 self.pauseregen_finished = time + autocvar_g_balance_pause_health_regen;
 444         }
 445
 446         if(round_handler_IsActive())
 447         if(!round_handler_IsRoundStarted())
 448                 return 1;
 449
 450         entity o;
 451         o = world;
 452         if(self.freezetag_frozen_timeout > 0 && time < self.freezetag_frozen_timeout)
 453                 self.freezetag_ice.alpha = ICE_MIN_ALPHA + (ICE_MAX_ALPHA - ICE_MIN_ALPHA) * (self.freezetag_frozen_timeout - time) / (self.freezetag_frozen_timeout - self.freezetag_frozen_time);
 454
 455         if(self.freezetag_frozen_timeout > 0 && time >= self.freezetag_frozen_timeout)
 456                 n = -1;
 457         else
 458         {
 459                 vector revive_extra_size = '1 1 1' * autocvar_g_freezetag_revive_extra_size;
 460                 n = 0;
 461                 FOR_EACH_PLAYER(other) if(self != other)
 462                 {
 463                         if(other.freezetag_frozen == 0)
 464                         {
 465                                 if(other.team == self.team)
 466                                 {
 467                                         if(boxesoverlap(self.absmin - revive_extra_size, self.absmax + revive_extra_size, other.absmin, other.absmax))
 468                                         {
 469                                                 if(!o)
 470                                                         o = other;
 471                                                 if(self.freezetag_frozen)
 472                                                         other.reviving = TRUE;
 473                                                 ++n;
 474                                         }
 475                                 }
 476                         }
 477                 }
 478         }
 479
 480         if(n && self.freezetag_frozen) // OK, there is at least one teammate reviving us
 481         {
 482                 self.freezetag_revive_progress = bound(0, self.freezetag_revive_progress + frametime * autocvar_g_freezetag_revive_speed, 1);
 483                 self.health = max(1, self.freezetag_revive_progress * autocvar_g_balance_health_start);
 484
 485                 if(self.freezetag_revive_progress >= 1)
 486                 {
 487                         freezetag_Unfreeze(self);
 488                         freezetag_count_alive_players();
 489
 490                         if(n == -1)
 491                         {
 492                                 string s = ftos(autocvar_g_freezetag_frozen_maxtime);
 493                                 centerprint(self, strcat("^5You were automatically revived after ", s, " seconds^5.\n"));
 494                                 bprint("^7", self.netname, "^5 were automatically revived after ", s, " seconds^5.\n");
 495                                 return 1;
 496                         }
 497
 498                         // EVERY team mate nearby gets a point (even if multiple!)
 499                         FOR_EACH_PLAYER(other)
 500                         {
 501                                 if(other.reviving)
 502                                 {
 503                                         PlayerScore_Add(other, SP_FREEZETAG_REVIVALS, +1);
 504                                         PlayerScore_Add(other, SP_SCORE, +1);
 505                                 }
 506                         }
 507
 508                         if(n > 1)
 509                                 centerprint(self, strcat("^5You were revived by ^7", o.netname, "^5 et al.\n"));
 510                         else
 511                                 centerprint(self, strcat("^5You were revived by ^7", o.netname, "^5.\n"));
 512                         centerprint(o, strcat("^5You revived ^7", self.netname, "^5.\n"));
 513                         if(n > 1)
 514                                 bprint("^7", o.netname, "^5 et al revived ^7", self.netname, "^5.\n");
 515                         else
 516                                 bprint("^7", o.netname, "^5 revived ^7", self.netname, "^5.\n");
 517                 }
 518
 519                 FOR_EACH_PLAYER(other)
 520                 {
 521                         if(other.reviving)
 522                         {
 523                                 other.freezetag_revive_progress = self.freezetag_revive_progress;
 524                                 other.reviving = FALSE;
 525                         }
 526                 }
 527         }
 528         else if(!n && self.freezetag_frozen) // only if no teammate is nearby will we reset
 529         {
 530                 self.freezetag_revive_progress = bound(0, self.freezetag_revive_progress - frametime * autocvar_g_freezetag_revive_clearspeed, 1);
 531                 self.health = max(1, self.freezetag_revive_progress * autocvar_g_balance_health_start);
 532         }
 533         else if(!n)
 534         {
 535                 self.freezetag_revive_progress = 0; // thawing nobody
 536         }
 537
 538         return 1;
 539 }
 540
 541 MUTATOR_HOOKFUNCTION(freezetag_PlayerPhysics)
 542 {
 543         if(self.freezetag_frozen)
 544         {
 545                 self.movement = '0 0 0';
 546                 self.disableclientprediction = 1;
 547         }
 548         return 1;
 549 }
 550
 551 MUTATOR_HOOKFUNCTION(freezetag_PlayerDamage_Calculate)
 552 {
 553         if(frag_target.freezetag_frozen && frag_deathtype != DEATH_HURTTRIGGER)
 554         {
 555                 frag_damage = 0;
 556                 frag_force = frag_force * autocvar_g_freezetag_frozen_force;
 557         }
 558         return 1;
 559 }
 560
 561 MUTATOR_HOOKFUNCTION(freezetag_ForbidThrowCurrentWeapon)
 562 {
 563         if (self.freezetag_frozen)
 564                 return 1;
 565         return 0;
 566 }
 567
 568 MUTATOR_HOOKFUNCTION(freezetag_BotRoles)
 569 {
 570         if not(self.deadflag)
 571         {
 572                 if (random() < 0.5)
 573                         self.havocbot_role = havocbot_role_ft_freeing;
 574                 else
 575                         self.havocbot_role = havocbot_role_ft_offense;
 576         }
 577
 578         return TRUE;
 579 }
 580
 581 MUTATOR_HOOKFUNCTION(freezetag_SpectateCopy)
 582 {
 583         self.freezetag_frozen = other.freezetag_frozen;
 584         self.freezetag_revive_progress = other.freezetag_revive_progress;
 585         return 0;
 586 }
 587
 588 MUTATOR_HOOKFUNCTION(freezetag_GetTeamCount)
 589 {
 590         freezetag_teams = autocvar_g_freezetag_teams_override;
 591         if(freezetag_teams < 2)
 592                 freezetag_teams = autocvar_g_freezetag_teams;
 593         freezetag_teams = bound(2, freezetag_teams, 4);
 594         ret_float = freezetag_teams;
 595         return 0;
 596 }
 597
 598 void freezetag_Initialize()
 599 {
 600         precache_model("models/ice/ice.md3");
 601         ScoreRules_freezetag();
 602
 603         round_handler_Spawn(freezetag_CheckTeams, freezetag_CheckWinner, func_null);
 604         round_handler_Init(5, autocvar_g_freezetag_warmup, autocvar_g_freezetag_round_timelimit);
 605
 606         addstat(STAT_REDALIVE, AS_INT, redalive_stat);
 607         addstat(STAT_BLUEALIVE, AS_INT, bluealive_stat);
 608         addstat(STAT_YELLOWALIVE, AS_INT, yellowalive_stat);
 609         addstat(STAT_PINKALIVE, AS_INT, pinkalive_stat);
 610
 611         addstat(STAT_FROZEN, AS_INT, freezetag_frozen);
 612         addstat(STAT_REVIVE_PROGRESS, AS_FLOAT, freezetag_revive_progress);
 613 }
 614
 615 MUTATOR_DEFINITION(gamemode_freezetag)
 616 {
 617         MUTATOR_HOOK(MakePlayerObserver, freezetag_RemovePlayer, CBC_ORDER_ANY);
 618         MUTATOR_HOOK(ClientDisconnect, freezetag_RemovePlayer, CBC_ORDER_ANY);
 619         MUTATOR_HOOK(PlayerDies, freezetag_PlayerDies, CBC_ORDER_ANY);
 620         MUTATOR_HOOK(PlayerSpawn, freezetag_PlayerSpawn, CBC_ORDER_ANY);
 621         MUTATOR_HOOK(reset_map_players, freezetag_reset_map_players, CBC_ORDER_ANY);
 622         MUTATOR_HOOK(GiveFragsForKill, freezetag_GiveFragsForKill, CBC_ORDER_FIRST);
 623         MUTATOR_HOOK(PlayerPreThink, freezetag_PlayerPreThink, CBC_ORDER_FIRST);
 624         MUTATOR_HOOK(PlayerPhysics, freezetag_PlayerPhysics, CBC_ORDER_FIRST);
 625         MUTATOR_HOOK(PlayerDamage_Calculate, freezetag_PlayerDamage_Calculate, CBC_ORDER_ANY);
 626         MUTATOR_HOOK(ForbidThrowCurrentWeapon, freezetag_ForbidThrowCurrentWeapon, CBC_ORDER_ANY);
 627         MUTATOR_HOOK(HavocBot_ChooseRule, freezetag_BotRoles, CBC_ORDER_ANY);
 628         MUTATOR_HOOK(SpectateCopy, freezetag_SpectateCopy, CBC_ORDER_ANY);
 629         MUTATOR_HOOK(GetTeamCount, freezetag_GetTeamCount, CBC_ORDER_EXCLUSIVE);
 630
 631         MUTATOR_ONADD
 632         {
 633                 if(time > 1) // game loads at time 1
 634                         error("This is a game type and it cannot be added at runtime.");
 635                 freezetag_Initialize();
 636         }
 637
 638         MUTATOR_ONROLLBACK_OR_REMOVE
 639         {
 640                 // we actually cannot roll back freezetag_Initialize here
 641                 // BUT: we don't need to! If this gets called, adding always
 642                 // succeeds.
 643         }
 644
 645         MUTATOR_ONREMOVE
 646         {
 647                 print("This is a game type and it cannot be removed at runtime.");
 648                 return -1;
 649         }
 650
 651         return 0;
 652 }