qcsrc/server/mutators/gamemode_freezetag.qc

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