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) // game didn't even start yet! nobody can win in that case.
  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
 103         entity ice;
 104         ice = spawn();
 105         ice.owner = self;
 106         ice.classname = "freezetag_ice";
 107         ice.think = freezetag_Ice_Think;
 108         ice.nextthink = time;
 109         ice.frame = floor(random() * 21); // ice model has 20 different looking frames
 110         setmodel(ice, "models/ice/ice.md3");
 111
 112         entity oldself;
 113         oldself = self;
 114         self = ice;
 115         freezetag_Ice_Think();
 116         self = oldself;
 117
 118         RemoveGrapplingHook(self);
 119
 120         // add waypoint
 121         WaypointSprite_Spawn("freezetag_frozen", 0, 0, self, '0 0 64', world, self.team, self, waypointsprite_attached, TRUE, RADARICON_WAYPOINT, '0.25 0.90 1');
 122
 123         if(attacker == self)
 124         {
 125                 // you froze your own dumb self
 126                 // counted as "suicide" already
 127                 PlayerScore_Add(self, SP_SCORE, -1);
 128         }
 129         else if(attacker.classname == "player")
 130         {
 131                 // got frozen by an enemy
 132                 // counted as "kill" and "death" already
 133                 PlayerScore_Add(self, SP_SCORE, -1);
 134                 PlayerScore_Add(attacker, SP_SCORE, +1);
 135         }
 136         else
 137         {
 138                 // nothing - got frozen by the game type rules themselves
 139         }
 140 }
 141
 142 void freezetag_Unfreeze(entity attacker)
 143 {
 144         self.freezetag_frozen = 0;
 145         self.freezetag_revive_progress = 0;
 146         self.health = autocvar_g_balance_health_start;
 147
 148         // remove the ice block
 149         entity ice;
 150         for(ice = world; (ice = find(ice, classname, "freezetag_ice")); ) if(ice.owner == self)
 151         {
 152                 remove(ice);
 153                 break;
 154         }
 155
 156         // remove waypoint
 157         if(self.waypointsprite_attached)
 158                 WaypointSprite_Kill(self.waypointsprite_attached);
 159 }
 160
 161
 162 // ================
 163 // Bot player logic
 164 // ================
 165
 166 void() havocbot_role_ft_freeing;
 167 void() havocbot_role_ft_offense;
 168
 169 void havocbot_goalrating_freeplayers(float ratingscale, vector org, float sradius)
 170 {
 171         entity head;
 172         float distance;
 173
 174         FOR_EACH_PLAYER(head)
 175         {
 176                 if ((head != self) && (head.team == self.team))
 177                 {
 178                         if (head.freezetag_frozen)
 179                         {
 180                                 distance = vlen(head.origin - org);
 181                                 if (distance > sradius)
 182                                         continue;
 183                                 navigation_routerating(head, ratingscale, 2000);
 184                         }
 185                         else
 186                         {
 187                                 // If teamate is not frozen still seek them out as fight better
 188                                 // in a group.
 189                                 navigation_routerating(head, ratingscale/3, 2000);
 190                         }
 191                 }
 192         }
 193 }
 194
 195 void havocbot_role_ft_offense()
 196 {
 197         entity head;
 198         float unfrozen;
 199
 200         if(self.deadflag != DEAD_NO)
 201                 return;
 202
 203         if (!self.havocbot_role_timeout)
 204                 self.havocbot_role_timeout = time + random() * 10 + 20;
 205
 206         // Count how many players on team are unfrozen.
 207         unfrozen = 0;
 208         FOR_EACH_PLAYER(head)
 209         {
 210                 if ((head.team == self.team) && (!head.freezetag_frozen))
 211                         unfrozen++;
 212         }
 213
 214         // If only one left on team or if role has timed out then start trying to free players.
 215         if (((unfrozen == 0) && (!self.freezetag_frozen)) || (time > self.havocbot_role_timeout))
 216         {
 217                 dprint("changing role to freeing\n");
 218                 self.havocbot_role = havocbot_role_ft_freeing;
 219                 self.havocbot_role_timeout = 0;
 220                 return;
 221         }
 222
 223         if (time > self.bot_strategytime)
 224         {
 225                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
 226
 227                 navigation_goalrating_start();
 228                 havocbot_goalrating_items(10000, self.origin, 10000);
 229                 havocbot_goalrating_enemyplayers(20000, self.origin, 10000);
 230                 havocbot_goalrating_freeplayers(9000, self.origin, 10000);
 231                 //havocbot_goalrating_waypoints(1, self.origin, 1000);
 232                 navigation_goalrating_end();
 233         }
 234 }
 235
 236 void havocbot_role_ft_freeing()
 237 {
 238         if(self.deadflag != DEAD_NO)
 239                 return;
 240
 241         if (!self.havocbot_role_timeout)
 242                 self.havocbot_role_timeout = time + random() * 10 + 20;
 243
 244         if (time > self.havocbot_role_timeout)
 245         {
 246                 dprint("changing role to offense\n");
 247                 self.havocbot_role = havocbot_role_ft_offense;
 248                 self.havocbot_role_timeout = 0;
 249                 return;
 250         }
 251
 252         if (time > self.bot_strategytime)
 253         {
 254                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
 255
 256                 navigation_goalrating_start();
 257                 havocbot_goalrating_items(8000, self.origin, 10000);
 258                 havocbot_goalrating_enemyplayers(10000, self.origin, 10000);
 259                 havocbot_goalrating_freeplayers(20000, self.origin, 10000);
 260                 //havocbot_goalrating_waypoints(1, self.origin, 1000);
 261                 navigation_goalrating_end();
 262         }
 263 }
 264
 265
 266 // ==============
 267 // Hook Functions
 268 // ==============
 269
 270 MUTATOR_HOOKFUNCTION(freezetag_RemovePlayer)
 271 {
 272         if(self.freezetag_frozen == 0 && self.health >= 1)
 273                 freezetag_remove_alive();
 274
 275         freezetag_Unfreeze(world);
 276
 277         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)
 278                 freezetag_CheckWinner();
 279
 280         return 1;
 281 }
 282
 283 MUTATOR_HOOKFUNCTION(freezetag_PlayerDies)
 284 {
 285
 286         if(frag_deathtype == DEATH_HURTTRIGGER)
 287         {
 288                 if(!self.freezetag_frozen)
 289                 {
 290                         freezetag_remove_alive();
 291                         freezetag_CheckWinner();
 292                 }
 293                 PutClientInServer(); // respawn the player
 294                 self.health = 1;
 295                 return 0;
 296         }
 297
 298         if(self.freezetag_frozen == 0)
 299         {
 300                 freezetag_Freeze(frag_attacker);
 301                 freezetag_remove_alive();
 302         }
 303
 304         if(frag_attacker == frag_target || frag_attacker == world)
 305         {
 306                 if(frag_target.classname == STR_PLAYER)
 307                         centerprint(frag_target, "^1You froze yourself.\n");
 308                 bprint("^7", frag_target.netname, "^1 froze himself.\n");
 309         }
 310         else
 311         {
 312                 if(frag_target.classname == STR_PLAYER)
 313                         centerprint(frag_target, strcat("^1You were frozen by ^7", frag_attacker.netname, ".\n"));
 314                 if(frag_attacker.classname == STR_PLAYER)
 315                         centerprint(frag_attacker, strcat("^2You froze ^7", frag_target.netname, ".\n"));
 316                 bprint("^7", frag_target.netname, "^1 was frozen by ^7", frag_attacker.netname, ".\n");
 317         }
 318
 319         frag_target.health = 1; // "respawn" the player :P
 320
 321         freezetag_CheckWinner();
 322
 323         return 0;
 324 }
 325
 326 MUTATOR_HOOKFUNCTION(freezetag_PlayerSpawn)
 327 {
 328         freezetag_add_alive();
 329         if(time <= game_starttime || total_players == 0)
 330                 return 1;
 331
 332         freezetag_Unfreeze(world); // start by making sure that all ice blocks are removed
 333
 334         if(total_players == 1) // only one player active on server, start a new match immediately
 335         if(!next_round && warmup && (time < warmup - autocvar_g_freezetag_warmup || time > warmup)) // not awaiting next round
 336         {
 337                 next_round = time;
 338                 return 1;
 339         }
 340
 341         if(warmup && time > warmup) // spawn too late, freeze player
 342         {
 343                 centerprint(self, "^1You spawned after the round started, you'll spawn as frozen.\n");
 344                 freezetag_Freeze(world);
 345                 freezetag_remove_alive();
 346         }
 347
 348         return 1;
 349 }
 350
 351 MUTATOR_HOOKFUNCTION(freezetag_GiveFragsForKill)
 352 {
 353         frag_score = 0; // no frags counted in Freeze Tag
 354         return 1;
 355 }
 356
 357 MUTATOR_HOOKFUNCTION(freezetag_PlayerPreThink)
 358 {
 359         float n;
 360         vector revive_extra_size;
 361
 362         if(next_round || (time > warmup - autocvar_g_freezetag_warmup && time < warmup))
 363                 return 1; // already waiting for next round to start
 364
 365         revive_extra_size = '1 1 1' * autocvar_g_freezetag_revive_extra_size;
 366
 367         entity o;
 368         o = world;
 369         n = 0;
 370         FOR_EACH_PLAYER(other) if(self != other)
 371         {
 372                 if(other.freezetag_frozen == 0)
 373                 {
 374                         if(other.team == self.team)
 375                         {
 376                                 if(boxesoverlap(self.absmin - revive_extra_size, self.absmax + revive_extra_size, other.absmin, other.absmax))
 377                                 {
 378                                         if(!o)
 379                                                 o = other;
 380                                         ++n;
 381                                 }
 382                         }
 383                 }
 384         }
 385
 386         if(n && self.freezetag_frozen) // OK, there is at least one teammate reviving us
 387         {
 388                 self.freezetag_revive_progress = bound(0, self.freezetag_revive_progress + frametime * autocvar_g_freezetag_revive_speed, 1);
 389                 self.health = max(1, self.freezetag_revive_progress * autocvar_g_balance_health_start);
 390
 391                 if(self.freezetag_revive_progress >= 1)
 392                 {
 393                         freezetag_Unfreeze(self);
 394                         freezetag_add_alive();
 395
 396                         // EVERY team mate nearby gets a point (even if multiple!)
 397                         FOR_EACH_PLAYER(other) if(self != other)
 398                         {
 399                                 if(other.freezetag_frozen == 0)
 400                                 {
 401                                         if(other.team == self.team)
 402                                         {
 403                                                 if(boxesoverlap(self.absmin - revive_extra_size, self.absmax + revive_extra_size, other.absmin, other.absmax))
 404                                                 {
 405                                                         PlayerScore_Add(other, SP_FREEZETAG_REVIVALS, +1);
 406                                                         PlayerScore_Add(other, SP_SCORE, +1);
 407                                                 }
 408                                         }
 409                                 }
 410                         }
 411
 412                         if(n > 1)
 413                                 centerprint(self, strcat("^5You were revived by ^7", o.netname, "^5 et al.\n"));
 414                         else
 415                                 centerprint(self, strcat("^5You were revived by ^7", o.netname, "^5.\n"));
 416                         centerprint(o, strcat("^5You revived ^7", self.netname, "^5.\n"));
 417                         if(n > 1)
 418                                 bprint("^7", o.netname, "^5 et al revived ^7", self.netname, "^5.\n");
 419                         else
 420                                 bprint("^7", o.netname, "^5 revived ^7", self.netname, "^5.\n");
 421                 }
 422
 423                 // now find EVERY teammate within reviving radius, set their revive_progress values correct
 424                 FOR_EACH_PLAYER(other) if(self != other)
 425                 {
 426                         if(other.freezetag_frozen == 0)
 427                         {
 428                                 if(other.team == self.team)
 429                                 {
 430                                         if(boxesoverlap(self.absmin - revive_extra_size, self.absmax + revive_extra_size, other.absmin, other.absmax))
 431                                                 other.freezetag_revive_progress = self.freezetag_revive_progress;
 432                                 }
 433                         }
 434                 }
 435         }
 436         else if(!n && self.freezetag_frozen) // only if no teammate is nearby will we reset
 437         {
 438                 self.freezetag_revive_progress = bound(0, self.freezetag_revive_progress - frametime * autocvar_g_freezetag_revive_clearspeed, 1);
 439                 self.health = max(1, self.freezetag_revive_progress * autocvar_g_balance_health_start);
 440         }
 441         else if(!n)
 442         {
 443                 self.freezetag_revive_progress = 0; // thawing nobody
 444         }
 445
 446         return 1;
 447 }
 448
 449 MUTATOR_HOOKFUNCTION(freezetag_PlayerPhysics)
 450 {
 451         if(self.freezetag_frozen)
 452         {
 453                 self.movement = '0 0 0';
 454                 self.disableclientprediction = 1;
 455         }
 456         return 1;
 457 }
 458
 459 MUTATOR_HOOKFUNCTION(freezetag_PlayerDamage_Calculate)
 460 {
 461     if(g_freezetag)
 462     {
 463         if(frag_target.freezetag_frozen == 1 && frag_deathtype != DEATH_HURTTRIGGER)
 464         {
 465             frag_damage = 0;
 466             frag_force = frag_force * autocvar_g_freezetag_frozen_force;
 467         }
 468     }
 469     return 1;
 470 }
 471
 472 MUTATOR_HOOKFUNCTION(freezetag_ForbidThrowCurrentWeapon)
 473 {
 474         if (self.freezetag_frozen)
 475                 return 1;
 476         return 0;
 477 }
 478
 479 MUTATOR_HOOKFUNCTION(freezetag_BotRoles)
 480 {
 481         if not(self.deadflag)
 482         {
 483                 if (random() < 0.5)
 484                         self.havocbot_role = havocbot_role_ft_freeing;
 485                 else
 486                         self.havocbot_role = havocbot_role_ft_offense;
 487         }
 488
 489         return TRUE;
 490 }
 491
 492 MUTATOR_DEFINITION(gamemode_freezetag)
 493 {
 494         MUTATOR_HOOK(MakePlayerObserver, freezetag_RemovePlayer, CBC_ORDER_ANY);
 495         MUTATOR_HOOK(ClientDisconnect, freezetag_RemovePlayer, CBC_ORDER_ANY);
 496         MUTATOR_HOOK(PlayerDies, freezetag_PlayerDies, CBC_ORDER_ANY);
 497         MUTATOR_HOOK(PlayerSpawn, freezetag_PlayerSpawn, CBC_ORDER_ANY);
 498         MUTATOR_HOOK(GiveFragsForKill, freezetag_GiveFragsForKill, CBC_ORDER_FIRST);
 499         MUTATOR_HOOK(PlayerPreThink, freezetag_PlayerPreThink, CBC_ORDER_FIRST);
 500         MUTATOR_HOOK(PlayerPhysics, freezetag_PlayerPhysics, CBC_ORDER_FIRST);
 501         MUTATOR_HOOK(PlayerDamage_Calculate, freezetag_PlayerDamage_Calculate, CBC_ORDER_ANY);
 502         MUTATOR_HOOK(ForbidThrowCurrentWeapon, freezetag_ForbidThrowCurrentWeapon, CBC_ORDER_FIRST); //first, last or any? dunno.
 503         MUTATOR_HOOK(HavocBot_ChooseRule, freezetag_BotRoles, CBC_ORDER_ANY);
 504
 505         MUTATOR_ONADD
 506         {
 507                 if(time > 1) // game loads at time 1
 508                         error("This is a game type and it cannot be added at runtime.");
 509                 freezetag_Initialize();
 510         }
 511
 512         MUTATOR_ONREMOVE
 513         {
 514                 error("This is a game type and it cannot be removed at runtime.");
 515         }
 516
 517         return 0;
 518 }