qcsrc/server/mutators/mutator/gamemode_ca.qc

   1 #ifndef GAMEMODE_CA_H
   2 #define GAMEMODE_CA_H
   3
   4 int autocvar_g_ca_point_limit;
   5 int autocvar_g_ca_point_leadlimit;
   6 bool autocvar_g_ca_team_spawns;
   7
   8 void ca_Initialize();
   9
  10 REGISTER_MUTATOR(ca, false)
  11 {
  12         MUTATOR_ONADD
  13         {
  14                 if (time > 1) // game loads at time 1
  15                         error("This is a game type and it cannot be added at runtime.");
  16                 ca_Initialize();
  17
  18                 ActivateTeamplay();
  19                 SetLimits(autocvar_g_ca_point_limit, autocvar_g_ca_point_leadlimit, -1, -1);
  20
  21                 if (autocvar_g_ca_team_spawns)
  22                         have_team_spawns = -1; // request team spawns
  23         }
  24
  25         MUTATOR_ONREMOVE
  26         {
  27                 LOG_INFO("This is a game type and it cannot be removed at runtime.");
  28                 return -1;
  29         }
  30
  31         return 0;
  32 }
  33
  34 // should be removed in the future, as other code should not have to care
  35 .float caplayer; // 0.5 if scheduled to join the next round
  36 #endif
  37
  38 #ifdef IMPLEMENTATION
  39 float autocvar_g_ca_damage2score_multiplier;
  40 float autocvar_g_ca_round_timelimit;
  41 bool autocvar_g_ca_spectate_enemies;
  42 int autocvar_g_ca_teams;
  43 int autocvar_g_ca_teams_override;
  44 float autocvar_g_ca_warmup;
  45
  46 float ca_teams;
  47 float allowed_to_spawn;
  48
  49 const float ST_CA_ROUNDS = 1;
  50 void ca_ScoreRules(float teams)
  51 {
  52         ScoreRules_basics(teams, SFL_SORT_PRIO_PRIMARY, 0, true);
  53         ScoreInfo_SetLabel_TeamScore(ST_CA_ROUNDS, "rounds", SFL_SORT_PRIO_PRIMARY);
  54         ScoreRules_basics_end();
  55 }
  56
  57 void CA_count_alive_players()
  58 {
  59         total_players = redalive = bluealive = yellowalive = pinkalive = 0;
  60         FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(
  61                 switch(it.team)
  62                 {
  63                         case NUM_TEAM_1: ++total_players; if(!IS_DEAD(it)) ++redalive; break;
  64                         case NUM_TEAM_2: ++total_players; if(!IS_DEAD(it)) ++bluealive; break;
  65                         case NUM_TEAM_3: ++total_players; if(!IS_DEAD(it)) ++yellowalive; break;
  66                         case NUM_TEAM_4: ++total_players; if(!IS_DEAD(it)) ++pinkalive; break;
  67                 }
  68         ));
  69         FOREACH_CLIENT(IS_REAL_CLIENT(it), LAMBDA(
  70                 it.redalive_stat = redalive;
  71                 it.bluealive_stat = bluealive;
  72                 it.yellowalive_stat = yellowalive;
  73                 it.pinkalive_stat = pinkalive;
  74         ));
  75 }
  76
  77 float CA_GetWinnerTeam()
  78 {
  79         float winner_team = 0;
  80         if(redalive >= 1)
  81                 winner_team = NUM_TEAM_1;
  82         if(bluealive >= 1)
  83         {
  84                 if(winner_team) return 0;
  85                 winner_team = NUM_TEAM_2;
  86         }
  87         if(yellowalive >= 1)
  88         {
  89                 if(winner_team) return 0;
  90                 winner_team = NUM_TEAM_3;
  91         }
  92         if(pinkalive >= 1)
  93         {
  94                 if(winner_team) return 0;
  95                 winner_team = NUM_TEAM_4;
  96         }
  97         if(winner_team)
  98                 return winner_team;
  99         return -1; // no player left
 100 }
 101
 102 #define CA_ALIVE_TEAMS() ((redalive > 0) + (bluealive > 0) + (yellowalive > 0) + (pinkalive > 0))
 103 #define CA_ALIVE_TEAMS_OK() (CA_ALIVE_TEAMS() == ca_teams)
 104 float CA_CheckWinner()
 105 {
 106         if(round_handler_GetEndTime() > 0 && round_handler_GetEndTime() - time <= 0)
 107         {
 108                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_ROUND_OVER);
 109                 Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_ROUND_OVER);
 110                 allowed_to_spawn = false;
 111                 round_handler_Init(5, autocvar_g_ca_warmup, autocvar_g_ca_round_timelimit);
 112                 FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(nades_Clear(it)));
 113                 return 1;
 114         }
 115
 116         CA_count_alive_players();
 117         if(CA_ALIVE_TEAMS() > 1)
 118                 return 0;
 119
 120         int winner_team = CA_GetWinnerTeam();
 121         if(winner_team > 0)
 122         {
 123                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, APP_TEAM_NUM_4(winner_team, CENTER_ROUND_TEAM_WIN_));
 124                 Send_Notification(NOTIF_ALL, world, MSG_INFO, APP_TEAM_NUM_4(winner_team, INFO_ROUND_TEAM_WIN_));
 125                 TeamScore_AddToTeam(winner_team, ST_CA_ROUNDS, +1);
 126         }
 127         else if(winner_team == -1)
 128         {
 129                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_ROUND_TIED);
 130                 Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_ROUND_TIED);
 131         }
 132
 133         allowed_to_spawn = false;
 134         round_handler_Init(5, autocvar_g_ca_warmup, autocvar_g_ca_round_timelimit);
 135
 136         FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(nades_Clear(it)));
 137
 138         return 1;
 139 }
 140
 141 void CA_RoundStart()
 142 {
 143         if(warmup_stage)
 144                 allowed_to_spawn = true;
 145         else
 146                 allowed_to_spawn = false;
 147 }
 148
 149 bool CA_CheckTeams()
 150 {
 151         static int prev_missing_teams_mask;
 152         allowed_to_spawn = true;
 153         CA_count_alive_players();
 154         if(CA_ALIVE_TEAMS_OK())
 155         {
 156                 if(prev_missing_teams_mask > 0)
 157                         Kill_Notification(NOTIF_ALL, world, MSG_CENTER_CPID, CPID_MISSING_TEAMS);
 158                 prev_missing_teams_mask = -1;
 159                 return true;
 160         }
 161         if(total_players == 0)
 162         {
 163                 if(prev_missing_teams_mask > 0)
 164                         Kill_Notification(NOTIF_ALL, world, MSG_CENTER_CPID, CPID_MISSING_TEAMS);
 165                 prev_missing_teams_mask = -1;
 166                 return false;
 167         }
 168         int missing_teams_mask = (!redalive) + (!bluealive) * 2;
 169         if(ca_teams >= 3) missing_teams_mask += (!yellowalive) * 4;
 170         if(ca_teams >= 4) missing_teams_mask += (!pinkalive) * 8;
 171         if(prev_missing_teams_mask != missing_teams_mask)
 172         {
 173                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_MISSING_TEAMS, missing_teams_mask);
 174                 prev_missing_teams_mask = missing_teams_mask;
 175         }
 176         return false;
 177 }
 178
 179 bool ca_isEliminated(entity e)
 180 {
 181         if(e.caplayer == 1 && (IS_DEAD(e) || e.frags == FRAGS_LMS_LOSER))
 182                 return true;
 183         if(e.caplayer == 0.5)
 184                 return true;
 185         return false;
 186 }
 187
 188 /** Returns next available player to spectate if g_ca_spectate_enemies == 0 */
 189 entity CA_SpectateNext(entity player, entity start)
 190 {
 191     if (SAME_TEAM(start, player)) return start;
 192         // continue from current player
 193         for (entity e = start; (e = find(e, classname, STR_PLAYER)); )
 194         {
 195                 if (SAME_TEAM(player, e)) return e;
 196         }
 197         // restart from begining
 198         for (entity e = NULL; (e = find(e, classname, STR_PLAYER)); )
 199         {
 200                 if (SAME_TEAM(player, e)) return e;
 201         }
 202         return start;
 203 }
 204
 205
 206 MUTATOR_HOOKFUNCTION(ca, PlayerSpawn)
 207 {SELFPARAM();
 208         self.caplayer = 1;
 209         if(!warmup_stage)
 210                 eliminatedPlayers.SendFlags |= 1;
 211         return 1;
 212 }
 213
 214 MUTATOR_HOOKFUNCTION(ca, PutClientInServer)
 215 {SELFPARAM();
 216         if(!allowed_to_spawn)
 217         if(IS_PLAYER(self)) // this is true even when player is trying to join
 218         {
 219                 self.classname = STR_OBSERVER;
 220                 if(self.jointime != time) //not when connecting
 221                 if(!self.caplayer)
 222                 {
 223                         self.caplayer = 0.5;
 224                         if(IS_REAL_CLIENT(self))
 225                                 Send_Notification(NOTIF_ONE_ONLY, self, MSG_INFO, INFO_CA_JOIN_LATE);
 226                 }
 227         }
 228         return 1;
 229 }
 230
 231 MUTATOR_HOOKFUNCTION(ca, reset_map_players)
 232 {SELFPARAM();
 233         FOREACH_CLIENT(true, LAMBDA(
 234                 setself(it);
 235                 self.killcount = 0;
 236                 if(!self.caplayer && IS_BOT_CLIENT(self))
 237                 {
 238                         self.team = -1;
 239                         self.caplayer = 1;
 240                 }
 241                 if(self.caplayer)
 242                 {
 243                         self.classname = STR_PLAYER;
 244                         self.caplayer = 1;
 245                         PutClientInServer();
 246                 }
 247         ));
 248         return 1;
 249 }
 250
 251 MUTATOR_HOOKFUNCTION(ca, ClientConnect)
 252 {SELFPARAM();
 253         self.classname = STR_OBSERVER;
 254         return 1;
 255 }
 256
 257 MUTATOR_HOOKFUNCTION(ca, reset_map_global)
 258 {
 259         allowed_to_spawn = true;
 260         return 1;
 261 }
 262
 263 MUTATOR_HOOKFUNCTION(ca, GetTeamCount, CBC_ORDER_EXCLUSIVE)
 264 {
 265         ret_float = ca_teams;
 266         return false;
 267 }
 268
 269 entity ca_LastPlayerForTeam()
 270 {SELFPARAM();
 271         entity last_pl = world;
 272         FOREACH_CLIENT(IS_PLAYER(it) && it != self, LAMBDA(
 273                 if(!IS_DEAD(it))
 274                 if(SAME_TEAM(self, it))
 275                 if(!last_pl)
 276                         last_pl = it;
 277                 else
 278                         return world;
 279         ));
 280         return last_pl;
 281 }
 282
 283 void ca_LastPlayerForTeam_Notify()
 284 {
 285         if(round_handler_IsActive())
 286         if(round_handler_IsRoundStarted())
 287         {
 288                 entity pl = ca_LastPlayerForTeam();
 289                 if(pl)
 290                         Send_Notification(NOTIF_ONE, pl, MSG_CENTER, CENTER_ALONE);
 291         }
 292 }
 293
 294 MUTATOR_HOOKFUNCTION(ca, PlayerDies)
 295 {SELFPARAM();
 296         ca_LastPlayerForTeam_Notify();
 297         if(!allowed_to_spawn)
 298                 self.respawn_flags =  RESPAWN_SILENT;
 299         if(!warmup_stage)
 300                 eliminatedPlayers.SendFlags |= 1;
 301         return 1;
 302 }
 303
 304 MUTATOR_HOOKFUNCTION(ca, ClientDisconnect)
 305 {SELFPARAM();
 306         if(self.caplayer == 1)
 307                 ca_LastPlayerForTeam_Notify();
 308         return 1;
 309 }
 310
 311 MUTATOR_HOOKFUNCTION(ca, ForbidPlayerScore_Clear)
 312 {
 313         return 1;
 314 }
 315
 316 MUTATOR_HOOKFUNCTION(ca, MakePlayerObserver)
 317 {SELFPARAM();
 318         if(self.caplayer == 1)
 319                 ca_LastPlayerForTeam_Notify();
 320         if(self.killindicator_teamchange == -2)
 321                 self.caplayer = 0;
 322         if(self.caplayer)
 323                 self.frags = FRAGS_LMS_LOSER;
 324         if(!warmup_stage)
 325                 eliminatedPlayers.SendFlags |= 1;
 326         return true;
 327 }
 328
 329 MUTATOR_HOOKFUNCTION(ca, ForbidThrowCurrentWeapon)
 330 {
 331         return 1;
 332 }
 333
 334 MUTATOR_HOOKFUNCTION(ca, GiveFragsForKill, CBC_ORDER_FIRST)
 335 {
 336         frag_score = 0; // score will be given to the winner team when the round ends
 337         return 1;
 338 }
 339
 340 MUTATOR_HOOKFUNCTION(ca, SetStartItems)
 341 {
 342         start_items &= ~IT_UNLIMITED_AMMO;
 343         start_health       = warmup_start_health       = cvar("g_lms_start_health");
 344         start_armorvalue   = warmup_start_armorvalue   = cvar("g_lms_start_armor");
 345         start_ammo_shells  = warmup_start_ammo_shells  = cvar("g_lms_start_ammo_shells");
 346         start_ammo_nails   = warmup_start_ammo_nails   = cvar("g_lms_start_ammo_nails");
 347         start_ammo_rockets = warmup_start_ammo_rockets = cvar("g_lms_start_ammo_rockets");
 348         start_ammo_cells   = warmup_start_ammo_cells   = cvar("g_lms_start_ammo_cells");
 349         start_ammo_plasma  = warmup_start_ammo_plasma  = cvar("g_lms_start_ammo_plasma");
 350         start_ammo_fuel    = warmup_start_ammo_fuel    = cvar("g_lms_start_ammo_fuel");
 351
 352         return 0;
 353 }
 354
 355 MUTATOR_HOOKFUNCTION(ca, PlayerDamage_Calculate)
 356 {
 357         if(IS_PLAYER(frag_target))
 358         if(!IS_DEAD(frag_target))
 359         if(frag_target == frag_attacker || SAME_TEAM(frag_target, frag_attacker) || frag_deathtype == DEATH_FALL.m_id)
 360                 frag_damage = 0;
 361
 362         frag_mirrordamage = 0;
 363
 364         return false;
 365 }
 366
 367 MUTATOR_HOOKFUNCTION(ca, FilterItem)
 368 {SELFPARAM();
 369         if(autocvar_g_powerups <= 0)
 370         if(self.flags & FL_POWERUP)
 371                 return true;
 372
 373         if(autocvar_g_pickup_items <= 0)
 374                 return true;
 375
 376         return false;
 377 }
 378
 379 MUTATOR_HOOKFUNCTION(ca, PlayerDamage_SplitHealthArmor)
 380 {
 381         float excess = max(0, frag_damage - damage_take - damage_save);
 382
 383         if(frag_target != frag_attacker && IS_PLAYER(frag_attacker))
 384                 PlayerTeamScore_Add(frag_attacker, SP_SCORE, ST_SCORE, (frag_damage - excess) * autocvar_g_ca_damage2score_multiplier);
 385
 386         return false;
 387 }
 388
 389 MUTATOR_HOOKFUNCTION(ca, PlayerRegen)
 390 {
 391         // no regeneration in CA
 392         return true;
 393 }
 394
 395 MUTATOR_HOOKFUNCTION(ca, Scores_CountFragsRemaining)
 396 {
 397         // announce remaining frags
 398         return true;
 399 }
 400
 401 MUTATOR_HOOKFUNCTION(ca, SpectateSet)
 402 {
 403         if(!autocvar_g_ca_spectate_enemies && self.caplayer)
 404         if(DIFF_TEAM(spec_player, self))
 405                 return true;
 406         return false;
 407 }
 408
 409 MUTATOR_HOOKFUNCTION(ca, SpectateNext)
 410 {SELFPARAM();
 411         if(!autocvar_g_ca_spectate_enemies && self.caplayer)
 412         {
 413                 spec_player = CA_SpectateNext(self, spec_player);
 414                 return true;
 415         }
 416         return false;
 417 }
 418
 419 MUTATOR_HOOKFUNCTION(ca, SpectatePrev)
 420 {SELFPARAM();
 421         if(!autocvar_g_ca_spectate_enemies && self.caplayer)
 422         {
 423                 do { spec_player = spec_player.chain; }
 424                 while(spec_player && DIFF_TEAM(spec_player, self));
 425
 426                 if (!spec_player)
 427                 {
 428                         spec_player = spec_first;
 429                         while(spec_player && DIFF_TEAM(spec_player, self))
 430                                 spec_player = spec_player.chain;
 431                         if(spec_player == self.enemy)
 432                                 return MUT_SPECPREV_RETURN;
 433                 }
 434         }
 435
 436         return MUT_SPECPREV_FOUND;
 437 }
 438
 439 MUTATOR_HOOKFUNCTION(ca, Bot_FixCount, CBC_ORDER_EXCLUSIVE)
 440 {
 441         FOREACH_CLIENT(IS_REAL_CLIENT(it), LAMBDA(
 442                 if(IS_PLAYER(it) || it.caplayer == 1)
 443                         ++bot_activerealplayers;
 444                 ++bot_realplayers;
 445         ));
 446
 447         return true;
 448 }
 449
 450 MUTATOR_HOOKFUNCTION(ca, ClientCommand_Spectate)
 451 {
 452         if(self.caplayer)
 453         {
 454                 // they're going to spec, we can do other checks
 455                 if(autocvar_sv_spectate && (IS_SPEC(self) || IS_OBSERVER(self)))
 456                         Send_Notification(NOTIF_ONE_ONLY, self, MSG_INFO, INFO_CA_LEAVE);
 457                 return MUT_SPECCMD_FORCE;
 458         }
 459
 460         return MUT_SPECCMD_CONTINUE;
 461 }
 462
 463 MUTATOR_HOOKFUNCTION(ca, WantWeapon)
 464 {
 465         want_allguns = true;
 466         return false;
 467 }
 468
 469 MUTATOR_HOOKFUNCTION(ca, GetPlayerStatus)
 470 {
 471         if(set_player.caplayer == 1)
 472                 return true;
 473         return false;
 474 }
 475
 476 MUTATOR_HOOKFUNCTION(ca, SetWeaponArena)
 477 {
 478         // most weapons arena
 479         if(ret_string == "0" || ret_string == "")
 480                 ret_string = "most";
 481         return false;
 482 }
 483
 484 void ca_Initialize()
 485 {
 486         allowed_to_spawn = true;
 487
 488         ca_teams = autocvar_g_ca_teams_override;
 489         if(ca_teams < 2)
 490                 ca_teams = autocvar_g_ca_teams;
 491         ca_teams = bound(2, ca_teams, 4);
 492         ret_float = ca_teams;
 493         ca_ScoreRules(ca_teams);
 494
 495         round_handler_Spawn(CA_CheckTeams, CA_CheckWinner, CA_RoundStart);
 496         round_handler_Init(5, autocvar_g_ca_warmup, autocvar_g_ca_round_timelimit);
 497
 498         EliminatedPlayers_Init(ca_isEliminated);
 499 }
 500
 501 #endif