qcsrc/server/mutators/mutator/gamemode_assault.qc

   1 #ifndef GAMEMODE_ASSAULT_H
   2 #define GAMEMODE_ASSAULT_H
   3
   4 void assault_ScoreRules();
   5
   6 REGISTER_MUTATOR(as, false)
   7 {
   8         ActivateTeamplay();
   9         have_team_spawns = -1; // request team spawns
  10
  11         MUTATOR_ONADD
  12         {
  13                 if (time > 1) // game loads at time 1
  14                         error("This is a game type and it cannot be added at runtime.");
  15                 assault_ScoreRules();
  16         }
  17
  18         MUTATOR_ONROLLBACK_OR_REMOVE
  19         {
  20                 // we actually cannot roll back assault_Initialize here
  21                 // BUT: we don't need to! If this gets called, adding always
  22                 // succeeds.
  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 // sprites
  35 .entity assault_decreaser;
  36 .entity assault_sprite;
  37
  38 // legacy bot defs
  39 const int HAVOCBOT_AST_ROLE_NONE = 0;
  40 const int HAVOCBOT_AST_ROLE_DEFENSE = 2;
  41 const int HAVOCBOT_AST_ROLE_OFFENSE = 4;
  42
  43 .int havocbot_role_flags;
  44 .float havocbot_attack_time;
  45
  46 .void() havocbot_role;
  47 .void() havocbot_previous_role;
  48
  49 void() havocbot_role_ast_defense;
  50 void() havocbot_role_ast_offense;
  51 .entity havocbot_ast_target;
  52
  53 void(entity bot) havocbot_ast_reset_role;
  54
  55 void(float ratingscale, vector org, float sradius) havocbot_goalrating_items;
  56 void(float ratingscale, vector org, float sradius) havocbot_goalrating_enemyplayers;
  57
  58 // scoreboard stuff
  59 const float ST_ASSAULT_OBJECTIVES = 1;
  60 const float SP_ASSAULT_OBJECTIVES = 4;
  61
  62 // predefined spawnfuncs
  63 void target_objective_decrease_activate();
  64 #endif
  65
  66 #ifdef IMPLEMENTATION
  67 .entity sprite;
  68
  69 // random functions
  70 void assault_objective_use()
  71 {SELFPARAM();
  72         // activate objective
  73         self.health = 100;
  74         //print("^2Activated objective ", self.targetname, "=", etos(self), "\n");
  75         //print("Activator is ", activator.classname, "\n");
  76
  77         for (entity e = world; (e = find(e, target, this.targetname)); )
  78         {
  79                 if (e.classname == "target_objective_decrease")
  80                 {
  81                         WITH(entity, self, e, target_objective_decrease_activate());
  82                 }
  83         }
  84
  85         setself(this);
  86 }
  87
  88 vector target_objective_spawn_evalfunc(entity player, entity spot, vector current)
  89 {SELFPARAM();
  90         if(self.health < 0 || self.health >= ASSAULT_VALUE_INACTIVE)
  91                 return '-1 0 0';
  92         return current;
  93 }
  94
  95 // reset this objective. Used when spawning an objective
  96 // and when a new round starts
  97 void assault_objective_reset(entity this)
  98 {
  99         this.health = ASSAULT_VALUE_INACTIVE;
 100 }
 101
 102 // decrease the health of targeted objectives
 103 void assault_objective_decrease_use()
 104 {SELFPARAM();
 105         if(activator.team != assault_attacker_team)
 106         {
 107                 // wrong team triggered decrease
 108                 return;
 109         }
 110
 111         if(other.assault_sprite)
 112         {
 113                 WaypointSprite_Disown(other.assault_sprite, waypointsprite_deadlifetime);
 114                 if(other.classname == "func_assault_destructible")
 115                         other.sprite = world;
 116         }
 117         else
 118                 return; // already activated! cannot activate again!
 119
 120         if(self.enemy.health < ASSAULT_VALUE_INACTIVE)
 121         {
 122                 if(self.enemy.health - self.dmg > 0.5)
 123                 {
 124                         PlayerTeamScore_Add(activator, SP_SCORE, ST_SCORE, self.dmg);
 125                         self.enemy.health = self.enemy.health - self.dmg;
 126                 }
 127                 else
 128                 {
 129                         PlayerTeamScore_Add(activator, SP_SCORE, ST_SCORE, self.enemy.health);
 130                         PlayerTeamScore_Add(activator, SP_ASSAULT_OBJECTIVES, ST_ASSAULT_OBJECTIVES, 1);
 131                         self.enemy.health = -1;
 132
 133                         entity oldactivator;
 134
 135                         setself(this.enemy);
 136                         if(self.message)
 137                                 FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(centerprint(it, self.message)));
 138
 139                         oldactivator = activator;
 140                         activator = this;
 141                         SUB_UseTargets();
 142                         activator = oldactivator;
 143                         setself(this);
 144                 }
 145         }
 146 }
 147
 148 void assault_setenemytoobjective()
 149 {SELFPARAM();
 150         entity objective;
 151         for(objective = world; (objective = find(objective, targetname, self.target)); )
 152         {
 153                 if(objective.classname == "target_objective")
 154                 {
 155                         if(self.enemy == world)
 156                                 self.enemy = objective;
 157                         else
 158                                 objerror("more than one objective as target - fix the map!");
 159                         break;
 160                 }
 161         }
 162
 163         if(self.enemy == world)
 164                 objerror("no objective as target - fix the map!");
 165 }
 166
 167 float assault_decreaser_sprite_visible(entity e)
 168 {SELFPARAM();
 169         entity decreaser;
 170
 171         decreaser = self.assault_decreaser;
 172
 173         if(decreaser.enemy.health >= ASSAULT_VALUE_INACTIVE)
 174                 return false;
 175
 176         return true;
 177 }
 178
 179 void target_objective_decrease_activate()
 180 {SELFPARAM();
 181         entity ent, spr;
 182         self.owner = world;
 183         for(ent = world; (ent = find(ent, target, self.targetname)); )
 184         {
 185                 if(ent.assault_sprite != world)
 186                 {
 187                         WaypointSprite_Disown(ent.assault_sprite, waypointsprite_deadlifetime);
 188                         if(ent.classname == "func_assault_destructible")
 189                                 ent.sprite = world;
 190                 }
 191
 192                 spr = WaypointSprite_SpawnFixed(WP_Assault, 0.5 * (ent.absmin + ent.absmax), ent, assault_sprite, RADARICON_OBJECTIVE);
 193                 spr.assault_decreaser = self;
 194                 spr.waypointsprite_visible_for_player = assault_decreaser_sprite_visible;
 195                 spr.classname = "sprite_waypoint";
 196                 WaypointSprite_UpdateRule(spr, assault_attacker_team, SPRITERULE_TEAMPLAY);
 197                 if(ent.classname == "func_assault_destructible")
 198                 {
 199                         WaypointSprite_UpdateSprites(spr, WP_AssaultDefend, WP_AssaultDestroy, WP_AssaultDestroy);
 200                         WaypointSprite_UpdateMaxHealth(spr, ent.max_health);
 201                         WaypointSprite_UpdateHealth(spr, ent.health);
 202                         ent.sprite = spr;
 203                 }
 204                 else
 205                         WaypointSprite_UpdateSprites(spr, WP_AssaultDefend, WP_AssaultPush, WP_AssaultPush);
 206         }
 207 }
 208
 209 void target_objective_decrease_findtarget()
 210 {
 211         assault_setenemytoobjective();
 212 }
 213
 214 void target_assault_roundend_reset(entity this)
 215 {
 216         //print("round end reset\n");
 217         ++this.cnt; // up round counter
 218         this.winning = false; // up round
 219 }
 220
 221 void target_assault_roundend_use()
 222 {SELFPARAM();
 223         self.winning = 1; // round has been won by attackers
 224 }
 225
 226 void assault_roundstart_use()
 227 {SELFPARAM();
 228         activator = self;
 229         SUB_UseTargets();
 230
 231         //(Re)spawn all turrets
 232         for(entity ent = NULL; (ent = find(ent, classname, "turret_main")); ) {
 233                 // Swap turret teams
 234                 if(ent.team == NUM_TEAM_1)
 235                         ent.team = NUM_TEAM_2;
 236                 else
 237                         ent.team = NUM_TEAM_1;
 238
 239                 // Dubbles as teamchange
 240                 WITH(entity, self, ent, turret_respawn());
 241         }
 242 }
 243
 244 void assault_wall_think()
 245 {SELFPARAM();
 246         if(self.enemy.health < 0)
 247         {
 248                 self.model = "";
 249                 self.solid = SOLID_NOT;
 250         }
 251         else
 252         {
 253                 self.model = self.mdl;
 254                 self.solid = SOLID_BSP;
 255         }
 256
 257         self.nextthink = time + 0.2;
 258 }
 259
 260 // trigger new round
 261 // reset objectives, toggle spawnpoints, reset triggers, ...
 262 void vehicles_clearreturn(entity veh);
 263 void vehicles_spawn();
 264 void assault_new_round()
 265 {SELFPARAM();
 266         //bprint("ASSAULT: new round\n");
 267
 268         // Eject players from vehicles
 269     FOREACH_CLIENT(IS_PLAYER(it) && it.vehicle, LAMBDA(WITH(entity, self, it, vehicles_exit(VHEF_RELEASE))));
 270
 271     FOREACH_ENTITY_FLAGS(vehicle_flags, VHF_ISVEHICLE, LAMBDA(
 272         setself(it);
 273         vehicles_clearreturn(self);
 274         vehicles_spawn();
 275     ));
 276
 277     setself(this);
 278
 279         // up round counter
 280         self.winning = self.winning + 1;
 281
 282         // swap attacker/defender roles
 283         if(assault_attacker_team == NUM_TEAM_1)
 284                 assault_attacker_team = NUM_TEAM_2;
 285         else
 286                 assault_attacker_team = NUM_TEAM_1;
 287
 288         FOREACH_ENTITY(IS_NOT_A_CLIENT(it), LAMBDA(
 289                 if (it.team_saved == NUM_TEAM_1) it.team_saved = NUM_TEAM_2;
 290                 else if (it.team_saved == NUM_TEAM_2) it.team_saved = NUM_TEAM_1;
 291         ));
 292
 293         // reset the level with a countdown
 294         cvar_set("timelimit", ftos(ceil(time - game_starttime) / 60));
 295         ReadyRestart_force(); // sets game_starttime
 296 }
 297
 298 // spawnfuncs
 299 spawnfunc(info_player_attacker)
 300 {
 301         if (!g_assault) { remove(self); return; }
 302
 303         self.team = NUM_TEAM_1; // red, gets swapped every round
 304         spawnfunc_info_player_deathmatch(this);
 305 }
 306
 307 spawnfunc(info_player_defender)
 308 {
 309         if (!g_assault) { remove(self); return; }
 310
 311         self.team = NUM_TEAM_2; // blue, gets swapped every round
 312         spawnfunc_info_player_deathmatch(this);
 313 }
 314
 315 spawnfunc(target_objective)
 316 {
 317         if (!g_assault) { remove(this); return; }
 318
 319         this.classname = "target_objective";
 320         this.use = assault_objective_use;
 321         this.reset = assault_objective_reset;
 322         this.reset(this);
 323         this.spawn_evalfunc = target_objective_spawn_evalfunc;
 324 }
 325
 326 spawnfunc(target_objective_decrease)
 327 {
 328         if (!g_assault) { remove(self); return; }
 329
 330         self.classname = "target_objective_decrease";
 331
 332         if(!self.dmg)
 333                 self.dmg = 101;
 334
 335         self.use = assault_objective_decrease_use;
 336         self.health = ASSAULT_VALUE_INACTIVE;
 337         self.max_health = ASSAULT_VALUE_INACTIVE;
 338         self.enemy = world;
 339
 340         InitializeEntity(self, target_objective_decrease_findtarget, INITPRIO_FINDTARGET);
 341 }
 342
 343 // destructible walls that can be used to trigger target_objective_decrease
 344 spawnfunc(func_breakable);
 345 spawnfunc(func_assault_destructible)
 346 {
 347         if (!g_assault) { remove(self); return; }
 348
 349         self.spawnflags = 3;
 350         self.classname = "func_assault_destructible";
 351
 352         if(assault_attacker_team == NUM_TEAM_1)
 353                 self.team = NUM_TEAM_2;
 354         else
 355                 self.team = NUM_TEAM_1;
 356
 357         spawnfunc_func_breakable(this);
 358 }
 359
 360 spawnfunc(func_assault_wall)
 361 {
 362         if (!g_assault) { remove(self); return; }
 363
 364         self.classname = "func_assault_wall";
 365         self.mdl = self.model;
 366         _setmodel(self, self.mdl);
 367         self.solid = SOLID_BSP;
 368         self.think = assault_wall_think;
 369         self.nextthink = time;
 370         InitializeEntity(self, assault_setenemytoobjective, INITPRIO_FINDTARGET);
 371 }
 372
 373 spawnfunc(target_assault_roundend)
 374 {
 375         if (!g_assault) { remove(self); return; }
 376
 377         self.winning = 0; // round not yet won by attackers
 378         self.classname = "target_assault_roundend";
 379         self.use = target_assault_roundend_use;
 380         self.cnt = 0; // first round
 381         self.reset = target_assault_roundend_reset;
 382 }
 383
 384 spawnfunc(target_assault_roundstart)
 385 {
 386         if (!g_assault) { remove(self); return; }
 387
 388         assault_attacker_team = NUM_TEAM_1;
 389         self.classname = "target_assault_roundstart";
 390         self.use = assault_roundstart_use;
 391         self.reset2 = assault_roundstart_use;
 392         InitializeEntity(self, assault_roundstart_use, INITPRIO_FINDTARGET);
 393 }
 394
 395 // legacy bot code
 396 void havocbot_goalrating_ast_targets(float ratingscale)
 397 {SELFPARAM();
 398         entity ad, best, wp, tod;
 399         float radius, found, bestvalue;
 400         vector p;
 401
 402         ad = findchain(classname, "func_assault_destructible");
 403
 404         for (; ad; ad = ad.chain)
 405         {
 406                 if (ad.target == "")
 407                         continue;
 408
 409                 if (!ad.bot_attack)
 410                         continue;
 411
 412                 found = false;
 413                 for(tod = world; (tod = find(tod, targetname, ad.target)); )
 414                 {
 415                         if(tod.classname == "target_objective_decrease")
 416                         {
 417                                 if(tod.enemy.health > 0 && tod.enemy.health < ASSAULT_VALUE_INACTIVE)
 418                                 {
 419                                 //      dprint(etos(ad),"\n");
 420                                         found = true;
 421                                         break;
 422                                 }
 423                         }
 424                 }
 425
 426                 if(!found)
 427                 {
 428                 ///     dprint("target not found\n");
 429                         continue;
 430                 }
 431                 /// dprint("target #", etos(ad), " found\n");
 432
 433
 434                 p = 0.5 * (ad.absmin + ad.absmax);
 435         //      dprint(vtos(ad.origin), " ", vtos(ad.absmin), " ", vtos(ad.absmax),"\n");
 436         //      te_knightspike(p);
 437         //      te_lightning2(world, '0 0 0', p);
 438
 439                 // Find and rate waypoints around it
 440                 found = false;
 441                 best = world;
 442                 bestvalue = 99999999999;
 443                 for(radius=0; radius<1500 && !found; radius+=500)
 444                 {
 445                         for(wp=findradius(p, radius); wp; wp=wp.chain)
 446                         {
 447                                 if(!(wp.wpflags & WAYPOINTFLAG_GENERATED))
 448                                 if(wp.classname=="waypoint")
 449                                 if(checkpvs(wp.origin, ad))
 450                                 {
 451                                         found = true;
 452                                         if(wp.cnt<bestvalue)
 453                                         {
 454                                                 best = wp;
 455                                                 bestvalue = wp.cnt;
 456                                         }
 457                                 }
 458                         }
 459                 }
 460
 461                 if(best)
 462                 {
 463                 ///     dprint("waypoints around target were found\n");
 464                 //      te_lightning2(world, '0 0 0', best.origin);
 465                 //      te_knightspike(best.origin);
 466
 467                         navigation_routerating(best, ratingscale, 4000);
 468                         best.cnt += 1;
 469
 470                         self.havocbot_attack_time = 0;
 471
 472                         if(checkpvs(self.view_ofs,ad))
 473                         if(checkpvs(self.view_ofs,best))
 474                         {
 475                         //      dprint("increasing attack time for this target\n");
 476                                 self.havocbot_attack_time = time + 2;
 477                         }
 478                 }
 479         }
 480 }
 481
 482 void havocbot_role_ast_offense()
 483 {SELFPARAM();
 484         if(self.deadflag != DEAD_NO)
 485         {
 486                 self.havocbot_attack_time = 0;
 487                 havocbot_ast_reset_role(self);
 488                 return;
 489         }
 490
 491         // Set the role timeout if necessary
 492         if (!self.havocbot_role_timeout)
 493                 self.havocbot_role_timeout = time + 120;
 494
 495         if (time > self.havocbot_role_timeout)
 496         {
 497                 havocbot_ast_reset_role(self);
 498                 return;
 499         }
 500
 501         if(self.havocbot_attack_time>time)
 502                 return;
 503
 504         if (self.bot_strategytime < time)
 505         {
 506                 navigation_goalrating_start();
 507                 havocbot_goalrating_enemyplayers(20000, self.origin, 650);
 508                 havocbot_goalrating_ast_targets(20000);
 509                 havocbot_goalrating_items(15000, self.origin, 10000);
 510                 navigation_goalrating_end();
 511
 512                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
 513         }
 514 }
 515
 516 void havocbot_role_ast_defense()
 517 {SELFPARAM();
 518         if(self.deadflag != DEAD_NO)
 519         {
 520                 self.havocbot_attack_time = 0;
 521                 havocbot_ast_reset_role(self);
 522                 return;
 523         }
 524
 525         // Set the role timeout if necessary
 526         if (!self.havocbot_role_timeout)
 527                 self.havocbot_role_timeout = time + 120;
 528
 529         if (time > self.havocbot_role_timeout)
 530         {
 531                 havocbot_ast_reset_role(self);
 532                 return;
 533         }
 534
 535         if(self.havocbot_attack_time>time)
 536                 return;
 537
 538         if (self.bot_strategytime < time)
 539         {
 540                 navigation_goalrating_start();
 541                 havocbot_goalrating_enemyplayers(20000, self.origin, 3000);
 542                 havocbot_goalrating_ast_targets(20000);
 543                 havocbot_goalrating_items(15000, self.origin, 10000);
 544                 navigation_goalrating_end();
 545
 546                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
 547         }
 548 }
 549
 550 void havocbot_role_ast_setrole(entity bot, float role)
 551 {
 552         switch(role)
 553         {
 554                 case HAVOCBOT_AST_ROLE_DEFENSE:
 555                         bot.havocbot_role = havocbot_role_ast_defense;
 556                         bot.havocbot_role_flags = HAVOCBOT_AST_ROLE_DEFENSE;
 557                         bot.havocbot_role_timeout = 0;
 558                         break;
 559                 case HAVOCBOT_AST_ROLE_OFFENSE:
 560                         bot.havocbot_role = havocbot_role_ast_offense;
 561                         bot.havocbot_role_flags = HAVOCBOT_AST_ROLE_OFFENSE;
 562                         bot.havocbot_role_timeout = 0;
 563                         break;
 564         }
 565 }
 566
 567 void havocbot_ast_reset_role(entity bot)
 568 {SELFPARAM();
 569         if(self.deadflag != DEAD_NO)
 570                 return;
 571
 572         if(bot.team == assault_attacker_team)
 573                 havocbot_role_ast_setrole(bot, HAVOCBOT_AST_ROLE_OFFENSE);
 574         else
 575                 havocbot_role_ast_setrole(bot, HAVOCBOT_AST_ROLE_DEFENSE);
 576 }
 577
 578 // mutator hooks
 579 MUTATOR_HOOKFUNCTION(as, PlayerSpawn)
 580 {SELFPARAM();
 581         if(self.team == assault_attacker_team)
 582                 Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_ASSAULT_ATTACKING);
 583         else
 584                 Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_ASSAULT_DEFENDING);
 585
 586         return false;
 587 }
 588
 589 MUTATOR_HOOKFUNCTION(as, TurretSpawn)
 590 {SELFPARAM();
 591         if(!self.team || self.team == MAX_SHOT_DISTANCE)
 592                 self.team = 5; // this gets reversed when match starts?
 593
 594         return false;
 595 }
 596
 597 MUTATOR_HOOKFUNCTION(as, VehicleSpawn)
 598 {SELFPARAM();
 599         self.nextthink = time + 0.5;
 600
 601         return false;
 602 }
 603
 604 MUTATOR_HOOKFUNCTION(as, HavocBot_ChooseRole)
 605 {SELFPARAM();
 606         havocbot_ast_reset_role(self);
 607         return true;
 608 }
 609
 610 MUTATOR_HOOKFUNCTION(as, PlayHitsound)
 611 {
 612         return (frag_victim.classname == "func_assault_destructible");
 613 }
 614
 615 MUTATOR_HOOKFUNCTION(as, GetTeamCount)
 616 {
 617         // assault always has 2 teams
 618         c1 = c2 = 0;
 619         return true;
 620 }
 621
 622 MUTATOR_HOOKFUNCTION(as, CheckRules_World)
 623 {
 624         ret_float = WinningCondition_Assault();
 625         return true;
 626 }
 627
 628 MUTATOR_HOOKFUNCTION(as, ReadLevelCvars)
 629 {
 630         // no assault warmups
 631         warmup_stage = 0;
 632         return false;
 633 }
 634
 635 MUTATOR_HOOKFUNCTION(as, OnEntityPreSpawn)
 636 {
 637         switch(self.classname)
 638         {
 639                 case "info_player_team1":
 640                 case "info_player_team2":
 641                 case "info_player_team3":
 642                 case "info_player_team4":
 643                         return true;
 644         }
 645
 646         return false;
 647 }
 648
 649 // scoreboard setup
 650 void assault_ScoreRules()
 651 {
 652         ScoreRules_basics(2, SFL_SORT_PRIO_SECONDARY, SFL_SORT_PRIO_SECONDARY, true);
 653         ScoreInfo_SetLabel_TeamScore(  ST_ASSAULT_OBJECTIVES,    "objectives",      SFL_SORT_PRIO_PRIMARY);
 654         ScoreInfo_SetLabel_PlayerScore(SP_ASSAULT_OBJECTIVES,    "objectives",      SFL_SORT_PRIO_PRIMARY);
 655         ScoreRules_basics_end();
 656 }
 657
 658 #endif