qcsrc/server/mutators/gamemode_invasion.qc

   1 #include "gamemode_invasion.qh"
   2 #include "../_all.qh"
   3
   4 #include "gamemode.qh"
   5
   6 #include "../../common/monsters/spawn.qh"
   7 #include "../../common/monsters/sv_monsters.qh"
   8
   9 spawnfunc(invasion_spawnpoint)
  10 {
  11         if(!g_invasion) { remove(self); return; }
  12
  13         self.classname = "invasion_spawnpoint";
  14
  15         if(autocvar_g_invasion_zombies_only) // precache only if it hasn't been already
  16         if(self.monsterid)
  17                 MON_ACTION(self.monsterid, MR_PRECACHE);
  18 }
  19
  20 float invasion_PickMonster(float supermonster_count)
  21 {
  22         if(autocvar_g_invasion_zombies_only)
  23                 return MON_ZOMBIE.monsterid;
  24
  25         float i;
  26         entity mon;
  27
  28         RandomSelection_Init();
  29
  30         for(i = MON_FIRST; i <= MON_LAST; ++i)
  31         {
  32                 mon = get_monsterinfo(i);
  33                 if((mon.spawnflags & MONSTER_TYPE_FLY) || (mon.spawnflags & MONSTER_TYPE_SWIM) || ((mon.spawnflags & MON_FLAG_SUPERMONSTER) && supermonster_count >= 1))
  34                         continue; // flying/swimming monsters not yet supported
  35
  36                 RandomSelection_Add(world, i, string_null, 1, 1);
  37         }
  38
  39         return RandomSelection_chosen_float;
  40 }
  41
  42 entity invasion_PickSpawn()
  43 {
  44         entity e;
  45
  46         RandomSelection_Init();
  47
  48         for(e = world;(e = find(e, classname, "invasion_spawnpoint")); )
  49         {
  50                 RandomSelection_Add(e, 0, string_null, 1, ((time >= e.spawnshieldtime) ? 0.2 : 1)); // give recently used spawnpoints a very low rating
  51                 e.spawnshieldtime = time + autocvar_g_invasion_spawnpoint_spawn_delay;
  52         }
  53
  54         return RandomSelection_chosen_ent;
  55 }
  56
  57 void invasion_SpawnChosenMonster(float mon)
  58 {
  59         entity spawn_point, monster;
  60
  61         spawn_point = invasion_PickSpawn();
  62
  63         if(spawn_point == world)
  64         {
  65                 LOG_TRACE("Warning: couldn't find any invasion_spawnpoint spawnpoints, attempting to spawn monsters in random locations\n");
  66                 entity e = spawn();
  67                 setsize(e, (get_monsterinfo(mon)).mins, (get_monsterinfo(mon)).maxs);
  68
  69                 if(MoveToRandomMapLocation(e, DPCONTENTS_SOLID | DPCONTENTS_CORPSE | DPCONTENTS_PLAYERCLIP, DPCONTENTS_SLIME | DPCONTENTS_LAVA | DPCONTENTS_SKY | DPCONTENTS_BODY | DPCONTENTS_DONOTENTER, Q3SURFACEFLAG_SKY, 10, 1024, 256))
  70                         monster = spawnmonster("", mon, world, world, e.origin, false, false, 2);
  71                 else return;
  72
  73                 e.think = SUB_Remove;
  74                 e.nextthink = time + 0.1;
  75         }
  76         else
  77                 monster = spawnmonster("", ((spawn_point.monsterid) ? spawn_point.monsterid : mon), spawn_point, spawn_point, spawn_point.origin, false, false, 2);
  78
  79         if(spawn_point) monster.target2 = spawn_point.target2;
  80         monster.spawnshieldtime = time;
  81         if(spawn_point && spawn_point.target_range) monster.target_range = spawn_point.target_range;
  82
  83         if(teamplay)
  84         if(spawn_point && spawn_point.team && inv_monsters_perteam[spawn_point.team] > 0)
  85                 monster.team = spawn_point.team;
  86         else
  87         {
  88                 RandomSelection_Init();
  89                 if(inv_monsters_perteam[NUM_TEAM_1] > 0) RandomSelection_Add(world, NUM_TEAM_1, string_null, 1, 1);
  90                 if(inv_monsters_perteam[NUM_TEAM_2] > 0) RandomSelection_Add(world, NUM_TEAM_2, string_null, 1, 1);
  91                 if(invasion_teams >= 3) if(inv_monsters_perteam[NUM_TEAM_3] > 0) { RandomSelection_Add(world, NUM_TEAM_3, string_null, 1, 1); }
  92                 if(invasion_teams >= 4) if(inv_monsters_perteam[NUM_TEAM_4] > 0) { RandomSelection_Add(world, NUM_TEAM_4, string_null, 1, 1); }
  93
  94                 monster.team = RandomSelection_chosen_float;
  95         }
  96
  97         if(teamplay)
  98         {
  99                 monster_setupcolors(monster);
 100
 101                 if(monster.sprite)
 102                 {
 103                         WaypointSprite_UpdateTeamRadar(monster.sprite, RADARICON_DANGER, ((monster.team) ? Team_ColorRGB(monster.team) : '1 0 0'));
 104
 105                         monster.sprite.team = 0;
 106                         monster.sprite.SendFlags |= 1;
 107                 }
 108         }
 109
 110         monster.monster_attack = false; // it's the player's job to kill all the monsters
 111
 112         if(inv_roundcnt >= inv_maxrounds)
 113                 monster.spawnflags |= MONSTERFLAG_MINIBOSS; // last round spawns minibosses
 114 }
 115
 116 void invasion_SpawnMonsters(float supermonster_count)
 117 {
 118         float chosen_monster = invasion_PickMonster(supermonster_count);
 119
 120         invasion_SpawnChosenMonster(chosen_monster);
 121 }
 122
 123 float Invasion_CheckWinner()
 124 {
 125         entity head;
 126         if(round_handler_GetEndTime() > 0 && round_handler_GetEndTime() - time <= 0)
 127         {
 128                 FOR_EACH_MONSTER(head)
 129                         Monster_Remove(head);
 130
 131                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_ROUND_OVER);
 132                 Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_ROUND_OVER);
 133                 round_handler_Init(5, autocvar_g_invasion_warmup, autocvar_g_invasion_round_timelimit);
 134                 return 1;
 135         }
 136
 137         float total_alive_monsters = 0, supermonster_count = 0, red_alive = 0, blue_alive = 0, yellow_alive = 0, pink_alive = 0;
 138
 139         FOR_EACH_MONSTER(head) if(head.health > 0)
 140         {
 141                 if((get_monsterinfo(head.monsterid)).spawnflags & MON_FLAG_SUPERMONSTER)
 142                         ++supermonster_count;
 143                 ++total_alive_monsters;
 144
 145                 if(teamplay)
 146                 switch(head.team)
 147                 {
 148                         case NUM_TEAM_1: ++red_alive; break;
 149                         case NUM_TEAM_2: ++blue_alive; break;
 150                         case NUM_TEAM_3: ++yellow_alive; break;
 151                         case NUM_TEAM_4: ++pink_alive; break;
 152                 }
 153         }
 154
 155         if((total_alive_monsters + inv_numkilled) < inv_maxspawned && inv_maxcurrent < inv_maxspawned)
 156         {
 157                 if(time >= inv_lastcheck)
 158                 {
 159                         invasion_SpawnMonsters(supermonster_count);
 160                         inv_lastcheck = time + autocvar_g_invasion_spawn_delay;
 161                 }
 162
 163                 return 0;
 164         }
 165
 166         if(inv_numspawned < 1)
 167                 return 0; // nothing has spawned yet
 168
 169         if(teamplay)
 170         {
 171                 if(((red_alive > 0) + (blue_alive > 0) + (yellow_alive > 0) + (pink_alive > 0)) > 1)
 172                         return 0;
 173         }
 174         else if(inv_numkilled < inv_maxspawned)
 175                 return 0;
 176
 177         entity winner = world;
 178         float winning_score = 0, winner_team = 0;
 179
 180
 181         if(teamplay)
 182         {
 183                 if(red_alive > 0) { winner_team = NUM_TEAM_1; }
 184                 if(blue_alive > 0)
 185                 if(winner_team) { winner_team = 0; }
 186                 else { winner_team = NUM_TEAM_2; }
 187                 if(yellow_alive > 0)
 188                 if(winner_team) { winner_team = 0; }
 189                 else { winner_team = NUM_TEAM_3; }
 190                 if(pink_alive > 0)
 191                 if(winner_team) { winner_team = 0; }
 192                 else { winner_team = NUM_TEAM_4; }
 193         }
 194         else
 195         FOR_EACH_PLAYER(head)
 196         {
 197                 float cs = PlayerScore_Add(head, SP_KILLS, 0);
 198                 if(cs > winning_score)
 199                 {
 200                         winning_score = cs;
 201                         winner = head;
 202                 }
 203         }
 204
 205         FOR_EACH_MONSTER(head)
 206                 Monster_Remove(head);
 207
 208         if(teamplay)
 209         {
 210                 if(winner_team)
 211                 {
 212                         Send_Notification(NOTIF_ALL, world, MSG_CENTER, APP_TEAM_NUM_4(winner_team, CENTER_ROUND_TEAM_WIN_));
 213                         Send_Notification(NOTIF_ALL, world, MSG_INFO, APP_TEAM_NUM_4(winner_team, INFO_ROUND_TEAM_WIN_));
 214                 }
 215         }
 216         else if(winner)
 217         {
 218                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_ROUND_PLAYER_WIN, winner.netname);
 219                 Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_ROUND_PLAYER_WIN, winner.netname);
 220         }
 221
 222         round_handler_Init(5, autocvar_g_invasion_warmup, autocvar_g_invasion_round_timelimit);
 223
 224         return 1;
 225 }
 226
 227 float Invasion_CheckPlayers()
 228 {
 229         return true;
 230 }
 231
 232 void Invasion_RoundStart()
 233 {
 234         entity e;
 235         float numplayers = 0;
 236         FOR_EACH_PLAYER(e)
 237         {
 238                 e.player_blocked = 0;
 239                 ++numplayers;
 240         }
 241
 242         if(inv_roundcnt < inv_maxrounds)
 243                 inv_roundcnt += 1; // a limiter to stop crazy counts
 244
 245         inv_monsterskill = inv_roundcnt + max(1, numplayers * 0.3);
 246
 247         inv_maxcurrent = 0;
 248         inv_numspawned = 0;
 249         inv_numkilled = 0;
 250
 251         inv_maxspawned = rint(max(autocvar_g_invasion_monster_count, autocvar_g_invasion_monster_count * (inv_roundcnt * 0.5)));
 252
 253         if(teamplay)
 254         {
 255                 DistributeEvenly_Init(inv_maxspawned, invasion_teams);
 256                 inv_monsters_perteam[NUM_TEAM_1] = DistributeEvenly_Get(1);
 257                 inv_monsters_perteam[NUM_TEAM_2] = DistributeEvenly_Get(1);
 258                 if(invasion_teams >= 3) inv_monsters_perteam[NUM_TEAM_3] = DistributeEvenly_Get(1);
 259                 if(invasion_teams >= 4) inv_monsters_perteam[NUM_TEAM_4] = DistributeEvenly_Get(1);
 260         }
 261 }
 262
 263 MUTATOR_HOOKFUNCTION(invasion_MonsterDies)
 264 {SELFPARAM();
 265         if(!(self.spawnflags & MONSTERFLAG_RESPAWNED))
 266         {
 267                 inv_numkilled += 1;
 268                 inv_maxcurrent -= 1;
 269                 if(teamplay) { inv_monsters_perteam[self.team] -= 1; }
 270
 271                 if(IS_PLAYER(frag_attacker))
 272                 if(SAME_TEAM(frag_attacker, self)) // in non-teamplay modes, same team = same player, so this works
 273                         PlayerScore_Add(frag_attacker, SP_KILLS, -1);
 274                 else
 275                 {
 276                         PlayerScore_Add(frag_attacker, SP_KILLS, +1);
 277                         if(teamplay)
 278                                 TeamScore_AddToTeam(frag_attacker.team, ST_INV_KILLS, +1);
 279                 }
 280         }
 281
 282         return false;
 283 }
 284
 285 MUTATOR_HOOKFUNCTION(invasion_MonsterSpawn)
 286 {SELFPARAM();
 287         if(!(self.spawnflags & MONSTERFLAG_SPAWNED))
 288                 return true;
 289
 290         if(!(self.spawnflags & MONSTERFLAG_RESPAWNED))
 291         {
 292                 inv_numspawned += 1;
 293                 inv_maxcurrent += 1;
 294         }
 295
 296         self.monster_skill = inv_monsterskill;
 297
 298         if((get_monsterinfo(self.monsterid)).spawnflags & MON_FLAG_SUPERMONSTER)
 299                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_INVASION_SUPERMONSTER, self.monster_name);
 300
 301         self.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_BOTCLIP | DPCONTENTS_MONSTERCLIP;
 302
 303         return false;
 304 }
 305
 306 MUTATOR_HOOKFUNCTION(invasion_OnEntityPreSpawn)
 307 {SELFPARAM();
 308         if(startsWith(self.classname, "monster_"))
 309         if(!(self.spawnflags & MONSTERFLAG_SPAWNED))
 310                 return true;
 311
 312         return false;
 313 }
 314
 315 MUTATOR_HOOKFUNCTION(invasion_StartFrame)
 316 {
 317         monsters_total = inv_maxspawned; // TODO: make sure numspawned never exceeds maxspawned
 318         monsters_killed = inv_numkilled;
 319
 320         return false;
 321 }
 322
 323 MUTATOR_HOOKFUNCTION(invasion_PlayerRegen)
 324 {
 325         // no regeneration in invasion
 326         return true;
 327 }
 328
 329 MUTATOR_HOOKFUNCTION(invasion_PlayerSpawn)
 330 {SELFPARAM();
 331         self.bot_attack = false;
 332         return false;
 333 }
 334
 335 MUTATOR_HOOKFUNCTION(invasion_PlayerDamage)
 336 {
 337         if(IS_PLAYER(frag_attacker) && IS_PLAYER(frag_target) && frag_attacker != frag_target)
 338         {
 339                 frag_damage = 0;
 340                 frag_force = '0 0 0';
 341         }
 342
 343         return false;
 344 }
 345
 346 MUTATOR_HOOKFUNCTION(invasion_PlayerCommand)
 347 {SELFPARAM();
 348         if(MUTATOR_RETURNVALUE) // command was already handled?
 349                 return false;
 350
 351         if(cmd_name == "debuginvasion")
 352         {
 353                 sprint(self, strcat("inv_maxspawned = ", ftos(inv_maxspawned), "\n"));
 354                 sprint(self, strcat("inv_numspawned = ", ftos(inv_numspawned), "\n"));
 355                 sprint(self, strcat("inv_numkilled = ", ftos(inv_numkilled), "\n"));
 356                 sprint(self, strcat("inv_roundcnt = ", ftos(inv_roundcnt), "\n"));
 357                 sprint(self, strcat("monsters_total = ", ftos(monsters_total), "\n"));
 358                 sprint(self, strcat("monsters_killed = ", ftos(monsters_killed), "\n"));
 359                 sprint(self, strcat("inv_monsterskill = ", ftos(inv_monsterskill), "\n"));
 360
 361                 return true;
 362         }
 363
 364         return false;
 365 }
 366
 367 MUTATOR_HOOKFUNCTION(invasion_BotShouldAttack)
 368 {
 369         if(!IS_MONSTER(checkentity))
 370                 return true;
 371
 372         return false;
 373 }
 374
 375 MUTATOR_HOOKFUNCTION(invasion_SetStartItems)
 376 {
 377         start_health = 200;
 378         start_armorvalue = 200;
 379
 380         return false;
 381 }
 382
 383 MUTATOR_HOOKFUNCTION(invasion_AccuracyTargetValid)
 384 {
 385         if(IS_MONSTER(frag_target))
 386                 return MUT_ACCADD_INVALID;
 387         return MUT_ACCADD_INDIFFERENT;
 388 }
 389
 390 MUTATOR_HOOKFUNCTION(invasion_AllowMobSpawning)
 391 {
 392         // monster spawning disabled during an invasion
 393         return true;
 394 }
 395
 396 MUTATOR_HOOKFUNCTION(invasion_GetTeamCount)
 397 {
 398         ret_float = invasion_teams;
 399         return false;
 400 }
 401
 402 void invasion_ScoreRules(float inv_teams)
 403 {
 404         if(inv_teams) { CheckAllowedTeams(world); }
 405         ScoreRules_basics(inv_teams, 0, 0, false);
 406         if(inv_teams) ScoreInfo_SetLabel_TeamScore(ST_INV_KILLS, "frags", SFL_SORT_PRIO_PRIMARY);
 407         ScoreInfo_SetLabel_PlayerScore(SP_KILLS, "frags", ((inv_teams) ? SFL_SORT_PRIO_SECONDARY : SFL_SORT_PRIO_PRIMARY));
 408         ScoreRules_basics_end();
 409 }
 410
 411 void invasion_DelayedInit() // Do this check with a delay so we can wait for teams to be set up.
 412 {
 413         if(autocvar_g_invasion_teams)
 414                 invasion_teams = bound(2, autocvar_g_invasion_teams, 4);
 415         else
 416                 invasion_teams = 0;
 417
 418         independent_players = 1; // to disable extra useless scores
 419
 420         invasion_ScoreRules(invasion_teams);
 421
 422         independent_players = 0;
 423
 424         round_handler_Spawn(Invasion_CheckPlayers, Invasion_CheckWinner, Invasion_RoundStart);
 425         round_handler_Init(5, autocvar_g_invasion_warmup, autocvar_g_invasion_round_timelimit);
 426
 427         inv_roundcnt = 0;
 428         inv_maxrounds = 15; // 15?
 429 }
 430
 431 void invasion_Initialize()
 432 {
 433         if(autocvar_g_invasion_zombies_only)
 434                 MON_ACTION(MON_ZOMBIE.monsterid, MR_PRECACHE);
 435         else
 436         {
 437                 float i;
 438                 entity mon;
 439                 for(i = MON_FIRST; i <= MON_LAST; ++i)
 440                 {
 441                         mon = get_monsterinfo(i);
 442                         if((mon.spawnflags & MONSTER_TYPE_FLY) || (mon.spawnflags & MONSTER_TYPE_SWIM))
 443                                 continue; // flying/swimming monsters not yet supported
 444
 445                         MON_ACTION(i, MR_PRECACHE);
 446                 }
 447         }
 448
 449         InitializeEntity(world, invasion_DelayedInit, INITPRIO_GAMETYPE);
 450 }
 451
 452 MUTATOR_DEFINITION(gamemode_invasion)
 453 {
 454         MUTATOR_HOOK(MonsterDies, invasion_MonsterDies, CBC_ORDER_ANY);
 455         MUTATOR_HOOK(MonsterSpawn, invasion_MonsterSpawn, CBC_ORDER_ANY);
 456         MUTATOR_HOOK(OnEntityPreSpawn, invasion_OnEntityPreSpawn, CBC_ORDER_ANY);
 457         MUTATOR_HOOK(SV_StartFrame, invasion_StartFrame, CBC_ORDER_ANY);
 458         MUTATOR_HOOK(PlayerRegen, invasion_PlayerRegen, CBC_ORDER_ANY);
 459         MUTATOR_HOOK(PlayerSpawn, invasion_PlayerSpawn, CBC_ORDER_ANY);
 460         MUTATOR_HOOK(PlayerDamage_Calculate, invasion_PlayerDamage, CBC_ORDER_ANY);
 461         MUTATOR_HOOK(SV_ParseClientCommand, invasion_PlayerCommand, CBC_ORDER_ANY);
 462         MUTATOR_HOOK(BotShouldAttack, invasion_BotShouldAttack, CBC_ORDER_ANY);
 463         MUTATOR_HOOK(SetStartItems, invasion_SetStartItems, CBC_ORDER_ANY);
 464         MUTATOR_HOOK(AccuracyTargetValid, invasion_AccuracyTargetValid, CBC_ORDER_ANY);
 465         MUTATOR_HOOK(AllowMobSpawning, invasion_AllowMobSpawning, CBC_ORDER_ANY);
 466         MUTATOR_HOOK(GetTeamCount, invasion_GetTeamCount, CBC_ORDER_ANY);
 467
 468         MUTATOR_ONADD
 469         {
 470                 if(time > 1) // game loads at time 1
 471                         error("This is a game type and it cannot be added at runtime.");
 472                 invasion_Initialize();
 473
 474                 cvar_settemp("g_monsters", "1");
 475         }
 476
 477         MUTATOR_ONROLLBACK_OR_REMOVE
 478         {
 479                 // we actually cannot roll back invasion_Initialize here
 480                 // BUT: we don't need to! If this gets called, adding always
 481                 // succeeds.
 482         }
 483
 484         MUTATOR_ONREMOVE
 485         {
 486                 LOG_INFO("This is a game type and it cannot be removed at runtime.");
 487                 return -1;
 488         }
 489
 490         return 0;
 491 }