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