qcsrc/server/mutators/gamemode_invasion.qc

   1 void invasion_spawnpoint()
   2 {
   3         if(!g_invasion) { remove(self); return; }
   4
   5         self.classname = "invasion_spawnpoint";
   6 }
   7
   8 float invasion_PickMonster(float supermonster_count)
   9 {
  10         if(autocvar_g_invasion_zombies_only)
  11                 return MON_ZOMBIE;
  12
  13         float i;
  14         entity mon;
  15
  16         RandomSelection_Init();
  17
  18         for(i = MON_FIRST; i <= MON_LAST; ++i)
  19         {
  20                 mon = get_monsterinfo(i);
  21                 if((mon.spawnflags & MONSTER_TYPE_FLY) || (mon.spawnflags & MONSTER_TYPE_SWIM) || ((mon.spawnflags & MON_FLAG_SUPERMONSTER) && supermonster_count >= 1))
  22                         continue; // flying/swimming monsters not yet supported
  23
  24                 RandomSelection_Add(world, i, "", 1, 1);
  25         }
  26
  27         return RandomSelection_chosen_float;
  28 }
  29
  30 entity invasion_PickSpawn()
  31 {
  32         entity e;
  33
  34         RandomSelection_Init();
  35
  36         for(e = world;(e = find(e, classname, "invasion_spawnpoint")); )
  37                 RandomSelection_Add(e, 0, string_null, 1, 1);
  38
  39         return RandomSelection_chosen_ent;
  40 }
  41
  42 void invasion_SpawnChosenMonster(float mon)
  43 {
  44         entity spawn_point, monster;
  45
  46         spawn_point = invasion_PickSpawn();
  47
  48         if(spawn_point == world)
  49         {
  50                 dprint("Warning: couldn't find any invasion_spawnpoint spawnpoints, no monsters will spawn!\n");
  51                 return;
  52         }
  53
  54         monster = spawnmonster("", mon, spawn_point, spawn_point, spawn_point.origin, FALSE, 2);
  55
  56         if(inv_roundcnt >= inv_maxrounds)
  57                 monster.spawnflags |= MONSTERFLAG_MINIBOSS; // last round spawns minibosses
  58 }
  59
  60 void invasion_SpawnMonsters(float supermonster_count)
  61 {
  62         float chosen_monster = invasion_PickMonster(supermonster_count);
  63
  64         invasion_SpawnChosenMonster(chosen_monster);
  65 }
  66
  67 float Invasion_CheckWinner()
  68 {
  69         entity head;
  70         if(round_handler_GetEndTime() > 0 && round_handler_GetEndTime() - time <= 0)
  71         {
  72                 FOR_EACH_MONSTER(head)
  73                         monster_remove(head);
  74
  75                 if(inv_roundcnt >= inv_maxrounds)
  76                 {
  77                         NextLevel();
  78                         return 1;
  79                 }
  80
  81                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_ROUND_OVER);
  82                 Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_ROUND_OVER);
  83                 round_handler_Init(5, autocvar_g_invasion_warmup, autocvar_g_invasion_round_timelimit);
  84                 return 1;
  85         }
  86
  87         float total_alive_monsters = 0, supermonster_count = 0;
  88
  89         FOR_EACH_MONSTER(head) if(head.health > 0)
  90         {
  91                 if((get_monsterinfo(head.monsterid)).spawnflags & MON_FLAG_SUPERMONSTER)
  92                         ++supermonster_count;
  93                 ++total_alive_monsters;
  94         }
  95
  96         if((total_alive_monsters + inv_numkilled) < inv_maxspawned && inv_maxcurrent < 10) // 10 at a time should be plenty
  97         {
  98                 if(time >= inv_lastcheck)
  99                 {
 100                         invasion_SpawnMonsters(supermonster_count);
 101                         inv_lastcheck = time + autocvar_g_invasion_spawn_delay;
 102                 }
 103
 104                 return 0;
 105         }
 106
 107         if(inv_numspawned < 1 || inv_numkilled < inv_maxspawned)
 108                 return 0; // nothing has spawned yet, or there are still alive monsters
 109
 110         if(inv_roundcnt >= inv_maxrounds)
 111         {
 112                 NextLevel();
 113                 return 1;
 114         }
 115
 116         entity winner = world;
 117         float winning_score = 0;
 118
 119         FOR_EACH_PLAYER(head)
 120         {
 121                 float cs = PlayerScore_Add(head, SP_KILLS, 0);
 122                 if(cs > winning_score)
 123                 {
 124                         winning_score = cs;
 125                         winner = head;
 126                 }
 127         }
 128
 129         FOR_EACH_MONSTER(head)
 130                 monster_remove(head);
 131
 132         if(winner)
 133         {
 134                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_ROUND_PLAYER_WIN, winner.netname);
 135                 Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_ROUND_PLAYER_WIN, winner.netname);
 136         }
 137
 138         round_handler_Init(5, autocvar_g_invasion_warmup, autocvar_g_invasion_round_timelimit);
 139
 140         return 1;
 141 }
 142
 143 float Invasion_CheckPlayers()
 144 {
 145         return TRUE;
 146 }
 147
 148 void Invasion_RoundStart()
 149 {
 150         entity e;
 151         float numplayers = 0;
 152         FOR_EACH_PLAYER(e)
 153         {
 154                 e.player_blocked = 0;
 155                 ++numplayers;
 156         }
 157
 158         inv_roundcnt += 1;
 159
 160         inv_monsterskill = inv_roundcnt + (numplayers * 0.3);
 161
 162         inv_maxcurrent = 0;
 163         inv_numspawned = 0;
 164         inv_numkilled = 0;
 165
 166         inv_maxspawned = rint(min(autocvar_g_invasion_monster_count, autocvar_g_invasion_monster_count * (inv_roundcnt * 0.5)));
 167 }
 168
 169 MUTATOR_HOOKFUNCTION(invasion_MonsterDies)
 170 {
 171         if(!(self.spawnflags & MONSTERFLAG_RESPAWNED))
 172         {
 173                 inv_numkilled += 1;
 174                 inv_maxcurrent -= 1;
 175
 176                 if(IS_PLAYER(frag_attacker))
 177                         PlayerScore_Add(frag_attacker, SP_KILLS, +1);
 178         }
 179
 180         return FALSE;
 181 }
 182
 183 MUTATOR_HOOKFUNCTION(invasion_MonsterSpawn)
 184 {
 185         if(!(self.spawnflags & MONSTERFLAG_SPAWNED))
 186         {
 187                 monster_remove(self);
 188                 return FALSE;
 189         }
 190
 191         if(!(self.spawnflags & MONSTERFLAG_RESPAWNED))
 192         {
 193                 inv_numspawned += 1;
 194                 inv_maxcurrent += 1;
 195         }
 196
 197         self.monster_skill = inv_monsterskill;
 198
 199         if((get_monsterinfo(self.monsterid)).spawnflags & MON_FLAG_SUPERMONSTER)
 200                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_INVASION_SUPERMONSTER, M_NAME(self.monsterid));
 201
 202         self.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_BOTCLIP | DPCONTENTS_MONSTERCLIP;
 203
 204         return FALSE;
 205 }
 206
 207 MUTATOR_HOOKFUNCTION(invasion_PlayerThink)
 208 {
 209         monsters_total = inv_maxspawned; // TODO: make sure numspawned never exceeds maxspawned
 210         monsters_killed = inv_numkilled;
 211
 212         return FALSE;
 213 }
 214
 215 MUTATOR_HOOKFUNCTION(invasion_PlayerRegen)
 216 {
 217         // no regeneration in invasion
 218         return TRUE;
 219 }
 220
 221 MUTATOR_HOOKFUNCTION(invasion_PlayerSpawn)
 222 {
 223         self.bot_attack = FALSE;
 224         return FALSE;
 225 }
 226
 227 MUTATOR_HOOKFUNCTION(invasion_PlayerDamage)
 228 {
 229         if(IS_PLAYER(frag_attacker) && IS_PLAYER(frag_target) && frag_attacker != frag_target)
 230         {
 231                 frag_damage = 0;
 232                 frag_force = '0 0 0';
 233         }
 234
 235         return FALSE;
 236 }
 237
 238 MUTATOR_HOOKFUNCTION(invasion_PlayerCommand)
 239 {
 240         if(MUTATOR_RETURNVALUE) // command was already handled?
 241                 return FALSE;
 242
 243         if(cmd_name == "debuginvasion")
 244         {
 245                 sprint(self, strcat("inv_maxspawned = ", ftos(inv_maxspawned), "\n"));
 246                 sprint(self, strcat("inv_numspawned = ", ftos(inv_numspawned), "\n"));
 247                 sprint(self, strcat("inv_numkilled = ", ftos(inv_numkilled), "\n"));
 248                 sprint(self, strcat("inv_roundcnt = ", ftos(inv_roundcnt), "\n"));
 249                 sprint(self, strcat("monsters_total = ", ftos(monsters_total), "\n"));
 250                 sprint(self, strcat("monsters_killed = ", ftos(monsters_killed), "\n"));
 251                 sprint(self, strcat("inv_monsterskill = ", ftos(inv_monsterskill), "\n"));
 252
 253                 return TRUE;
 254         }
 255
 256         return FALSE;
 257 }
 258
 259 MUTATOR_HOOKFUNCTION(invasion_SetStartItems)
 260 {
 261         start_health = 200;
 262         start_armorvalue = 200;
 263
 264         return FALSE;
 265 }
 266
 267 MUTATOR_HOOKFUNCTION(invasion_AccuracyTargetValid)
 268 {
 269         if(frag_target.flags & FL_MONSTER)
 270                 return MUT_ACCADD_INVALID;
 271         return MUT_ACCADD_INDIFFERENT;
 272 }
 273
 274 MUTATOR_HOOKFUNCTION(invasion_AllowMobSpawning)
 275 {
 276         // monster spawning disabled during an invasion
 277         return TRUE;
 278 }
 279
 280 void invasion_ScoreRules()
 281 {
 282         ScoreRules_basics(0, 0, 0, FALSE);
 283         ScoreInfo_SetLabel_PlayerScore(SP_KILLS, "frags", SFL_SORT_PRIO_PRIMARY);
 284         ScoreRules_basics_end();
 285 }
 286
 287 void invasion_Initialize()
 288 {
 289         independent_players = 1; // to disable extra useless scores
 290
 291         invasion_ScoreRules();
 292
 293         independent_players = 0;
 294
 295         round_handler_Spawn(Invasion_CheckPlayers, Invasion_CheckWinner, Invasion_RoundStart);
 296         round_handler_Init(5, autocvar_g_invasion_warmup, autocvar_g_invasion_round_timelimit);
 297
 298         allowed_to_spawn = TRUE;
 299
 300         inv_roundcnt = 0;
 301 }
 302
 303 MUTATOR_DEFINITION(gamemode_invasion)
 304 {
 305         MUTATOR_HOOK(MonsterDies, invasion_MonsterDies, CBC_ORDER_ANY);
 306         MUTATOR_HOOK(MonsterSpawn, invasion_MonsterSpawn, CBC_ORDER_ANY);
 307         MUTATOR_HOOK(PlayerPreThink, invasion_PlayerThink, CBC_ORDER_ANY);
 308         MUTATOR_HOOK(PlayerRegen, invasion_PlayerRegen, CBC_ORDER_ANY);
 309         MUTATOR_HOOK(PlayerSpawn, invasion_PlayerSpawn, CBC_ORDER_ANY);
 310         MUTATOR_HOOK(PlayerDamage_Calculate, invasion_PlayerDamage, CBC_ORDER_ANY);
 311         MUTATOR_HOOK(SV_ParseClientCommand, invasion_PlayerCommand, CBC_ORDER_ANY);
 312         MUTATOR_HOOK(SetStartItems, invasion_SetStartItems, CBC_ORDER_ANY);
 313         MUTATOR_HOOK(AccuracyTargetValid, invasion_AccuracyTargetValid, CBC_ORDER_ANY);
 314         MUTATOR_HOOK(AllowMobSpawning, invasion_AllowMobSpawning, CBC_ORDER_ANY);
 315
 316         MUTATOR_ONADD
 317         {
 318                 if(time > 1) // game loads at time 1
 319                         error("This is a game type and it cannot be added at runtime.");
 320                 invasion_Initialize();
 321
 322                 cvar_settemp("g_monsters", "1");
 323         }
 324
 325         MUTATOR_ONROLLBACK_OR_REMOVE
 326         {
 327                 // we actually cannot roll back invasion_Initialize here
 328                 // BUT: we don't need to! If this gets called, adding always
 329                 // succeeds.
 330         }
 331
 332         MUTATOR_ONREMOVE
 333         {
 334                 print("This is a game type and it cannot be removed at runtime.");
 335                 return -1;
 336         }
 337
 338         return 0;
 339 }