qcsrc/server/mutators/mutator/gamemode_freezetag.qc

   1 #include "gamemode_freezetag.qh"
   2
   3 float autocvar_g_freezetag_frozen_maxtime;
   4 float autocvar_g_freezetag_revive_clearspeed;
   5 float autocvar_g_freezetag_round_timelimit;
   6 //int autocvar_g_freezetag_teams;
   7 int autocvar_g_freezetag_teams_override;
   8 float autocvar_g_freezetag_warmup;
   9
  10 void freezetag_ScoreRules(int teams)
  11 {
  12         ScoreRules_basics(teams, SFL_SORT_PRIO_PRIMARY, SFL_SORT_PRIO_PRIMARY, true); // SFL_SORT_PRIO_PRIMARY
  13         ScoreInfo_SetLabel_PlayerScore(SP_FREEZETAG_REVIVALS, "revivals", 0);
  14         ScoreRules_basics_end();
  15 }
  16
  17 void freezetag_count_alive_players()
  18 {
  19         total_players = redalive = bluealive = yellowalive = pinkalive = 0;
  20         FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(
  21                 switch(it.team)
  22                 {
  23                         case NUM_TEAM_1: ++total_players; if(it.health >= 1 && STAT(FROZEN, it) != 1) ++redalive; break;
  24                         case NUM_TEAM_2: ++total_players; if(it.health >= 1 && STAT(FROZEN, it) != 1) ++bluealive; break;
  25                         case NUM_TEAM_3: ++total_players; if(it.health >= 1 && STAT(FROZEN, it) != 1) ++yellowalive; break;
  26                         case NUM_TEAM_4: ++total_players; if(it.health >= 1 && STAT(FROZEN, it) != 1) ++pinkalive; break;
  27                 }
  28         ));
  29         FOREACH_CLIENT(IS_REAL_CLIENT(it), LAMBDA(
  30                 it.redalive_stat = redalive;
  31                 it.bluealive_stat = bluealive;
  32                 it.yellowalive_stat = yellowalive;
  33                 it.pinkalive_stat = pinkalive;
  34         ));
  35
  36         eliminatedPlayers.SendFlags |= 1;
  37 }
  38 #define FREEZETAG_ALIVE_TEAMS() ((redalive > 0) + (bluealive > 0) + (yellowalive > 0) + (pinkalive > 0))
  39 #define FREEZETAG_ALIVE_TEAMS_OK() (FREEZETAG_ALIVE_TEAMS() == NumTeams(freezetag_teams))
  40
  41 float freezetag_CheckTeams()
  42 {
  43         static float prev_missing_teams_mask;
  44         if(FREEZETAG_ALIVE_TEAMS_OK())
  45         {
  46                 if(prev_missing_teams_mask > 0)
  47                         Kill_Notification(NOTIF_ALL, NULL, MSG_CENTER, CPID_MISSING_TEAMS);
  48                 prev_missing_teams_mask = -1;
  49                 return 1;
  50         }
  51         if(total_players == 0)
  52         {
  53                 if(prev_missing_teams_mask > 0)
  54                         Kill_Notification(NOTIF_ALL, NULL, MSG_CENTER, CPID_MISSING_TEAMS);
  55                 prev_missing_teams_mask = -1;
  56                 return 0;
  57         }
  58         int missing_teams_mask = 0;
  59         if(freezetag_teams & BIT(0))
  60                 missing_teams_mask += (!redalive) * 1;
  61         if(freezetag_teams & BIT(1))
  62                 missing_teams_mask += (!bluealive) * 2;
  63         if(freezetag_teams & BIT(2))
  64                 missing_teams_mask += (!yellowalive) * 4;
  65         if(freezetag_teams & BIT(3))
  66                 missing_teams_mask += (!pinkalive) * 8;
  67         if(prev_missing_teams_mask != missing_teams_mask)
  68         {
  69                 Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_MISSING_TEAMS, missing_teams_mask);
  70                 prev_missing_teams_mask = missing_teams_mask;
  71         }
  72         return 0;
  73 }
  74
  75 float freezetag_getWinnerTeam()
  76 {
  77         float winner_team = 0;
  78         if(redalive >= 1)
  79                 winner_team = NUM_TEAM_1;
  80         if(bluealive >= 1)
  81         {
  82                 if(winner_team) return 0;
  83                 winner_team = NUM_TEAM_2;
  84         }
  85         if(yellowalive >= 1)
  86         {
  87                 if(winner_team) return 0;
  88                 winner_team = NUM_TEAM_3;
  89         }
  90         if(pinkalive >= 1)
  91         {
  92                 if(winner_team) return 0;
  93                 winner_team = NUM_TEAM_4;
  94         }
  95         if(winner_team)
  96                 return winner_team;
  97         return -1; // no player left
  98 }
  99
 100 void nades_Clear(entity);
 101 void nades_GiveBonus(entity player, float score);
 102
 103 float freezetag_CheckWinner()
 104 {
 105         if(round_handler_GetEndTime() > 0 && round_handler_GetEndTime() - time <= 0)
 106         {
 107                 Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_ROUND_OVER);
 108                 Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_ROUND_OVER);
 109                 FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(
 110                         it.freezetag_frozen_timeout = 0;
 111                         nades_Clear(it);
 112                 ));
 113                 game_stopped = true;
 114                 round_handler_Init(5, autocvar_g_freezetag_warmup, autocvar_g_freezetag_round_timelimit);
 115                 return 1;
 116         }
 117
 118         if(FREEZETAG_ALIVE_TEAMS() > 1)
 119                 return 0;
 120
 121         int winner_team = freezetag_getWinnerTeam();
 122         if(winner_team > 0)
 123         {
 124                 Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, APP_TEAM_NUM(winner_team, CENTER_ROUND_TEAM_WIN));
 125                 Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(winner_team, INFO_ROUND_TEAM_WIN));
 126                 TeamScore_AddToTeam(winner_team, ST_SCORE, +1);
 127         }
 128         else if(winner_team == -1)
 129         {
 130                 Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_ROUND_TIED);
 131                 Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_ROUND_TIED);
 132         }
 133
 134         FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(
 135                 it.freezetag_frozen_timeout = 0;
 136                 nades_Clear(it);
 137         ));
 138
 139         game_stopped = true;
 140         round_handler_Init(5, autocvar_g_freezetag_warmup, autocvar_g_freezetag_round_timelimit);
 141         return 1;
 142 }
 143
 144 entity freezetag_LastPlayerForTeam(entity this)
 145 {
 146         entity last_pl = NULL;
 147         FOREACH_CLIENT(IS_PLAYER(it) && it != this, LAMBDA(
 148                 if(it.health >= 1)
 149                 if(!STAT(FROZEN, it))
 150                 if(SAME_TEAM(it, this))
 151                 if(!last_pl)
 152                         last_pl = it;
 153                 else
 154                         return NULL;
 155         ));
 156         return last_pl;
 157 }
 158
 159 void freezetag_LastPlayerForTeam_Notify(entity this)
 160 {
 161         if(round_handler_IsActive())
 162         if(round_handler_IsRoundStarted())
 163         {
 164                 entity pl = freezetag_LastPlayerForTeam(this);
 165                 if(pl)
 166                         Send_Notification(NOTIF_ONE, pl, MSG_CENTER, CENTER_ALONE);
 167         }
 168 }
 169
 170 void freezetag_Add_Score(entity targ, entity attacker)
 171 {
 172         if(attacker == targ)
 173         {
 174                 // you froze your own dumb targ
 175                 // counted as "suicide" already
 176                 PlayerScore_Add(targ, SP_SCORE, -1);
 177         }
 178         else if(IS_PLAYER(attacker))
 179         {
 180                 // got frozen by an enemy
 181                 // counted as "kill" and "death" already
 182                 PlayerScore_Add(targ, SP_SCORE, -1);
 183                 PlayerScore_Add(attacker, SP_SCORE, +1);
 184         }
 185         // else nothing - got frozen by the game type rules themselves
 186 }
 187
 188 void freezetag_Freeze(entity targ, entity attacker)
 189 {
 190         if(STAT(FROZEN, targ))
 191                 return;
 192
 193         if(autocvar_g_freezetag_frozen_maxtime > 0)
 194                 targ.freezetag_frozen_timeout = time + autocvar_g_freezetag_frozen_maxtime;
 195
 196         Freeze(targ, 0, 1, true);
 197
 198         freezetag_count_alive_players();
 199
 200         freezetag_Add_Score(targ, attacker);
 201 }
 202
 203 void freezetag_Unfreeze(entity this)
 204 {
 205         this.freezetag_frozen_time = 0;
 206         this.freezetag_frozen_timeout = 0;
 207
 208         Unfreeze(this);
 209 }
 210
 211 float freezetag_isEliminated(entity e)
 212 {
 213         if(IS_PLAYER(e) && (STAT(FROZEN, e) == 1 || IS_DEAD(e)))
 214                 return true;
 215         return false;
 216 }
 217
 218
 219 // ================
 220 // Bot player logic
 221 // ================
 222
 223 void(entity this) havocbot_role_ft_freeing;
 224 void(entity this) havocbot_role_ft_offense;
 225
 226 void havocbot_goalrating_freeplayers(entity this, float ratingscale, vector org, float sradius)
 227 {
 228         FOREACH_CLIENT(IS_PLAYER(it) && it != this && SAME_TEAM(it, this), LAMBDA(
 229                 if (STAT(FROZEN, it) == 1)
 230                 {
 231                         if(vdist(it.origin - org, >, sradius))
 232                                 continue;
 233                         navigation_routerating(this, it, ratingscale, 2000);
 234                 }
 235                 else
 236                 {
 237                         // If teamate is not frozen still seek them out as fight better
 238                         // in a group.
 239                         navigation_routerating(this, it, ratingscale/3, 2000);
 240                 }
 241         ));
 242 }
 243
 244 void havocbot_role_ft_offense(entity this)
 245 {
 246         if(IS_DEAD(this))
 247                 return;
 248
 249         if (!this.havocbot_role_timeout)
 250                 this.havocbot_role_timeout = time + random() * 10 + 20;
 251
 252         // Count how many players on team are unfrozen.
 253         int unfrozen = 0;
 254         FOREACH_CLIENT(IS_PLAYER(it) && SAME_TEAM(it, this) && !(STAT(FROZEN, it) != 1), LAMBDA(unfrozen++));
 255
 256         // If only one left on team or if role has timed out then start trying to free players.
 257         if (((unfrozen == 0) && (!STAT(FROZEN, this))) || (time > this.havocbot_role_timeout))
 258         {
 259                 LOG_TRACE("changing role to freeing");
 260                 this.havocbot_role = havocbot_role_ft_freeing;
 261                 this.havocbot_role_timeout = 0;
 262                 return;
 263         }
 264
 265         if (time > this.bot_strategytime)
 266         {
 267                 this.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
 268
 269                 navigation_goalrating_start(this);
 270                 havocbot_goalrating_items(this, 10000, this.origin, 10000);
 271                 havocbot_goalrating_enemyplayers(this, 20000, this.origin, 10000);
 272                 havocbot_goalrating_freeplayers(this, 9000, this.origin, 10000);
 273                 havocbot_goalrating_waypoints(this, 1, this.origin, 3000);
 274                 navigation_goalrating_end(this);
 275         }
 276 }
 277
 278 void havocbot_role_ft_freeing(entity this)
 279 {
 280         if(IS_DEAD(this))
 281                 return;
 282
 283         if (!this.havocbot_role_timeout)
 284                 this.havocbot_role_timeout = time + random() * 10 + 20;
 285
 286         if (time > this.havocbot_role_timeout)
 287         {
 288                 LOG_TRACE("changing role to offense");
 289                 this.havocbot_role = havocbot_role_ft_offense;
 290                 this.havocbot_role_timeout = 0;
 291                 return;
 292         }
 293
 294         if (time > this.bot_strategytime)
 295         {
 296                 this.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
 297
 298                 navigation_goalrating_start(this);
 299                 havocbot_goalrating_items(this, 8000, this.origin, 10000);
 300                 havocbot_goalrating_enemyplayers(this, 10000, this.origin, 10000);
 301                 havocbot_goalrating_freeplayers(this, 20000, this.origin, 10000);
 302                 havocbot_goalrating_waypoints(this, 1, this.origin, 3000);
 303                 navigation_goalrating_end(this);
 304         }
 305 }
 306
 307
 308 // ==============
 309 // Hook Functions
 310 // ==============
 311
 312 void ft_RemovePlayer(entity this)
 313 {
 314         this.health = 0; // neccessary to update correctly alive stats
 315         if(!STAT(FROZEN, this))
 316                 freezetag_LastPlayerForTeam_Notify(this);
 317         freezetag_Unfreeze(this);
 318         freezetag_count_alive_players();
 319 }
 320
 321 MUTATOR_HOOKFUNCTION(ft, ClientDisconnect)
 322 {
 323         entity player = M_ARGV(0, entity);
 324
 325         ft_RemovePlayer(player);
 326         return true;
 327 }
 328
 329 MUTATOR_HOOKFUNCTION(ft, MakePlayerObserver)
 330 {
 331         entity player = M_ARGV(0, entity);
 332
 333         ft_RemovePlayer(player);
 334 }
 335
 336 MUTATOR_HOOKFUNCTION(ft, PlayerDies)
 337 {
 338         entity frag_attacker = M_ARGV(1, entity);
 339         entity frag_target = M_ARGV(2, entity);
 340         float frag_deathtype = M_ARGV(3, float);
 341
 342         if(round_handler_IsActive())
 343         if(round_handler_CountdownRunning())
 344         {
 345                 if(STAT(FROZEN, frag_target))
 346                         freezetag_Unfreeze(frag_target);
 347                 freezetag_count_alive_players();
 348                 return true; // let the player die so that he can respawn whenever he wants
 349         }
 350
 351         // Cases DEATH_TEAMCHANGE and DEATH_AUTOTEAMCHANGE are needed to fix a bug whe
 352         // you succeed changing team through the menu: you both really die (gibbing) and get frozen
 353         if(ITEM_DAMAGE_NEEDKILL(frag_deathtype)
 354                 || frag_deathtype == DEATH_TEAMCHANGE.m_id || frag_deathtype == DEATH_AUTOTEAMCHANGE.m_id)
 355         {
 356                 // let the player die, he will be automatically frozen when he respawns
 357                 if(STAT(FROZEN, frag_target) != 1)
 358                 {
 359                         freezetag_Add_Score(frag_target, frag_attacker);
 360                         freezetag_count_alive_players();
 361                         freezetag_LastPlayerForTeam_Notify(frag_target);
 362                 }
 363                 else
 364                         freezetag_Unfreeze(frag_target); // remove ice
 365                 frag_target.health = 0; // Unfreeze resets health
 366                 frag_target.freezetag_frozen_timeout = -2; // freeze on respawn
 367                 return true;
 368         }
 369
 370         if(STAT(FROZEN, frag_target))
 371                 return true;
 372
 373         freezetag_Freeze(frag_target, frag_attacker);
 374         freezetag_LastPlayerForTeam_Notify(frag_target);
 375
 376         if(frag_attacker == frag_target || frag_attacker == NULL)
 377         {
 378                 if(IS_PLAYER(frag_target))
 379                         Send_Notification(NOTIF_ONE, frag_target, MSG_CENTER, CENTER_FREEZETAG_SELF);
 380                 Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_FREEZETAG_SELF, frag_target.netname);
 381         }
 382         else
 383         {
 384                 Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_FREEZETAG_FREEZE, frag_target.netname, frag_attacker.netname);
 385         }
 386
 387         return true;
 388 }
 389
 390 MUTATOR_HOOKFUNCTION(ft, PlayerSpawn)
 391 {
 392         entity player = M_ARGV(0, entity);
 393
 394         if(player.freezetag_frozen_timeout == -1) // if PlayerSpawn is called by reset_map_players
 395                 return true; // do nothing, round is starting right now
 396
 397         if(player.freezetag_frozen_timeout == -2) // player was dead
 398         {
 399                 freezetag_Freeze(player, NULL);
 400                 return true;
 401         }
 402
 403         freezetag_count_alive_players();
 404
 405         if(round_handler_IsActive())
 406         if(round_handler_IsRoundStarted())
 407         {
 408                 Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_FREEZETAG_SPAWN_LATE);
 409                 freezetag_Freeze(player, NULL);
 410         }
 411
 412         return true;
 413 }
 414
 415 MUTATOR_HOOKFUNCTION(ft, reset_map_players)
 416 {
 417         FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(
 418                 it.killcount = 0;
 419                 it.freezetag_frozen_timeout = -1;
 420                 PutClientInServer(it);
 421                 it.freezetag_frozen_timeout = 0;
 422         ));
 423         freezetag_count_alive_players();
 424         return true;
 425 }
 426
 427 MUTATOR_HOOKFUNCTION(ft, GiveFragsForKill, CBC_ORDER_FIRST)
 428 {
 429         M_ARGV(2, float) = 0; // no frags counted in Freeze Tag
 430         return true;
 431 }
 432
 433 MUTATOR_HOOKFUNCTION(ft, PlayerPreThink, CBC_ORDER_FIRST)
 434 {
 435         if(game_stopped)
 436                 return true;
 437
 438         if(round_handler_IsActive())
 439         if(!round_handler_IsRoundStarted())
 440                 return true;
 441
 442         int n;
 443         entity o = NULL;
 444         entity player = M_ARGV(0, entity);
 445         //if(STAT(FROZEN, player))
 446         //if(player.freezetag_frozen_timeout > 0 && time < player.freezetag_frozen_timeout)
 447                 //player.iceblock.alpha = ICE_MIN_ALPHA + (ICE_MAX_ALPHA - ICE_MIN_ALPHA) * (player.freezetag_frozen_timeout - time) / (player.freezetag_frozen_timeout - player.freezetag_frozen_time);
 448
 449         if(player.freezetag_frozen_timeout > 0 && time >= player.freezetag_frozen_timeout)
 450                 n = -1;
 451         else
 452         {
 453                 vector revive_extra_size = '1 1 1' * autocvar_g_freezetag_revive_extra_size;
 454                 n = 0;
 455                 FOREACH_CLIENT(IS_PLAYER(it) && it != player, LAMBDA(
 456                         if(STAT(FROZEN, it) == 0)
 457                         if(!IS_DEAD(it))
 458                         if(SAME_TEAM(it, player))
 459                         if(boxesoverlap(player.absmin - revive_extra_size, player.absmax + revive_extra_size, it.absmin, it.absmax))
 460                         {
 461                                 if(!o)
 462                                         o = it;
 463                                 if(STAT(FROZEN, player) == 1)
 464                                         it.reviving = true;
 465                                 ++n;
 466                         }
 467                 ));
 468
 469         }
 470
 471         if(n && STAT(FROZEN, player) == 1) // OK, there is at least one teammate reviving us
 472         {
 473                 player.revive_progress = bound(0, player.revive_progress + frametime * max(1/60, autocvar_g_freezetag_revive_speed), 1);
 474                 player.health = max(1, player.revive_progress * ((warmup_stage) ? warmup_start_health : start_health));
 475
 476                 if(player.revive_progress >= 1)
 477                 {
 478                         freezetag_Unfreeze(player);
 479                         freezetag_count_alive_players();
 480
 481                         if(n == -1)
 482                         {
 483                                 Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_FREEZETAG_AUTO_REVIVED, autocvar_g_freezetag_frozen_maxtime);
 484                                 Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_FREEZETAG_AUTO_REVIVED, player.netname, autocvar_g_freezetag_frozen_maxtime);
 485                                 return true;
 486                         }
 487
 488                         // EVERY team mate nearby gets a point (even if multiple!)
 489                         FOREACH_CLIENT(IS_PLAYER(it) && it.reviving, LAMBDA(
 490                                 PlayerScore_Add(it, SP_FREEZETAG_REVIVALS, +1);
 491                                 PlayerScore_Add(it, SP_SCORE, +1);
 492                                 nades_GiveBonus(it,autocvar_g_nades_bonus_score_low);
 493                         ));
 494
 495                         Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_FREEZETAG_REVIVED, o.netname);
 496                         Send_Notification(NOTIF_ONE, o, MSG_CENTER, CENTER_FREEZETAG_REVIVE, player.netname);
 497                         Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_FREEZETAG_REVIVED, player.netname, o.netname);
 498                 }
 499
 500                 FOREACH_CLIENT(IS_PLAYER(it) && it.reviving, LAMBDA(
 501                         it.revive_progress = player.revive_progress;
 502                         it.reviving = false;
 503                 ));
 504         }
 505         else if(!n && STAT(FROZEN, player) == 1) // only if no teammate is nearby will we reset
 506         {
 507                 player.revive_progress = bound(0, player.revive_progress - frametime * autocvar_g_freezetag_revive_clearspeed, 1);
 508                 player.health = max(1, player.revive_progress * ((warmup_stage) ? warmup_start_health : start_health));
 509         }
 510         else if(!n && !STAT(FROZEN, player))
 511         {
 512                 player.revive_progress = 0; // thawing nobody
 513         }
 514
 515         return true;
 516 }
 517
 518 MUTATOR_HOOKFUNCTION(ft, SetStartItems)
 519 {
 520         start_items &= ~IT_UNLIMITED_AMMO;
 521         //start_health       = warmup_start_health       = cvar("g_lms_start_health");
 522         //start_armorvalue   = warmup_start_armorvalue   = cvar("g_lms_start_armor");
 523         start_ammo_shells  = warmup_start_ammo_shells  = cvar("g_lms_start_ammo_shells");
 524         start_ammo_nails   = warmup_start_ammo_nails   = cvar("g_lms_start_ammo_nails");
 525         start_ammo_rockets = warmup_start_ammo_rockets = cvar("g_lms_start_ammo_rockets");
 526         start_ammo_cells   = warmup_start_ammo_cells   = cvar("g_lms_start_ammo_cells");
 527         start_ammo_plasma  = warmup_start_ammo_plasma  = cvar("g_lms_start_ammo_plasma");
 528         start_ammo_fuel    = warmup_start_ammo_fuel    = cvar("g_lms_start_ammo_fuel");
 529 }
 530
 531 MUTATOR_HOOKFUNCTION(ft, HavocBot_ChooseRole)
 532 {
 533         entity bot = M_ARGV(0, entity);
 534
 535         if (!IS_DEAD(bot))
 536         {
 537                 if (random() < 0.5)
 538                         bot.havocbot_role = havocbot_role_ft_freeing;
 539                 else
 540                         bot.havocbot_role = havocbot_role_ft_offense;
 541         }
 542
 543         return true;
 544 }
 545
 546 MUTATOR_HOOKFUNCTION(ft, CheckAllowedTeams, CBC_ORDER_EXCLUSIVE)
 547 {
 548         M_ARGV(0, float) = freezetag_teams;
 549 }
 550
 551 MUTATOR_HOOKFUNCTION(ft, SetWeaponArena)
 552 {
 553         // most weapons arena
 554         if(M_ARGV(0, string) == "0" || M_ARGV(0, string) == "")
 555                 M_ARGV(0, string) = "most";
 556 }
 557
 558 MUTATOR_HOOKFUNCTION(ft, FragCenterMessage)
 559 {
 560         entity frag_attacker = M_ARGV(0, entity);
 561         entity frag_target = M_ARGV(1, entity);
 562         //float frag_deathtype = M_ARGV(2, float);
 563         int kill_count_to_attacker = M_ARGV(3, int);
 564         int kill_count_to_target = M_ARGV(4, int);
 565
 566         if(STAT(FROZEN, frag_target))
 567                 return; // target was already frozen, so this is just pushing them off the cliff
 568
 569         Send_Notification(NOTIF_ONE, frag_attacker, MSG_CHOICE, CHOICE_FRAG_FREEZE, frag_target.netname, kill_count_to_attacker, (IS_BOT_CLIENT(frag_target) ? -1 : frag_target.ping));
 570         Send_Notification(NOTIF_ONE, frag_target, MSG_CHOICE, CHOICE_FRAGGED_FREEZE, frag_attacker.netname, kill_count_to_target, frag_attacker.health, frag_attacker.armorvalue, (IS_BOT_CLIENT(frag_attacker) ? -1 : frag_attacker.ping));
 571
 572         return true;
 573 }
 574
 575 void freezetag_Initialize()
 576 {
 577         freezetag_teams = autocvar_g_freezetag_teams_override;
 578         if(freezetag_teams < 2)
 579                 freezetag_teams = cvar("g_freezetag_teams"); // read the cvar directly as it gets written earlier in the same frame
 580         freezetag_teams = bound(2, freezetag_teams, 4);
 581
 582         int teams = 0;
 583         if(freezetag_teams >= 1) teams |= BIT(0);
 584         if(freezetag_teams >= 2) teams |= BIT(1);
 585         if(freezetag_teams >= 3) teams |= BIT(2);
 586         if(freezetag_teams >= 4) teams |= BIT(3);
 587
 588         freezetag_teams = teams; // now set it?
 589         freezetag_ScoreRules(freezetag_teams);
 590
 591         round_handler_Spawn(freezetag_CheckTeams, freezetag_CheckWinner, func_null);
 592         round_handler_Init(5, autocvar_g_freezetag_warmup, autocvar_g_freezetag_round_timelimit);
 593
 594         EliminatedPlayers_Init(freezetag_isEliminated);
 595 }