Merge branch 'master' into terencehill/bot_ai
[xonotic/xonotic-data.pk3dir.git] / 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         SetResourceAmountExplicit(this, RESOURCE_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(GetResourceAmount(this, RESOURCE_HEALTH) < 0 || GetResourceAmount(this, RESOURCE_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         SetResourceAmountExplicit(this, RESOURCE_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(GetResourceAmount(this.enemy, RESOURCE_HEALTH) < ASSAULT_VALUE_INACTIVE)
65         {
66                 if(GetResourceAmount(this.enemy, RESOURCE_HEALTH) - this.dmg > 0.5)
67                 {
68                         GameRules_scoring_add_team(actor, SCORE, this.dmg);
69                         TakeResource(this.enemy, RESOURCE_HEALTH, this.dmg);
70                 }
71                 else
72                 {
73                         GameRules_scoring_add_team(actor, SCORE, GetResourceAmount(this.enemy, RESOURCE_HEALTH));
74                         GameRules_scoring_add_team(actor, ASSAULT_OBJECTIVES, 1);
75                         SetResourceAmountExplicit(this.enemy, RESOURCE_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(GetResourceAmount(this.assault_decreaser.enemy, RESOURCE_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, GetResourceAmount(it, RESOURCE_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(GetResourceAmount(this.enemy, RESOURCE_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         SetResourceAmountExplicit(this, RESOURCE_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 bool destructible_heal(entity targ, entity inflictor, float amount, float limit)
335 {
336         float true_limit = ((limit != RESOURCE_LIMIT_NONE) ? limit : targ.max_health);
337         if(GetResourceAmount(targ, RESOURCE_HEALTH) <= 0 || GetResourceAmount(targ, RESOURCE_HEALTH) >= true_limit)
338                 return false;
339
340         GiveResourceWithLimit(targ, RESOURCE_HEALTH, amount, true_limit);
341         if(targ.sprite)
342         {
343                 WaypointSprite_UpdateHealth(targ.sprite, GetResourceAmount(targ, RESOURCE_HEALTH));
344         }
345         func_breakable_colormod(targ);
346         return true;
347 }
348
349 spawnfunc(func_breakable);
350 spawnfunc(func_assault_destructible)
351 {
352         if (!g_assault) { delete(this); return; }
353
354         this.spawnflags = 3;
355         this.classname = "func_assault_destructible";
356         this.event_heal = destructible_heal;
357         IL_PUSH(g_assault_destructibles, this);
358
359         if(assault_attacker_team == NUM_TEAM_1)
360                 this.team = NUM_TEAM_2;
361         else
362                 this.team = NUM_TEAM_1;
363
364         spawnfunc_func_breakable(this);
365 }
366
367 spawnfunc(func_assault_wall)
368 {
369         if (!g_assault) { delete(this); return; }
370
371         this.classname = "func_assault_wall";
372         this.mdl = this.model;
373         _setmodel(this, this.mdl);
374         this.solid = SOLID_BSP;
375         setthink(this, assault_wall_think);
376         this.nextthink = time;
377         InitializeEntity(this, assault_setenemytoobjective, INITPRIO_FINDTARGET);
378 }
379
380 spawnfunc(target_assault_roundend)
381 {
382         if (!g_assault) { delete(this); return; }
383
384         this.winning = 0; // round not yet won by attackers
385         this.classname = "target_assault_roundend";
386         this.use = target_assault_roundend_use;
387         this.cnt = 0; // first round
388         this.reset = target_assault_roundend_reset;
389 }
390
391 spawnfunc(target_assault_roundstart)
392 {
393         if (!g_assault) { delete(this); return; }
394
395         assault_attacker_team = NUM_TEAM_1;
396         this.classname = "target_assault_roundstart";
397         this.use = assault_roundstart_use;
398         this.reset2 = assault_roundstart_use_this;
399         InitializeEntity(this, assault_roundstart_use_this, INITPRIO_FINDTARGET);
400 }
401
402 // legacy bot code
403 void havocbot_goalrating_ast_targets(entity this, float ratingscale)
404 {
405         IL_EACH(g_assault_destructibles, it.bot_attack,
406         {
407                 if (it.target == "")
408                         continue;
409
410                 bool found = false;
411                 entity destr = it;
412                 IL_EACH(g_assault_objectivedecreasers, it.targetname == destr.target,
413                 {
414                         if(GetResourceAmount(it.enemy, RESOURCE_HEALTH) > 0 && GetResourceAmount(it.enemy, RESOURCE_HEALTH) < ASSAULT_VALUE_INACTIVE)
415                         {
416                                 found = true;
417                                 break;
418                         }
419                 });
420
421                 if(!found)
422                         continue;
423
424                 vector p = 0.5 * (it.absmin + it.absmax);
425
426                 // Find and rate waypoints around it
427                 found = false;
428                 entity best = NULL;
429                 float bestvalue = 99999999999;
430                 entity des = it;
431                 for(float radius = 0; radius < 1500 && !found; radius += 500)
432                 {
433                         FOREACH_ENTITY_RADIUS(p, radius, it.classname == "waypoint" && !(it.wpflags & WAYPOINTFLAG_GENERATED),
434                         {
435                                 if(checkpvs(it.origin, des))
436                                 {
437                                         found = true;
438                                         if(it.cnt < bestvalue)
439                                         {
440                                                 best = it;
441                                                 bestvalue = it.cnt;
442                                         }
443                                 }
444                         });
445                 }
446
447                 if(best)
448                 {
449                 ///     dprint("waypoints around target were found\n");
450                 //      te_lightning2(NULL, '0 0 0', best.origin);
451                 //      te_knightspike(best.origin);
452
453                         navigation_routerating(this, best, ratingscale, 4000);
454                         best.cnt += 1;
455
456                         this.havocbot_attack_time = 0;
457
458                         if(checkpvs(this.origin + this.view_ofs, it))
459                         if(checkpvs(this.origin + this.view_ofs, best))
460                         {
461                         //      dprint("increasing attack time for this target\n");
462                                 this.havocbot_attack_time = time + 2;
463                         }
464                 }
465         });
466 }
467
468 void havocbot_role_ast_offense(entity this)
469 {
470         if(IS_DEAD(this))
471         {
472                 this.havocbot_attack_time = 0;
473                 havocbot_ast_reset_role(this);
474                 return;
475         }
476
477         // Set the role timeout if necessary
478         if (!this.havocbot_role_timeout)
479                 this.havocbot_role_timeout = time + 120;
480
481         if (time > this.havocbot_role_timeout)
482         {
483                 havocbot_ast_reset_role(this);
484                 return;
485         }
486
487         if(this.havocbot_attack_time>time)
488                 return;
489
490         if (navigation_goalrating_timeout(this))
491         {
492                 navigation_goalrating_start(this);
493                 havocbot_goalrating_enemyplayers(this, 10000, this.origin, 650);
494                 havocbot_goalrating_ast_targets(this, 20000);
495                 havocbot_goalrating_items(this, 15000, this.origin, 10000);
496                 navigation_goalrating_end(this);
497
498                 navigation_goalrating_timeout_set(this);
499         }
500 }
501
502 void havocbot_role_ast_defense(entity this)
503 {
504         if(IS_DEAD(this))
505         {
506                 this.havocbot_attack_time = 0;
507                 havocbot_ast_reset_role(this);
508                 return;
509         }
510
511         // Set the role timeout if necessary
512         if (!this.havocbot_role_timeout)
513                 this.havocbot_role_timeout = time + 120;
514
515         if (time > this.havocbot_role_timeout)
516         {
517                 havocbot_ast_reset_role(this);
518                 return;
519         }
520
521         if(this.havocbot_attack_time>time)
522                 return;
523
524         if (navigation_goalrating_timeout(this))
525         {
526                 navigation_goalrating_start(this);
527                 havocbot_goalrating_enemyplayers(this, 10000, this.origin, 3000);
528                 havocbot_goalrating_ast_targets(this, 20000);
529                 havocbot_goalrating_items(this, 15000, this.origin, 10000);
530                 navigation_goalrating_end(this);
531
532                 navigation_goalrating_timeout_set(this);
533         }
534 }
535
536 void havocbot_role_ast_setrole(entity this, float role)
537 {
538         switch(role)
539         {
540                 case HAVOCBOT_AST_ROLE_DEFENSE:
541                         this.havocbot_role = havocbot_role_ast_defense;
542                         this.havocbot_role_timeout = 0;
543                         break;
544                 case HAVOCBOT_AST_ROLE_OFFENSE:
545                         this.havocbot_role = havocbot_role_ast_offense;
546                         this.havocbot_role_timeout = 0;
547                         break;
548         }
549 }
550
551 void havocbot_ast_reset_role(entity this)
552 {
553         if(IS_DEAD(this))
554                 return;
555
556         if(this.team == assault_attacker_team)
557                 havocbot_role_ast_setrole(this, HAVOCBOT_AST_ROLE_OFFENSE);
558         else
559                 havocbot_role_ast_setrole(this, HAVOCBOT_AST_ROLE_DEFENSE);
560 }
561
562 // mutator hooks
563 MUTATOR_HOOKFUNCTION(as, PlayerSpawn)
564 {
565         entity player = M_ARGV(0, entity);
566
567         if(player.team == assault_attacker_team)
568                 Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_ASSAULT_ATTACKING);
569         else
570                 Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_ASSAULT_DEFENDING);
571 }
572
573 MUTATOR_HOOKFUNCTION(as, TurretSpawn)
574 {
575         entity turret = M_ARGV(0, entity);
576
577         if(!turret.team || turret.team == FLOAT_MAX)
578                 turret.team = 5; // this gets reversed when match starts?
579 }
580
581 MUTATOR_HOOKFUNCTION(as, VehicleInit)
582 {
583         entity veh = M_ARGV(0, entity);
584
585         veh.nextthink = time + 0.5;
586 }
587
588 MUTATOR_HOOKFUNCTION(as, HavocBot_ChooseRole)
589 {
590         entity bot = M_ARGV(0, entity);
591
592         havocbot_ast_reset_role(bot);
593         return true;
594 }
595
596 MUTATOR_HOOKFUNCTION(as, PlayHitsound)
597 {
598         entity frag_victim = M_ARGV(0, entity);
599
600         return (frag_victim.classname == "func_assault_destructible");
601 }
602
603 MUTATOR_HOOKFUNCTION(as, CheckAllowedTeams)
604 {
605         // assault always has 2 teams
606         c1 = c2 = 0;
607         return true;
608 }
609
610 MUTATOR_HOOKFUNCTION(as, CheckRules_World)
611 {
612         M_ARGV(0, float) = WinningCondition_Assault();
613         return true;
614 }
615
616 MUTATOR_HOOKFUNCTION(as, ReadLevelCvars)
617 {
618         // incompatible
619         warmup_stage = 0;
620         sv_ready_restart_after_countdown = 0;
621 }
622
623 MUTATOR_HOOKFUNCTION(as, OnEntityPreSpawn)
624 {
625     entity ent = M_ARGV(0, entity);
626
627         switch(ent.classname)
628         {
629                 case "info_player_team1":
630                 case "info_player_team2":
631                 case "info_player_team3":
632                 case "info_player_team4":
633                         return true;
634         }
635 }
636
637 MUTATOR_HOOKFUNCTION(as, ReadyRestart_Deny)
638 {
639         // readyrestart not supported (yet)
640         return true;
641 }
642 #endif