qcsrc/server/mutators/gamemode_ca.qc

   1 #include "gamemode_ca.qh"
   2
   3 #include "gamemode.qh"
   4
   5 float ca_teams;
   6 float allowed_to_spawn;
   7
   8 const float ST_CA_ROUNDS = 1;
   9 void ca_ScoreRules(float teams)
  10 {
  11         ScoreRules_basics(teams, SFL_SORT_PRIO_PRIMARY, 0, true);
  12         ScoreInfo_SetLabel_TeamScore(ST_CA_ROUNDS, "rounds", SFL_SORT_PRIO_PRIMARY);
  13         ScoreRules_basics_end();
  14 }
  15
  16 void CA_count_alive_players()
  17 {
  18         entity e;
  19         total_players = redalive = bluealive = yellowalive = pinkalive = 0;
  20         FOR_EACH_PLAYER(e) {
  21                 if(e.team == NUM_TEAM_1)
  22                 {
  23                         ++total_players;
  24                         if (e.health >= 1) ++redalive;
  25                 }
  26                 else if(e.team == NUM_TEAM_2)
  27                 {
  28                         ++total_players;
  29                         if (e.health >= 1) ++bluealive;
  30                 }
  31                 else if(e.team == NUM_TEAM_3)
  32                 {
  33                         ++total_players;
  34                         if (e.health >= 1) ++yellowalive;
  35                 }
  36                 else if(e.team == NUM_TEAM_4)
  37                 {
  38                         ++total_players;
  39                         if (e.health >= 1) ++pinkalive;
  40                 }
  41         }
  42         FOR_EACH_REALCLIENT(e) {
  43                 e.redalive_stat = redalive;
  44                 e.bluealive_stat = bluealive;
  45                 e.yellowalive_stat = yellowalive;
  46                 e.pinkalive_stat = pinkalive;
  47         }
  48 }
  49
  50 float CA_GetWinnerTeam()
  51 {
  52         float winner_team = 0;
  53         if(redalive >= 1)
  54                 winner_team = NUM_TEAM_1;
  55         if(bluealive >= 1)
  56         {
  57                 if(winner_team) return 0;
  58                 winner_team = NUM_TEAM_2;
  59         }
  60         if(yellowalive >= 1)
  61         {
  62                 if(winner_team) return 0;
  63                 winner_team = NUM_TEAM_3;
  64         }
  65         if(pinkalive >= 1)
  66         {
  67                 if(winner_team) return 0;
  68                 winner_team = NUM_TEAM_4;
  69         }
  70         if(winner_team)
  71                 return winner_team;
  72         return -1; // no player left
  73 }
  74
  75 #define CA_ALIVE_TEAMS() ((redalive > 0) + (bluealive > 0) + (yellowalive > 0) + (pinkalive > 0))
  76 #define CA_ALIVE_TEAMS_OK() (CA_ALIVE_TEAMS() == ca_teams)
  77 float CA_CheckWinner()
  78 {
  79         entity e;
  80         if(round_handler_GetEndTime() > 0 && round_handler_GetEndTime() - time <= 0)
  81         {
  82                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_ROUND_OVER);
  83                 Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_ROUND_OVER);
  84                 allowed_to_spawn = false;
  85                 round_handler_Init(5, autocvar_g_ca_warmup, autocvar_g_ca_round_timelimit);
  86                 FOR_EACH_PLAYER(e)
  87                         nades_Clear(e);
  88                 return 1;
  89         }
  90
  91         CA_count_alive_players();
  92         if(CA_ALIVE_TEAMS() > 1)
  93                 return 0;
  94
  95         float winner_team = CA_GetWinnerTeam();
  96         if(winner_team > 0)
  97         {
  98                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, APP_TEAM_NUM_4(winner_team, CENTER_ROUND_TEAM_WIN_));
  99                 Send_Notification(NOTIF_ALL, world, MSG_INFO, APP_TEAM_NUM_4(winner_team, INFO_ROUND_TEAM_WIN_));
 100                 TeamScore_AddToTeam(winner_team, ST_CA_ROUNDS, +1);
 101         }
 102         else if(winner_team == -1)
 103         {
 104                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_ROUND_TIED);
 105                 Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_ROUND_TIED);
 106         }
 107
 108         allowed_to_spawn = false;
 109         round_handler_Init(5, autocvar_g_ca_warmup, autocvar_g_ca_round_timelimit);
 110
 111         FOR_EACH_PLAYER(e)
 112                 nades_Clear(e);
 113
 114         return 1;
 115 }
 116
 117 void CA_RoundStart()
 118 {
 119         if(warmup_stage)
 120                 allowed_to_spawn = true;
 121         else
 122                 allowed_to_spawn = false;
 123 }
 124
 125 float CA_CheckTeams()
 126 {
 127         static float prev_missing_teams_mask;
 128         allowed_to_spawn = true;
 129         CA_count_alive_players();
 130         if(CA_ALIVE_TEAMS_OK())
 131         {
 132                 if(prev_missing_teams_mask > 0)
 133                         Kill_Notification(NOTIF_ALL, world, MSG_CENTER_CPID, CPID_MISSING_TEAMS);
 134                 prev_missing_teams_mask = -1;
 135                 return 1;
 136         }
 137         if(total_players == 0)
 138         {
 139                 if(prev_missing_teams_mask > 0)
 140                         Kill_Notification(NOTIF_ALL, world, MSG_CENTER_CPID, CPID_MISSING_TEAMS);
 141                 prev_missing_teams_mask = -1;
 142                 return 0;
 143         }
 144         float missing_teams_mask = (!redalive) + (!bluealive) * 2;
 145         if(ca_teams >= 3) missing_teams_mask += (!yellowalive) * 4;
 146         if(ca_teams >= 4) missing_teams_mask += (!pinkalive) * 8;
 147         if(prev_missing_teams_mask != missing_teams_mask)
 148         {
 149                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_MISSING_TEAMS, missing_teams_mask);
 150                 prev_missing_teams_mask = missing_teams_mask;
 151         }
 152         return 0;
 153 }
 154
 155 float ca_isEliminated(entity e)
 156 {
 157         if(e.caplayer == 1 && (e.deadflag != DEAD_NO || e.frags == FRAGS_LMS_LOSER))
 158                 return true;
 159         if(e.caplayer == 0.5)
 160                 return true;
 161         return false;
 162 }
 163
 164 MUTATOR_HOOKFUNCTION(ca_PlayerSpawn)
 165 {SELFPARAM();
 166         self.caplayer = 1;
 167         if(!warmup_stage)
 168                 eliminatedPlayers.SendFlags |= 1;
 169         return 1;
 170 }
 171
 172 MUTATOR_HOOKFUNCTION(ca_PutClientInServer)
 173 {SELFPARAM();
 174         if(!allowed_to_spawn)
 175         if(IS_PLAYER(self)) // this is true even when player is trying to join
 176         {
 177                 self.classname = "observer";
 178                 if(self.jointime != time) //not when connecting
 179                 if(!self.caplayer)
 180                 {
 181                         self.caplayer = 0.5;
 182                         if(IS_REAL_CLIENT(self))
 183                                 Send_Notification(NOTIF_ONE_ONLY, self, MSG_INFO, INFO_CA_JOIN_LATE);
 184                 }
 185         }
 186         return 1;
 187 }
 188
 189 MUTATOR_HOOKFUNCTION(ca_reset_map_players)
 190 {SELFPARAM();
 191         entity e;
 192         FOR_EACH_CLIENT(e)
 193         {
 194                 setself(e);
 195                 self.killcount = 0;
 196                 if(!self.caplayer && IS_BOT_CLIENT(self))
 197                 {
 198                         self.team = -1;
 199                         self.caplayer = 1;
 200                 }
 201                 if(self.caplayer)
 202                 {
 203                         self.classname = "player";
 204                         self.caplayer = 1;
 205                         PutClientInServer();
 206                 }
 207         }
 208         return 1;
 209 }
 210
 211 MUTATOR_HOOKFUNCTION(ca_ClientConnect)
 212 {SELFPARAM();
 213         self.classname = "observer";
 214         return 1;
 215 }
 216
 217 MUTATOR_HOOKFUNCTION(ca_reset_map_global)
 218 {
 219         allowed_to_spawn = true;
 220         return 1;
 221 }
 222
 223 MUTATOR_HOOKFUNCTION(ca_GetTeamCount)
 224 {
 225         ret_float = ca_teams;
 226         return 0;
 227 }
 228
 229 entity ca_LastPlayerForTeam()
 230 {SELFPARAM();
 231         entity pl, last_pl = world;
 232         FOR_EACH_PLAYER(pl)
 233         {
 234                 if(pl.health >= 1)
 235                 if(pl != self)
 236                 if(pl.team == self.team)
 237                 if(!last_pl)
 238                         last_pl = pl;
 239                 else
 240                         return world;
 241         }
 242         return last_pl;
 243 }
 244
 245 void ca_LastPlayerForTeam_Notify()
 246 {
 247         if(round_handler_IsActive())
 248         if(round_handler_IsRoundStarted())
 249         {
 250                 entity pl = ca_LastPlayerForTeam();
 251                 if(pl)
 252                         Send_Notification(NOTIF_ONE, pl, MSG_CENTER, CENTER_ALONE);
 253         }
 254 }
 255
 256 MUTATOR_HOOKFUNCTION(ca_PlayerDies)
 257 {SELFPARAM();
 258         ca_LastPlayerForTeam_Notify();
 259         if(!allowed_to_spawn)
 260                 self.respawn_flags =  RESPAWN_SILENT;
 261         if(!warmup_stage)
 262                 eliminatedPlayers.SendFlags |= 1;
 263         return 1;
 264 }
 265
 266 MUTATOR_HOOKFUNCTION(ca_ClientDisconnect)
 267 {SELFPARAM();
 268         if(self.caplayer == 1)
 269                 ca_LastPlayerForTeam_Notify();
 270         return 1;
 271 }
 272
 273 MUTATOR_HOOKFUNCTION(ca_ForbidPlayerScore_Clear)
 274 {
 275         return 1;
 276 }
 277
 278 MUTATOR_HOOKFUNCTION(ca_MakePlayerObserver)
 279 {SELFPARAM();
 280         if(self.caplayer == 1)
 281                 ca_LastPlayerForTeam_Notify();
 282         if(self.killindicator_teamchange == -2)
 283                 self.caplayer = 0;
 284         if(self.caplayer)
 285                 self.frags = FRAGS_LMS_LOSER;
 286         if(!warmup_stage)
 287                 eliminatedPlayers.SendFlags |= 1;
 288         return 1;
 289 }
 290
 291 MUTATOR_HOOKFUNCTION(ca_ForbidThrowCurrentWeapon)
 292 {
 293         return 1;
 294 }
 295
 296 MUTATOR_HOOKFUNCTION(ca_GiveFragsForKill)
 297 {
 298         frag_score = 0; // score will be given to the winner team when the round ends
 299         return 1;
 300 }
 301
 302 MUTATOR_HOOKFUNCTION(ca_SetStartItems)
 303 {
 304         start_items &= ~IT_UNLIMITED_AMMO;
 305         start_health       = warmup_start_health       = cvar("g_lms_start_health");
 306         start_armorvalue   = warmup_start_armorvalue   = cvar("g_lms_start_armor");
 307         start_ammo_shells  = warmup_start_ammo_shells  = cvar("g_lms_start_ammo_shells");
 308         start_ammo_nails   = warmup_start_ammo_nails   = cvar("g_lms_start_ammo_nails");
 309         start_ammo_rockets = warmup_start_ammo_rockets = cvar("g_lms_start_ammo_rockets");
 310         start_ammo_cells   = warmup_start_ammo_cells   = cvar("g_lms_start_ammo_cells");
 311         start_ammo_plasma  = warmup_start_ammo_plasma  = cvar("g_lms_start_ammo_plasma");
 312         start_ammo_fuel    = warmup_start_ammo_fuel    = cvar("g_lms_start_ammo_fuel");
 313
 314         return 0;
 315 }
 316
 317 MUTATOR_HOOKFUNCTION(ca_PlayerDamage)
 318 {
 319         if(IS_PLAYER(frag_target))
 320         if(frag_target.deadflag == DEAD_NO)
 321         if(frag_target == frag_attacker || SAME_TEAM(frag_target, frag_attacker) || frag_deathtype == DEATH_FALL.m_id)
 322                 frag_damage = 0;
 323
 324         frag_mirrordamage = 0;
 325
 326         return false;
 327 }
 328
 329 MUTATOR_HOOKFUNCTION(ca_FilterItem)
 330 {SELFPARAM();
 331         if(autocvar_g_powerups <= 0)
 332         if(self.flags & FL_POWERUP)
 333                 return true;
 334
 335         if(autocvar_g_pickup_items <= 0)
 336                 return true;
 337
 338         return false;
 339 }
 340
 341 MUTATOR_HOOKFUNCTION(ca_PlayerDamage_SplitHealthArmor)
 342 {
 343         float excess = max(0, frag_damage - damage_take - damage_save);
 344
 345         if(frag_target != frag_attacker && IS_PLAYER(frag_attacker))
 346                 PlayerTeamScore_Add(frag_attacker, SP_SCORE, ST_SCORE, (frag_damage - excess) * autocvar_g_ca_damage2score_multiplier);
 347
 348         return false;
 349 }
 350
 351 MUTATOR_HOOKFUNCTION(ca_PlayerRegen)
 352 {
 353         // no regeneration in CA
 354         return true;
 355 }
 356
 357 MUTATOR_HOOKFUNCTION(ca_CountFrags)
 358 {
 359         // announce remaining frags
 360         return true;
 361 }
 362
 363 void ca_Initialize()
 364 {
 365         allowed_to_spawn = true;
 366
 367         ca_teams = autocvar_g_ca_teams_override;
 368         if(ca_teams < 2)
 369                 ca_teams = autocvar_g_ca_teams;
 370         ca_teams = bound(2, ca_teams, 4);
 371         ret_float = ca_teams;
 372         ca_ScoreRules(ca_teams);
 373
 374         round_handler_Spawn(CA_CheckTeams, CA_CheckWinner, CA_RoundStart);
 375         round_handler_Init(5, autocvar_g_ca_warmup, autocvar_g_ca_round_timelimit);
 376
 377         addstat(STAT_REDALIVE, AS_INT, redalive_stat);
 378         addstat(STAT_BLUEALIVE, AS_INT, bluealive_stat);
 379         addstat(STAT_YELLOWALIVE, AS_INT, yellowalive_stat);
 380         addstat(STAT_PINKALIVE, AS_INT, pinkalive_stat);
 381
 382         EliminatedPlayers_Init(ca_isEliminated);
 383 }
 384
 385 MUTATOR_DEFINITION(gamemode_ca)
 386 {
 387         MUTATOR_HOOK(PlayerSpawn, ca_PlayerSpawn, CBC_ORDER_ANY);
 388         MUTATOR_HOOK(PutClientInServer, ca_PutClientInServer, CBC_ORDER_ANY);
 389         MUTATOR_HOOK(MakePlayerObserver, ca_MakePlayerObserver, CBC_ORDER_ANY);
 390         MUTATOR_HOOK(ClientConnect, ca_ClientConnect, CBC_ORDER_ANY);
 391         MUTATOR_HOOK(reset_map_global, ca_reset_map_global, CBC_ORDER_ANY);
 392         MUTATOR_HOOK(reset_map_players, ca_reset_map_players, CBC_ORDER_ANY);
 393         MUTATOR_HOOK(GetTeamCount, ca_GetTeamCount, CBC_ORDER_EXCLUSIVE);
 394         MUTATOR_HOOK(PlayerDies, ca_PlayerDies, CBC_ORDER_ANY);
 395         MUTATOR_HOOK(ClientDisconnect, ca_ClientDisconnect, CBC_ORDER_ANY);
 396         MUTATOR_HOOK(ForbidPlayerScore_Clear, ca_ForbidPlayerScore_Clear, CBC_ORDER_ANY);
 397         MUTATOR_HOOK(ForbidThrowCurrentWeapon, ca_ForbidThrowCurrentWeapon, CBC_ORDER_ANY);
 398         MUTATOR_HOOK(GiveFragsForKill, ca_GiveFragsForKill, CBC_ORDER_FIRST);
 399         MUTATOR_HOOK(SetStartItems, ca_SetStartItems, CBC_ORDER_ANY);
 400         MUTATOR_HOOK(PlayerDamage_Calculate, ca_PlayerDamage, CBC_ORDER_ANY);
 401         MUTATOR_HOOK(FilterItem, ca_FilterItem, CBC_ORDER_ANY);
 402         MUTATOR_HOOK(PlayerDamage_SplitHealthArmor, ca_PlayerDamage_SplitHealthArmor, CBC_ORDER_ANY);
 403         MUTATOR_HOOK(PlayerRegen, ca_PlayerRegen, CBC_ORDER_ANY);
 404         MUTATOR_HOOK(Scores_CountFragsRemaining, ca_CountFrags, CBC_ORDER_ANY);
 405
 406         MUTATOR_ONADD
 407         {
 408                 if(time > 1) // game loads at time 1
 409                         error("This is a game type and it cannot be added at runtime.");
 410                 ca_Initialize();
 411         }
 412
 413         MUTATOR_ONREMOVE
 414         {
 415                 LOG_INFO("This is a game type and it cannot be removed at runtime.");
 416                 return -1;
 417         }
 418
 419         return 0;
 420 }