qcsrc/server/mutators/mutator/gamemode_assault.qc

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