qcsrc/server/mutators/gamemode_freezetag.qc

   1 void freezetag_Initialize()
   2 {
   3         precache_model("models/ice/ice.md3");
   4         warmup = max(time, game_starttime) + autocvar_g_freezetag_warmup;
   5         ScoreRules_freezetag();
   6
   7         addstat(STAT_REDALIVE, AS_INT, redalive_stat);
   8         addstat(STAT_BLUEALIVE, AS_INT, bluealive_stat);
   9         addstat(STAT_YELLOWALIVE, AS_INT, yellowalive_stat);
  10         addstat(STAT_PINKALIVE, AS_INT, pinkalive_stat);
  11
  12         addstat(STAT_FROZEN, AS_INT, freezetag_frozen);
  13         addstat(STAT_REVIVE_PROGRESS, AS_FLOAT, freezetag_revive_progress);
  14 }
  15
  16 void freezetag_CheckWinner()
  17 {
  18         if(time <= game_starttime || inWarmupStage)
  19                 return;
  20
  21         if(next_round || (time > warmup - autocvar_g_freezetag_warmup && time < warmup))
  22                 return; // already waiting for next round to start
  23
  24         if((redalive >= 1 && bluealive >= 1)
  25                 || (redalive >= 1 && yellowalive >= 1)
  26                 || (redalive >= 1 && pinkalive >= 1)
  27                 || (bluealive >= 1 && yellowalive >= 1)
  28                 || (bluealive >= 1 && pinkalive >= 1)
  29                 || (yellowalive >= 1 && pinkalive >= 1))
  30                 return; // we still have active players on two or more teams, nobody won yet
  31
  32         entity e, winner;
  33         string teamname;
  34         winner = world;
  35
  36         FOR_EACH_PLAYER(e)
  37         {
  38                 if(e.freezetag_frozen == 0 && e.health >= 1) // here's one player from the winning team... good
  39                 {
  40                         winner = e;
  41                         break; // break, we found the winner
  42                 }
  43         }
  44
  45         if(winner != world) // just in case a winner wasn't found
  46         {
  47                 if(winner.team == COLOR_TEAM1)
  48                         teamname = "^1Red Team";
  49                 else if(winner.team == COLOR_TEAM2)
  50                         teamname = "^4Blue Team";
  51                 else if(winner.team == COLOR_TEAM3)
  52                         teamname = "^3Yellow Team";
  53                 else
  54                         teamname = "^6Pink Team";
  55                 FOR_EACH_PLAYER(e) {
  56                         centerprint(e, strcat(teamname, "^5 wins the round, all other teams were frozen.\n"));
  57                 }
  58                 bprint(teamname, "^5 wins the round since all the other teams were frozen.\n");
  59                 TeamScore_AddToTeam(winner.team, ST_SCORE, +1);
  60         }
  61
  62         next_round = time + 5;
  63 }
  64
  65 // this is needed to allow the player to turn his view around (fixangle can't
  66 // be used to freeze his view, as that also changes the angles), while not
  67 // turning that ice object with the player
  68 void freezetag_Ice_Think()
  69 {
  70         setorigin(self, self.owner.origin - '0 0 16');
  71         self.nextthink = time;
  72 }
  73
  74 void freezetag_count_alive_players()
  75 {
  76         entity e;
  77         redalive = bluealive = yellowalive = pinkalive = 0;
  78         FOR_EACH_PLAYER(e) {
  79                 if(e.team == COLOR_TEAM1 && e.freezetag_frozen == 0 && e.health >= 1) ++redalive;
  80                 else if(e.team == COLOR_TEAM2 && e.freezetag_frozen == 0 && e.health >= 1) ++bluealive;
  81                 else if(e.team == COLOR_TEAM3 && e.freezetag_frozen == 0 && e.health >= 1) ++yellowalive;
  82                 else if(e.team == COLOR_TEAM4 && e.freezetag_frozen == 0 && e.health >= 1) ++pinkalive;
  83         }
  84         FOR_EACH_REALCLIENT(e) {
  85                 e.redalive_stat = redalive;
  86                 e.bluealive_stat = bluealive;
  87                 e.yellowalive_stat = yellowalive;
  88                 e.pinkalive_stat = pinkalive;
  89         }
  90 }
  91
  92 void freezetag_Freeze(entity attacker)
  93 {
  94         if(self.freezetag_frozen)
  95                 return;
  96         self.freezetag_frozen = 1;
  97         self.freezetag_revive_progress = 0;
  98         self.health = 1;
  99         if(inWarmupStage)
 100                 self.freezetag_frozen_timeout = time + 5;
 101
 102         freezetag_count_alive_players();
 103
 104         entity ice;
 105         ice = spawn();
 106         ice.owner = self;
 107         ice.classname = "freezetag_ice";
 108         ice.think = freezetag_Ice_Think;
 109         ice.nextthink = time;
 110         ice.frame = floor(random() * 21); // ice model has 20 different looking frames
 111         setmodel(ice, "models/ice/ice.md3");
 112
 113         entity oldself;
 114         oldself = self;
 115         self = ice;
 116         freezetag_Ice_Think();
 117         self = oldself;
 118
 119         RemoveGrapplingHook(self);
 120
 121         // add waypoint
 122         WaypointSprite_Spawn("freezetag_frozen", 0, 0, self, '0 0 64', world, self.team, self, waypointsprite_attached, TRUE, RADARICON_WAYPOINT, '0.25 0.90 1');
 123
 124         if(attacker == self)
 125         {
 126                 // you froze your own dumb self
 127                 // counted as "suicide" already
 128                 PlayerScore_Add(self, SP_SCORE, -1);
 129         }
 130         else if(attacker.classname == "player")
 131         {
 132                 // got frozen by an enemy
 133                 // counted as "kill" and "death" already
 134                 PlayerScore_Add(self, SP_SCORE, -1);
 135                 PlayerScore_Add(attacker, SP_SCORE, +1);
 136         }
 137         else
 138         {
 139                 // nothing - got frozen by the game type rules themselves
 140         }
 141 }
 142
 143 void freezetag_Unfreeze(entity attacker)
 144 {
 145         self.freezetag_frozen = 0;
 146         self.freezetag_frozen_timeout = 0;
 147         self.freezetag_revive_progress = 0;
 148
 149         freezetag_count_alive_players();
 150
 151         // remove the ice block
 152         entity ice;
 153         for(ice = world; (ice = find(ice, classname, "freezetag_ice")); ) if(ice.owner == self)
 154         {
 155                 remove(ice);
 156                 break;
 157         }
 158
 159         // remove waypoint
 160         if(self.waypointsprite_attached)
 161                 WaypointSprite_Kill(self.waypointsprite_attached);
 162 }
 163
 164
 165 // ================
 166 // Bot player logic
 167 // ================
 168
 169 void() havocbot_role_ft_freeing;
 170 void() havocbot_role_ft_offense;
 171
 172 void havocbot_goalrating_freeplayers(float ratingscale, vector org, float sradius)
 173 {
 174         entity head;
 175         float distance;
 176
 177         FOR_EACH_PLAYER(head)
 178         {
 179                 if ((head != self) && (head.team == self.team))
 180                 {
 181                         if (head.freezetag_frozen)
 182                         {
 183                                 distance = vlen(head.origin - org);
 184                                 if (distance > sradius)
 185                                         continue;
 186                                 navigation_routerating(head, ratingscale, 2000);
 187                         }
 188                         else
 189                         {
 190                                 // If teamate is not frozen still seek them out as fight better
 191                                 // in a group.
 192                                 navigation_routerating(head, ratingscale/3, 2000);
 193                         }
 194                 }
 195         }
 196 }
 197
 198 void havocbot_role_ft_offense()
 199 {
 200         entity head;
 201         float unfrozen;
 202
 203         if(self.deadflag != DEAD_NO)
 204                 return;
 205
 206         if (!self.havocbot_role_timeout)
 207                 self.havocbot_role_timeout = time + random() * 10 + 20;
 208
 209         // Count how many players on team are unfrozen.
 210         unfrozen = 0;
 211         FOR_EACH_PLAYER(head)
 212         {
 213                 if ((head.team == self.team) && (!head.freezetag_frozen))
 214                         unfrozen++;
 215         }
 216
 217         // If only one left on team or if role has timed out then start trying to free players.
 218         if (((unfrozen == 0) && (!self.freezetag_frozen)) || (time > self.havocbot_role_timeout))
 219         {
 220                 dprint("changing role to freeing\n");
 221                 self.havocbot_role = havocbot_role_ft_freeing;
 222                 self.havocbot_role_timeout = 0;
 223                 return;
 224         }
 225
 226         if (time > self.bot_strategytime)
 227         {
 228                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
 229
 230                 navigation_goalrating_start();
 231                 havocbot_goalrating_items(10000, self.origin, 10000);
 232                 havocbot_goalrating_enemyplayers(20000, self.origin, 10000);
 233                 havocbot_goalrating_freeplayers(9000, self.origin, 10000);
 234                 //havocbot_goalrating_waypoints(1, self.origin, 1000);
 235                 navigation_goalrating_end();
 236         }
 237 }
 238
 239 void havocbot_role_ft_freeing()
 240 {
 241         if(self.deadflag != DEAD_NO)
 242                 return;
 243
 244         if (!self.havocbot_role_timeout)
 245                 self.havocbot_role_timeout = time + random() * 10 + 20;
 246
 247         if (time > self.havocbot_role_timeout)
 248         {
 249                 dprint("changing role to offense\n");
 250                 self.havocbot_role = havocbot_role_ft_offense;
 251                 self.havocbot_role_timeout = 0;
 252                 return;
 253         }
 254
 255         if (time > self.bot_strategytime)
 256         {
 257                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
 258
 259                 navigation_goalrating_start();
 260                 havocbot_goalrating_items(8000, self.origin, 10000);
 261                 havocbot_goalrating_enemyplayers(10000, self.origin, 10000);
 262                 havocbot_goalrating_freeplayers(20000, self.origin, 10000);
 263                 //havocbot_goalrating_waypoints(1, self.origin, 1000);
 264                 navigation_goalrating_end();
 265         }
 266 }
 267
 268
 269 // ==============
 270 // Hook Functions
 271 // ==============
 272
 273 MUTATOR_HOOKFUNCTION(freezetag_RemovePlayer)
 274 {
 275         self.health = 0; // neccessary to update correctly alive stats
 276         freezetag_Unfreeze(world);
 277
 278         if(total_players > 2) // only check for winners if we had more than two players (one of them left, don't let the other player win just because of that)
 279                 freezetag_CheckWinner();
 280
 281         return 1;
 282 }
 283
 284 MUTATOR_HOOKFUNCTION(freezetag_PlayerDies)
 285 {
 286         // let the player die in these cases
 287         if(time <= game_starttime)
 288                 return 1;
 289         if(next_round || (time > warmup - autocvar_g_freezetag_warmup && time < warmup))
 290                 return 1;
 291
 292         if(frag_deathtype == DEATH_HURTTRIGGER)
 293         {
 294                 if(!self.freezetag_frozen)
 295                 {
 296                         freezetag_Freeze(world);
 297                         freezetag_CheckWinner();
 298                 }
 299                 PutClientInServer(); // respawn the player
 300                 self.health = 1;
 301                 self.armorvalue = 0;
 302                 return 1;
 303         }
 304
 305         if(self.freezetag_frozen)
 306                 return 1;
 307
 308         freezetag_Freeze(frag_attacker);
 309
 310         if(frag_attacker == frag_target || frag_attacker == world)
 311         {
 312                 if(frag_target.classname == STR_PLAYER)
 313                         centerprint(frag_target, "^1You froze yourself.\n");
 314                 bprint("^7", frag_target.netname, "^1 froze himself.\n");
 315         }
 316         else
 317         {
 318                 if(frag_target.classname == STR_PLAYER)
 319                         centerprint(frag_target, strcat("^1You were frozen by ^7", frag_attacker.netname, ".\n"));
 320                 if(frag_attacker.classname == STR_PLAYER)
 321                         centerprint(frag_attacker, strcat("^2You froze ^7", frag_target.netname, ".\n"));
 322                 bprint("^7", frag_target.netname, "^1 was frozen by ^7", frag_attacker.netname, ".\n");
 323         }
 324
 325         frag_target.health = 1; // "respawn" the player :P
 326
 327         freezetag_CheckWinner();
 328
 329         return 1;
 330 }
 331
 332 MUTATOR_HOOKFUNCTION(freezetag_PlayerSpawn)
 333 {
 334         freezetag_count_alive_players();
 335
 336         if(self.freezetag_frozen) // stay frozen if respawning after death (DEATH_HURTTRIGGER)
 337                 return 1;
 338
 339         if(time <= game_starttime || inWarmupStage || total_players == 0)
 340                 return 1;
 341
 342         if(total_players == 1) // only one player active on server, start a new match immediately
 343         if(!next_round && warmup && (time < warmup - autocvar_g_freezetag_warmup || time > warmup)) // not awaiting next round
 344         {
 345                 next_round = time;
 346                 return 1;
 347         }
 348
 349         if(warmup && time > warmup) // spawn too late, freeze player
 350         {
 351                 centerprint(self, "^1Round already started, you spawn as frozen.");
 352                 freezetag_Freeze(world);
 353         }
 354
 355         return 1;
 356 }
 357
 358 MUTATOR_HOOKFUNCTION(freezetag_reset_map_global)
 359 {
 360         redalive = bluealive = yellowalive = pinkalive = 0;
 361         warmup = max(time, game_starttime);
 362         if(autocvar_g_freezetag_warmup > 0)
 363                 warmup += autocvar_g_freezetag_warmup;
 364         return 1;
 365 }
 366
 367 MUTATOR_HOOKFUNCTION(freezetag_reset_map_players)
 368 {
 369         FOR_EACH_PLAYER(self)
 370         {
 371                 if (self.freezetag_frozen)
 372                         freezetag_Unfreeze(world);
 373                 PutClientInServer();
 374         }
 375         return 1;
 376 }
 377
 378 MUTATOR_HOOKFUNCTION(freezetag_GiveFragsForKill)
 379 {
 380         frag_score = 0; // no frags counted in Freeze Tag
 381         return 1;
 382 }
 383
 384 MUTATOR_HOOKFUNCTION(freezetag_PlayerPreThink)
 385 {
 386         float n;
 387         vector revive_extra_size;
 388
 389         if(gameover)
 390                 return 1;
 391         if(self.freezetag_frozen && !self.freezetag_revive_progress)
 392                 self.health = 1;
 393         if(self.freezetag_frozen_timeout && time >= self.freezetag_frozen_timeout)
 394         {
 395                 self.health = autocvar_g_balance_health_start;
 396                 freezetag_Unfreeze(world);
 397                 return 1;
 398         }
 399         if(next_round || (time > warmup - autocvar_g_freezetag_warmup && time < warmup))
 400                 return 1; // already waiting for next round to start
 401
 402         revive_extra_size = '1 1 1' * autocvar_g_freezetag_revive_extra_size;
 403
 404         entity o;
 405         o = world;
 406         n = 0;
 407         FOR_EACH_PLAYER(other) if(self != other)
 408         {
 409                 if(other.freezetag_frozen == 0)
 410                 {
 411                         if(other.team == self.team)
 412                         {
 413                                 if(boxesoverlap(self.absmin - revive_extra_size, self.absmax + revive_extra_size, other.absmin, other.absmax))
 414                                 {
 415                                         if(!o)
 416                                                 o = other;
 417                                         ++n;
 418                                 }
 419                         }
 420                 }
 421         }
 422
 423         if(n && self.freezetag_frozen) // OK, there is at least one teammate reviving us
 424         {
 425                 self.freezetag_revive_progress = bound(0, self.freezetag_revive_progress + frametime * autocvar_g_freezetag_revive_speed, 1);
 426                 self.health = max(1, self.freezetag_revive_progress * autocvar_g_balance_health_start);
 427
 428                 if(self.freezetag_revive_progress >= 1)
 429                 {
 430                         freezetag_Unfreeze(self);
 431
 432                         // EVERY team mate nearby gets a point (even if multiple!)
 433                         FOR_EACH_PLAYER(other) if(self != other)
 434                         {
 435                                 if(other.freezetag_frozen == 0)
 436                                 {
 437                                         if(other.team == self.team)
 438                                         {
 439                                                 if(boxesoverlap(self.absmin - revive_extra_size, self.absmax + revive_extra_size, other.absmin, other.absmax))
 440                                                 {
 441                                                         PlayerScore_Add(other, SP_FREEZETAG_REVIVALS, +1);
 442                                                         PlayerScore_Add(other, SP_SCORE, +1);
 443                                                 }
 444                                         }
 445                                 }
 446                         }
 447
 448                         if(n > 1)
 449                                 centerprint(self, strcat("^5You were revived by ^7", o.netname, "^5 et al.\n"));
 450                         else
 451                                 centerprint(self, strcat("^5You were revived by ^7", o.netname, "^5.\n"));
 452                         centerprint(o, strcat("^5You revived ^7", self.netname, "^5.\n"));
 453                         if(n > 1)
 454                                 bprint("^7", o.netname, "^5 et al revived ^7", self.netname, "^5.\n");
 455                         else
 456                                 bprint("^7", o.netname, "^5 revived ^7", self.netname, "^5.\n");
 457                 }
 458
 459                 // now find EVERY teammate within reviving radius, set their revive_progress values correct
 460                 FOR_EACH_PLAYER(other) if(self != other)
 461                 {
 462                         if(other.freezetag_frozen == 0)
 463                         {
 464                                 if(other.team == self.team)
 465                                 {
 466                                         if(boxesoverlap(self.absmin - revive_extra_size, self.absmax + revive_extra_size, other.absmin, other.absmax))
 467                                                 other.freezetag_revive_progress = self.freezetag_revive_progress;
 468                                 }
 469                         }
 470                 }
 471         }
 472         else if(!n && self.freezetag_frozen) // only if no teammate is nearby will we reset
 473         {
 474                 self.freezetag_revive_progress = bound(0, self.freezetag_revive_progress - frametime * autocvar_g_freezetag_revive_clearspeed, 1);
 475                 self.health = max(1, self.freezetag_revive_progress * autocvar_g_balance_health_start);
 476         }
 477         else if(!n)
 478         {
 479                 self.freezetag_revive_progress = 0; // thawing nobody
 480         }
 481
 482         return 1;
 483 }
 484
 485 MUTATOR_HOOKFUNCTION(freezetag_PlayerPhysics)
 486 {
 487         if(self.freezetag_frozen)
 488         {
 489                 self.movement = '0 0 0';
 490                 self.disableclientprediction = 1;
 491         }
 492         return 1;
 493 }
 494
 495 MUTATOR_HOOKFUNCTION(freezetag_PlayerDamage_Calculate)
 496 {
 497         if(frag_target.freezetag_frozen == 1 && frag_deathtype != DEATH_HURTTRIGGER)
 498         {
 499                 frag_damage = 0;
 500                 frag_force = frag_force * autocvar_g_freezetag_frozen_force;
 501         }
 502         return 1;
 503 }
 504
 505 MUTATOR_HOOKFUNCTION(freezetag_ForbidThrowCurrentWeapon)
 506 {
 507         if (self.freezetag_frozen)
 508                 return 1;
 509         return 0;
 510 }
 511
 512 MUTATOR_HOOKFUNCTION(freezetag_BotRoles)
 513 {
 514         if not(self.deadflag)
 515         {
 516                 if (random() < 0.5)
 517                         self.havocbot_role = havocbot_role_ft_freeing;
 518                 else
 519                         self.havocbot_role = havocbot_role_ft_offense;
 520         }
 521
 522         return TRUE;
 523 }
 524
 525 MUTATOR_DEFINITION(gamemode_freezetag)
 526 {
 527         MUTATOR_HOOK(MakePlayerObserver, freezetag_RemovePlayer, CBC_ORDER_ANY);
 528         MUTATOR_HOOK(ClientDisconnect, freezetag_RemovePlayer, CBC_ORDER_ANY);
 529         MUTATOR_HOOK(PlayerDies, freezetag_PlayerDies, CBC_ORDER_ANY);
 530         MUTATOR_HOOK(PlayerSpawn, freezetag_PlayerSpawn, CBC_ORDER_ANY);
 531         MUTATOR_HOOK(reset_map_global, freezetag_reset_map_global, CBC_ORDER_ANY);
 532         MUTATOR_HOOK(reset_map_players, freezetag_reset_map_players, CBC_ORDER_ANY);
 533         MUTATOR_HOOK(GiveFragsForKill, freezetag_GiveFragsForKill, CBC_ORDER_FIRST);
 534         MUTATOR_HOOK(PlayerPreThink, freezetag_PlayerPreThink, CBC_ORDER_FIRST);
 535         MUTATOR_HOOK(PlayerPhysics, freezetag_PlayerPhysics, CBC_ORDER_FIRST);
 536         MUTATOR_HOOK(PlayerDamage_Calculate, freezetag_PlayerDamage_Calculate, CBC_ORDER_ANY);
 537         MUTATOR_HOOK(ForbidThrowCurrentWeapon, freezetag_ForbidThrowCurrentWeapon, CBC_ORDER_FIRST); //first, last or any? dunno.
 538         MUTATOR_HOOK(HavocBot_ChooseRule, freezetag_BotRoles, CBC_ORDER_ANY);
 539
 540         MUTATOR_ONADD
 541         {
 542                 if(time > 1) // game loads at time 1
 543                         error("This is a game type and it cannot be added at runtime.");
 544                 freezetag_Initialize();
 545         }
 546
 547         MUTATOR_ONREMOVE
 548         {
 549                 error("This is a game type and it cannot be removed at runtime.");
 550         }
 551
 552         return 0;
 553 }