qcsrc/common/gamemodes/gamemode/assault/assault.qc

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