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
   8 void freezetag_CheckWinner()
   9 {
  10         if(time <= game_starttime || inWarmupStage)
  11                 return;
  12
  13         if(next_round || (time > warmup - autocvar_g_freezetag_warmup && time < warmup))
  14                 return; // already waiting for next round to start
  15
  16         if((redalive >= 1 && bluealive >= 1)
  17                 || (redalive >= 1 && yellowalive >= 1)
  18                 || (redalive >= 1 && pinkalive >= 1)
  19                 || (bluealive >= 1 && yellowalive >= 1)
  20                 || (bluealive >= 1 && pinkalive >= 1)
  21                 || (yellowalive >= 1 && pinkalive >= 1))
  22                 return; // we still have active players on two or more teams, nobody won yet
  23
  24         entity e, winner;
  25         string teamname;
  26         winner = world;
  27
  28         FOR_EACH_PLAYER(e)
  29         {
  30                 if(e.freezetag_frozen == 0 && e.health >= 1) // here's one player from the winning team... good
  31                 {
  32                         winner = e;
  33                         break; // break, we found the winner
  34                 }
  35         }
  36
  37         if(winner != world) // just in case a winner wasn't found
  38         {
  39                 if(winner.team == COLOR_TEAM1)
  40                         teamname = "^1Red Team";
  41                 else if(winner.team == COLOR_TEAM2)
  42                         teamname = "^4Blue Team";
  43                 else if(winner.team == COLOR_TEAM3)
  44                         teamname = "^3Yellow Team";
  45                 else
  46                         teamname = "^6Pink Team";
  47                 FOR_EACH_PLAYER(e) {
  48                         centerprint(e, strcat(teamname, "^5 wins the round, all other teams were frozen.\n"));
  49                 }
  50                 bprint(teamname, "^5 wins the round since all the other teams were frozen.\n");
  51                 TeamScore_AddToTeam(winner.team, ST_SCORE, +1);
  52         }
  53
  54         next_round = time + 5;
  55 }
  56
  57 // this is needed to allow the player to turn his view around (fixangle can't
  58 // be used to freeze his view, as that also changes the angles), while not
  59 // turning that ice object with the player
  60 void freezetag_Ice_Think()
  61 {
  62         setorigin(self, self.owner.origin - '0 0 16');
  63         self.nextthink = time;
  64 }
  65
  66 void freezetag_update_alive_stats()
  67 {
  68         entity e;
  69         FOR_EACH_REALCLIENT(e) {
  70                 e.redalive_stat = redalive;
  71                 e.bluealive_stat = bluealive;
  72                 e.yellowalive_stat = yellowalive;
  73                 e.pinkalive_stat = pinkalive;
  74         }
  75 }
  76
  77 void freezetag_add_alive()
  78 {
  79         if(self.team == COLOR_TEAM1) ++redalive;
  80         else if(self.team == COLOR_TEAM2) ++bluealive;
  81         else if(self.team == COLOR_TEAM3) ++yellowalive;
  82         else if(self.team == COLOR_TEAM4) ++pinkalive;
  83         freezetag_update_alive_stats();
  84 }
  85
  86 void freezetag_remove_alive()
  87 {
  88         if(self.team == COLOR_TEAM1) --redalive;
  89         else if(self.team == COLOR_TEAM2) --bluealive;
  90         else if(self.team == COLOR_TEAM3) --yellowalive;
  91         else if(self.team == COLOR_TEAM4) --pinkalive;
  92         freezetag_update_alive_stats();
  93 }
  94
  95 void freezetag_Freeze(entity attacker)
  96 {
  97         if(self.freezetag_frozen)
  98                 return;
  99         self.freezetag_frozen = 1;
 100         self.freezetag_revive_progress = 0;
 101         self.health = 1;
 102         if(inWarmupStage)
 103                 self.freezetag_frozen_timeout = time + 5;
 104
 105         entity ice;
 106         ice = spawn();
 107         ice.owner = self;
 108         ice.classname = "freezetag_ice";
 109         ice.think = freezetag_Ice_Think;
 110         ice.nextthink = time;
 111         ice.frame = floor(random() * 21); // ice model has 20 different looking frames
 112         setmodel(ice, "models/ice/ice.md3");
 113
 114         entity oldself;
 115         oldself = self;
 116         self = ice;
 117         freezetag_Ice_Think();
 118         self = oldself;
 119
 120         RemoveGrapplingHook(self);
 121
 122         // add waypoint
 123         WaypointSprite_Spawn("freezetag_frozen", 0, 0, self, '0 0 64', world, self.team, self, waypointsprite_attached, TRUE, RADARICON_WAYPOINT, '0.25 0.90 1');
 124
 125         if(attacker == self)
 126         {
 127                 // you froze your own dumb self
 128                 // counted as "suicide" already
 129                 PlayerScore_Add(self, SP_SCORE, -1);
 130         }
 131         else if(attacker.classname == "player")
 132         {
 133                 // got frozen by an enemy
 134                 // counted as "kill" and "death" already
 135                 PlayerScore_Add(self, SP_SCORE, -1);
 136                 PlayerScore_Add(attacker, SP_SCORE, +1);
 137         }
 138         else
 139         {
 140                 // nothing - got frozen by the game type rules themselves
 141         }
 142 }
 143
 144 void freezetag_Unfreeze(entity attacker)
 145 {
 146         self.freezetag_frozen = 0;
 147         self.freezetag_frozen_timeout = 0;
 148         self.freezetag_revive_progress = 0;
 149         self.health = autocvar_g_balance_health_start;
 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         if(self.freezetag_frozen == 0 && self.health >= 1)
 276                 freezetag_remove_alive();
 277
 278         freezetag_Unfreeze(world);
 279
 280         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)
 281                 freezetag_CheckWinner();
 282
 283         return 1;
 284 }
 285
 286 MUTATOR_HOOKFUNCTION(freezetag_PlayerDies)
 287 {
 288         if(frag_deathtype == DEATH_HURTTRIGGER)
 289         {
 290                 if(!self.freezetag_frozen)
 291                 {
 292                         freezetag_remove_alive();
 293                         freezetag_Freeze(world);
 294                         freezetag_CheckWinner();
 295                 }
 296                 PutClientInServer(); // respawn the player
 297                 self.health = 1;
 298                 return 0;
 299         }
 300
 301         if(self.freezetag_frozen == 0)
 302         {
 303                 freezetag_Freeze(frag_attacker);
 304                 freezetag_remove_alive();
 305         }
 306
 307         if(frag_attacker == frag_target || frag_attacker == world)
 308         {
 309                 if(frag_target.classname == STR_PLAYER)
 310                         centerprint(frag_target, "^1You froze yourself.\n");
 311                 bprint("^7", frag_target.netname, "^1 froze himself.\n");
 312         }
 313         else
 314         {
 315                 if(frag_target.classname == STR_PLAYER)
 316                         centerprint(frag_target, strcat("^1You were frozen by ^7", frag_attacker.netname, ".\n"));
 317                 if(frag_attacker.classname == STR_PLAYER)
 318                         centerprint(frag_attacker, strcat("^2You froze ^7", frag_target.netname, ".\n"));
 319                 bprint("^7", frag_target.netname, "^1 was frozen by ^7", frag_attacker.netname, ".\n");
 320         }
 321
 322         frag_target.health = 1; // "respawn" the player :P
 323
 324         freezetag_CheckWinner();
 325
 326         return 0;
 327 }
 328
 329 MUTATOR_HOOKFUNCTION(freezetag_PlayerSpawn)
 330 {
 331         if(self.freezetag_frozen) // stay frozen if respawning after death (DEATH_HURTTRIGGER)
 332                 return 1;
 333
 334         freezetag_add_alive();
 335
 336         if(time <= game_starttime || inWarmupStage || total_players == 0)
 337                 return 1;
 338
 339         if(total_players == 1) // only one player active on server, start a new match immediately
 340         if(!next_round && warmup && (time < warmup - autocvar_g_freezetag_warmup || time > warmup)) // not awaiting next round
 341         {
 342                 next_round = time;
 343                 return 1;
 344         }
 345
 346         if(warmup && time > warmup) // spawn too late, freeze player
 347         {
 348                 centerprint(self, "^1Round already started, you spawn as frozen.");
 349                 freezetag_Freeze(world);
 350                 freezetag_remove_alive();
 351         }
 352
 353         return 1;
 354 }
 355
 356 MUTATOR_HOOKFUNCTION(freezetag_reset_map_global)
 357 {
 358         redalive = bluealive = yellowalive = pinkalive = 0;
 359         warmup = max(time, game_starttime);
 360         if(autocvar_g_freezetag_warmup > 0)
 361                 warmup += autocvar_g_freezetag_warmup;
 362         return 1;
 363 }
 364
 365 MUTATOR_HOOKFUNCTION(freezetag_reset_map_players)
 366 {
 367         FOR_EACH_PLAYER(self)
 368         {
 369                 if (self.freezetag_frozen)
 370                         freezetag_Unfreeze(world);
 371                 PutClientInServer();
 372         }
 373         return 1;
 374 }
 375
 376 MUTATOR_HOOKFUNCTION(freezetag_GiveFragsForKill)
 377 {
 378         frag_score = 0; // no frags counted in Freeze Tag
 379         return 1;
 380 }
 381
 382 MUTATOR_HOOKFUNCTION(freezetag_PlayerPreThink)
 383 {
 384         float n;
 385         vector revive_extra_size;
 386
 387         if(gameover)
 388                 return 1;
 389         if(self.freezetag_frozen && !self.freezetag_revive_progress)
 390                 self.health = 1;
 391         if(self.freezetag_frozen_timeout && time >= self.freezetag_frozen_timeout)
 392         {
 393                 freezetag_Unfreeze(world);
 394                 freezetag_add_alive();
 395                 return 1;
 396         }
 397         if(next_round || (time > warmup - autocvar_g_freezetag_warmup && time < warmup))
 398                 return 1; // already waiting for next round to start
 399
 400         revive_extra_size = '1 1 1' * autocvar_g_freezetag_revive_extra_size;
 401
 402         entity o;
 403         o = world;
 404         n = 0;
 405         FOR_EACH_PLAYER(other) if(self != other)
 406         {
 407                 if(other.freezetag_frozen == 0)
 408                 {
 409                         if(other.team == self.team)
 410                         {
 411                                 if(boxesoverlap(self.absmin - revive_extra_size, self.absmax + revive_extra_size, other.absmin, other.absmax))
 412                                 {
 413                                         if(!o)
 414                                                 o = other;
 415                                         ++n;
 416                                 }
 417                         }
 418                 }
 419         }
 420
 421         if(n && self.freezetag_frozen) // OK, there is at least one teammate reviving us
 422         {
 423                 self.freezetag_revive_progress = bound(0, self.freezetag_revive_progress + frametime * autocvar_g_freezetag_revive_speed, 1);
 424                 self.health = max(1, self.freezetag_revive_progress * autocvar_g_balance_health_start);
 425
 426                 if(self.freezetag_revive_progress >= 1)
 427                 {
 428                         freezetag_Unfreeze(self);
 429                         freezetag_add_alive();
 430
 431                         // EVERY team mate nearby gets a point (even if multiple!)
 432                         FOR_EACH_PLAYER(other) if(self != other)
 433                         {
 434                                 if(other.freezetag_frozen == 0)
 435                                 {
 436                                         if(other.team == self.team)
 437                                         {
 438                                                 if(boxesoverlap(self.absmin - revive_extra_size, self.absmax + revive_extra_size, other.absmin, other.absmax))
 439                                                 {
 440                                                         PlayerScore_Add(other, SP_FREEZETAG_REVIVALS, +1);
 441                                                         PlayerScore_Add(other, SP_SCORE, +1);
 442                                                 }
 443                                         }
 444                                 }
 445                         }
 446
 447                         if(n > 1)
 448                                 centerprint(self, strcat("^5You were revived by ^7", o.netname, "^5 et al.\n"));
 449                         else
 450                                 centerprint(self, strcat("^5You were revived by ^7", o.netname, "^5.\n"));
 451                         centerprint(o, strcat("^5You revived ^7", self.netname, "^5.\n"));
 452                         if(n > 1)
 453                                 bprint("^7", o.netname, "^5 et al revived ^7", self.netname, "^5.\n");
 454                         else
 455                                 bprint("^7", o.netname, "^5 revived ^7", self.netname, "^5.\n");
 456                 }
 457
 458                 // now find EVERY teammate within reviving radius, set their revive_progress values correct
 459                 FOR_EACH_PLAYER(other) if(self != other)
 460                 {
 461                         if(other.freezetag_frozen == 0)
 462                         {
 463                                 if(other.team == self.team)
 464                                 {
 465                                         if(boxesoverlap(self.absmin - revive_extra_size, self.absmax + revive_extra_size, other.absmin, other.absmax))
 466                                                 other.freezetag_revive_progress = self.freezetag_revive_progress;
 467                                 }
 468                         }
 469                 }
 470         }
 471         else if(!n && self.freezetag_frozen) // only if no teammate is nearby will we reset
 472         {
 473                 self.freezetag_revive_progress = bound(0, self.freezetag_revive_progress - frametime * autocvar_g_freezetag_revive_clearspeed, 1);
 474                 self.health = max(1, self.freezetag_revive_progress * autocvar_g_balance_health_start);
 475         }
 476         else if(!n)
 477         {
 478                 self.freezetag_revive_progress = 0; // thawing nobody
 479         }
 480
 481         return 1;
 482 }
 483
 484 MUTATOR_HOOKFUNCTION(freezetag_PlayerPhysics)
 485 {
 486         if(self.freezetag_frozen)
 487         {
 488                 self.movement = '0 0 0';
 489                 self.disableclientprediction = 1;
 490         }
 491         return 1;
 492 }
 493
 494 MUTATOR_HOOKFUNCTION(freezetag_PlayerDamage_Calculate)
 495 {
 496     if(g_freezetag)
 497     {
 498         if(frag_target.freezetag_frozen == 1 && frag_deathtype != DEATH_HURTTRIGGER)
 499         {
 500             frag_damage = 0;
 501             frag_force = frag_force * autocvar_g_freezetag_frozen_force;
 502         }
 503     }
 504     return 1;
 505 }
 506
 507 MUTATOR_HOOKFUNCTION(freezetag_ForbidThrowCurrentWeapon)
 508 {
 509         if (self.freezetag_frozen)
 510                 return 1;
 511         return 0;
 512 }
 513
 514 MUTATOR_HOOKFUNCTION(freezetag_BotRoles)
 515 {
 516         if not(self.deadflag)
 517         {
 518                 if (random() < 0.5)
 519                         self.havocbot_role = havocbot_role_ft_freeing;
 520                 else
 521                         self.havocbot_role = havocbot_role_ft_offense;
 522         }
 523
 524         return TRUE;
 525 }
 526
 527 MUTATOR_DEFINITION(gamemode_freezetag)
 528 {
 529         MUTATOR_HOOK(MakePlayerObserver, freezetag_RemovePlayer, CBC_ORDER_ANY);
 530         MUTATOR_HOOK(ClientDisconnect, freezetag_RemovePlayer, CBC_ORDER_ANY);
 531         MUTATOR_HOOK(PlayerDies, freezetag_PlayerDies, CBC_ORDER_ANY);
 532         MUTATOR_HOOK(PlayerSpawn, freezetag_PlayerSpawn, CBC_ORDER_ANY);
 533         MUTATOR_HOOK(reset_map_global, freezetag_reset_map_global, CBC_ORDER_ANY);
 534         MUTATOR_HOOK(reset_map_players, freezetag_reset_map_players, CBC_ORDER_ANY);
 535         MUTATOR_HOOK(GiveFragsForKill, freezetag_GiveFragsForKill, CBC_ORDER_FIRST);
 536         MUTATOR_HOOK(PlayerPreThink, freezetag_PlayerPreThink, CBC_ORDER_FIRST);
 537         MUTATOR_HOOK(PlayerPhysics, freezetag_PlayerPhysics, CBC_ORDER_FIRST);
 538         MUTATOR_HOOK(PlayerDamage_Calculate, freezetag_PlayerDamage_Calculate, CBC_ORDER_ANY);
 539         MUTATOR_HOOK(ForbidThrowCurrentWeapon, freezetag_ForbidThrowCurrentWeapon, CBC_ORDER_FIRST); //first, last or any? dunno.
 540         MUTATOR_HOOK(HavocBot_ChooseRule, freezetag_BotRoles, CBC_ORDER_ANY);
 541
 542         MUTATOR_ONADD
 543         {
 544                 if(time > 1) // game loads at time 1
 545                         error("This is a game type and it cannot be added at runtime.");
 546                 freezetag_Initialize();
 547         }
 548
 549         MUTATOR_ONREMOVE
 550         {
 551                 error("This is a game type and it cannot be removed at runtime.");
 552         }
 553
 554         return 0;
 555 }