qcsrc/common/gamemodes/gamemode/freezetag/freezetag.qc

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