Merge remote-tracking branch 'origin/Mario/extralife_fix'
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / mutators / gamemode_keepaway.qc
1 // ===========================================================
2 //  Keepaway game mode coding, written by Samual and Diabolik
3 //  Last updated: September, 2012
4 // ===========================================================
5
6 float ka_ballcarrier_waypointsprite_visible_for_player(entity e) // runs on waypoints which are attached to ballcarriers, updates once per frame 
7 {
8         if(e.ballcarried)
9                 if(IS_SPEC(other)) 
10                         return FALSE; // we don't want spectators of the ballcarrier to see the attached waypoint on the top of their screen
11                 
12         // TODO: Make the ballcarrier lack a waypointsprite whenever they have the invisibility powerup
13
14         return TRUE;
15 }
16
17 void ka_EventLog(string mode, entity actor) // use an alias for easy changing and quick editing later
18 {
19         if(autocvar_sv_eventlog)
20                 GameLogEcho(strcat(":ka:", mode, ((actor != world) ? (strcat(":", ftos(actor.playerid))) : "")));
21 }
22
23 void ka_RespawnBall() // runs whenever the ball needs to be relocated
24 {
25         if(gameover) { return; }
26         vector oldballorigin = self.origin;
27         
28         if(MoveToRandomMapLocation(self, DPCONTENTS_SOLID | DPCONTENTS_CORPSE | DPCONTENTS_PLAYERCLIP, DPCONTENTS_SLIME | DPCONTENTS_LAVA | DPCONTENTS_SKY | DPCONTENTS_BODY | DPCONTENTS_DONOTENTER, Q3SURFACEFLAG_SKY, 10, 1024, 256))
29         {
30                 makevectors(self.angles);
31                 self.movetype = MOVETYPE_BOUNCE;
32                 self.velocity = '0 0 200';
33                 self.angles = '0 0 0';
34                 self.effects = autocvar_g_keepawayball_effects;
35                 self.think = ka_RespawnBall;
36                 self.nextthink = time + autocvar_g_keepawayball_respawntime;
37                 
38                 pointparticles(particleeffectnum("electro_combo"), oldballorigin, '0 0 0', 1);
39                 pointparticles(particleeffectnum("electro_combo"), self.origin, '0 0 0', 1);
40
41                 WaypointSprite_Spawn("ka-ball", 0, 0, self, '0 0 64', world, self.team, self, waypointsprite_attachedforcarrier, FALSE, RADARICON_FLAGCARRIER, '0 1 1');
42                 WaypointSprite_Ping(self.waypointsprite_attachedforcarrier);    
43
44                 sound(self, CH_TRIGGER, "keepaway/respawn.wav", VOL_BASE, ATTN_NONE); // ATTN_NONE (it's a sound intended to be heard anywhere) 
45         }
46         else
47         {
48                 ka_RespawnBall(); // finding a location failed, retry 
49         }
50 }
51
52 void ka_TimeScoring()
53 {
54         if(self.owner.ballcarried)
55         { // add points for holding the ball after a certain amount of time
56                 if(autocvar_g_keepaway_score_timepoints)
57                         PlayerScore_Add(self.owner, SP_SCORE, autocvar_g_keepaway_score_timepoints);
58                         
59                 PlayerScore_Add(self.owner, SP_KEEPAWAY_BCTIME, (autocvar_g_keepaway_score_timeinterval / 1)); // interval is divided by 1 so that time always shows "seconds"
60                 self.nextthink = time + autocvar_g_keepaway_score_timeinterval;
61         }
62 }
63
64 void ka_TouchEvent() // runs any time that the ball comes in contact with something
65 {
66         if(gameover) { return; }
67         if(!self) { return; }
68         if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT)
69         { // The ball fell off the map, respawn it since players can't get to it
70                 ka_RespawnBall();
71                 return;
72         }
73         if(other.deadflag != DEAD_NO) { return; }
74         if not(IS_PLAYER(other)) 
75         {  // The ball just touched an object, most likely the world
76                 pointparticles(particleeffectnum("kaball_sparks"), self.origin, '0 0 0', 1);
77                 sound(self, CH_TRIGGER, "keepaway/touch.wav", VOL_BASE, ATTN_NORM);
78                 return; 
79         }
80         else if(self.wait > time) { return; }
81
82         // attach the ball to the player
83         self.owner = other;
84         other.ballcarried = self;
85         setattachment(self, other, "");
86         setorigin(self, '0 0 0');
87         
88         // make the ball invisible/unable to do anything/set up time scoring
89         self.velocity = '0 0 0';
90         self.movetype = MOVETYPE_NONE;
91         self.effects |= EF_NODRAW;
92         self.touch = func_null;
93         self.think = ka_TimeScoring;
94         self.nextthink = time + autocvar_g_keepaway_score_timeinterval;
95         self.takedamage = DAMAGE_NO;
96
97         // apply effects to player
98         other.glow_color = autocvar_g_keepawayball_trail_color;
99         other.glow_trail = TRUE;
100         other.effects |= autocvar_g_keepaway_ballcarrier_effects;
101         
102         // messages and sounds
103         ka_EventLog("pickup", other);
104         Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_KEEPAWAY_PICKUP, other.netname);
105         Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_KEEPAWAY_PICKUP, other.netname);
106         sound(self.owner, CH_TRIGGER, "keepaway/pickedup.wav", VOL_BASE, ATTN_NONE); // ATTN_NONE (it's a sound intended to be heard anywhere) 
107         
108         // scoring
109         PlayerScore_Add(other, SP_KEEPAWAY_PICKUPS, 1);
110
111         // waypoints
112         WaypointSprite_AttachCarrier("ka-ballcarrier", other, RADARICON_FLAGCARRIER, '1 0 0');
113         other.waypointsprite_attachedforcarrier.waypointsprite_visible_for_player = ka_ballcarrier_waypointsprite_visible_for_player;
114         WaypointSprite_UpdateRule(other.waypointsprite_attachedforcarrier, 0, SPRITERULE_DEFAULT);
115         WaypointSprite_Ping(other.waypointsprite_attachedforcarrier);   
116         WaypointSprite_Kill(self.waypointsprite_attachedforcarrier);
117 }
118
119 void ka_DropEvent(entity plyr) // runs any time that a player is supposed to lose the ball
120 {
121         entity ball;
122         ball = plyr.ballcarried;
123
124         if(!ball) { return; }
125         
126         // reset the ball
127         setattachment(ball, world, "");
128         ball.movetype = MOVETYPE_BOUNCE;
129         ball.wait = time + 1; 
130         ball.touch = ka_TouchEvent;
131         ball.think = ka_RespawnBall;
132         ball.nextthink = time + autocvar_g_keepawayball_respawntime;
133         ball.takedamage = DAMAGE_YES;
134         ball.effects &~= EF_NODRAW; 
135         setorigin(ball, plyr.origin + '0 0 10');
136         ball.velocity = '0 0 200' + '0 100 0'*crandom() + '100 0 0'*crandom();
137         ball.owner.ballcarried = world; // I hope nothing checks to see if the world has the ball in the rest of my code :P 
138         ball.owner = world;
139         
140         // reset the player effects
141         plyr.glow_trail = FALSE;
142         plyr.effects &~= autocvar_g_keepaway_ballcarrier_effects;
143
144         // messages and sounds
145         ka_EventLog("dropped", plyr);
146         Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_KEEPAWAY_DROPPED, plyr.netname);
147         Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_KEEPAWAY_DROPPED, plyr.netname);
148         sound(other, CH_TRIGGER, "keepaway/dropped.wav", VOL_BASE, ATTN_NONE);  // ATTN_NONE (it's a sound intended to be heard anywhere) 
149         
150         // scoring
151         // PlayerScore_Add(plyr, SP_KEEPAWAY_DROPS, 1); Not anymore, this is 100% the same as pickups and is useless.
152         
153         // waypoints
154         WaypointSprite_Spawn("ka-ball", 0, 0, ball, '0 0 64', world, ball.team, ball, waypointsprite_attachedforcarrier, FALSE, RADARICON_FLAGCARRIER, '0 1 1');
155         WaypointSprite_UpdateRule(ball.waypointsprite_attachedforcarrier, 0, SPRITERULE_DEFAULT);
156         WaypointSprite_Ping(ball.waypointsprite_attachedforcarrier);    
157         WaypointSprite_Kill(plyr.waypointsprite_attachedforcarrier);
158 }
159
160 void ka_Reset() // used to clear the ballcarrier whenever the match switches from warmup to normal
161 {
162         if((self.owner) && (IS_PLAYER(self.owner)))
163                 ka_DropEvent(self.owner);
164
165         ka_RespawnBall();
166 }
167
168
169 // ================
170 // Bot player logic
171 // ================
172
173 void havocbot_goalrating_ball(float ratingscale, vector org)
174 {
175         float t;
176         entity ball_owner;
177         ball_owner = ka_ball.owner;
178
179         if (ball_owner == self)
180                 return;
181
182         // If ball is carried by player then hunt them down.
183         if (ball_owner)
184         {
185                 t = (self.health + self.armorvalue) / (ball_owner.health + ball_owner.armorvalue);
186                 navigation_routerating(ball_owner, t * ratingscale, 2000);
187         }
188
189         // Ball has been dropped so collect.
190         navigation_routerating(ka_ball, ratingscale, 2000);
191 }
192
193 void havocbot_role_ka_carrier()
194 {
195         if (self.deadflag != DEAD_NO)
196                 return;
197
198         if (time > self.bot_strategytime)
199         {
200                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
201
202                 navigation_goalrating_start();
203                 havocbot_goalrating_items(10000, self.origin, 10000);
204                 havocbot_goalrating_enemyplayers(20000, self.origin, 10000);
205                 //havocbot_goalrating_waypoints(1, self.origin, 1000);
206                 navigation_goalrating_end();
207         }
208
209         if (!self.ballcarried)
210         {
211                 self.havocbot_role = havocbot_role_ka_collector;
212                 self.bot_strategytime = 0;
213         }
214 }
215
216 void havocbot_role_ka_collector()
217 {
218         if (self.deadflag != DEAD_NO)
219                 return;
220
221         if (time > self.bot_strategytime)
222         {
223                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
224
225                 navigation_goalrating_start();
226                 havocbot_goalrating_items(10000, self.origin, 10000);
227                 havocbot_goalrating_enemyplayers(1000, self.origin, 10000);
228                 havocbot_goalrating_ball(20000, self.origin);
229                 navigation_goalrating_end();
230         }
231
232         if (self.ballcarried)
233         {
234                 self.havocbot_role = havocbot_role_ka_carrier;
235                 self.bot_strategytime = 0;
236         }
237 }
238
239
240 // ==============
241 // Hook Functions
242 // ==============
243
244 MUTATOR_HOOKFUNCTION(ka_Scoring)
245 {
246         if((frag_attacker != frag_target) && (IS_PLAYER(frag_attacker)))
247         {
248                 if(frag_target.ballcarried) { // add to amount of times killing carrier
249                         PlayerScore_Add(frag_attacker, SP_KEEPAWAY_CARRIERKILLS, 1);
250                         if(autocvar_g_keepaway_score_bckill) // add bckills to the score
251                                 PlayerScore_Add(frag_attacker, SP_SCORE, autocvar_g_keepaway_score_bckill);
252                 }
253                 else if(!frag_attacker.ballcarried)
254                         if(autocvar_g_keepaway_noncarrier_warn)
255                                 Send_Notification(NOTIF_ONE_ONLY, frag_attacker, MSG_CENTER, CENTER_KEEPAWAY_WARN);
256
257                 if(frag_attacker.ballcarried) // add to amount of kills while ballcarrier
258                         PlayerScore_Add(frag_attacker, SP_SCORE, autocvar_g_keepaway_score_killac);
259         }
260
261         if(self.ballcarried) { ka_DropEvent(self); } // a player with the ball has died, drop it
262         return 0;
263 }
264
265 MUTATOR_HOOKFUNCTION(ka_GiveFragsForKill)
266 {
267         frag_score = 0; // no frags counted in keepaway
268         return 1; // you deceptive little bugger ;3 This needs to be true in order for this function to even count. 
269 }
270
271 MUTATOR_HOOKFUNCTION(ka_PlayerPreThink)
272 {
273         // clear the item used for the ball in keepaway
274         self.items &~= IT_KEY1;
275         
276         // if the player has the ball, make sure they have the item for it (Used for HUD primarily)
277         if(self.ballcarried)
278                 self.items |= IT_KEY1;
279
280         return 0;
281 }
282
283 MUTATOR_HOOKFUNCTION(ka_PlayerUseKey)
284 {
285         if(MUTATOR_RETURNVALUE == 0)
286         if(self.ballcarried)
287         {
288                 ka_DropEvent(self);
289                 return 1;
290         }
291         return 0;
292 }
293
294 MUTATOR_HOOKFUNCTION(ka_PlayerDamage) // for changing damage and force values that are applied to players in g_damage.qc
295 {
296         if(frag_attacker.ballcarried) // if the attacker is a ballcarrier
297         {
298                 if(frag_target == frag_attacker) // damage done to yourself
299                 {
300                         frag_damage *= autocvar_g_keepaway_ballcarrier_selfdamage;
301                         frag_force *= autocvar_g_keepaway_ballcarrier_selfforce;
302                 }
303                 else // damage done to noncarriers
304                 {
305                         frag_damage *= autocvar_g_keepaway_ballcarrier_damage;
306                         frag_force *= autocvar_g_keepaway_ballcarrier_force;
307                 }
308         }
309         else if not(frag_target.ballcarried) // if the target is a noncarrier
310         {
311                 if(frag_target == frag_attacker) // damage done to yourself
312                 {
313                         frag_damage *= autocvar_g_keepaway_noncarrier_selfdamage;
314                         frag_force *= autocvar_g_keepaway_noncarrier_selfforce;
315                 }
316                 else // damage done to other noncarriers
317                 {
318                         frag_damage *= autocvar_g_keepaway_noncarrier_damage;
319                         frag_force *= autocvar_g_keepaway_noncarrier_force;
320                 }
321         }
322         return 0;
323 }
324
325 MUTATOR_HOOKFUNCTION(ka_RemovePlayer)
326 {
327         if(self.ballcarried) { ka_DropEvent(self); } // a player with the ball has left the match, drop it
328         return 0;
329 }
330
331 MUTATOR_HOOKFUNCTION(ka_PlayerPowerups)
332 {
333         // In the future this hook is supposed to allow me to do some extra stuff with waypointsprites and invisibility powerup
334         // So bare with me until I can fix a certain bug with ka_ballcarrier_waypointsprite_visible_for_player() 
335         
336         self.effects &~= autocvar_g_keepaway_ballcarrier_effects;
337
338         if(self.ballcarried)
339                 self.effects |= autocvar_g_keepaway_ballcarrier_effects;
340         
341         return 0;
342 }
343
344 MUTATOR_HOOKFUNCTION(ka_BotRoles)
345 {
346         if (self.ballcarried)
347                 self.havocbot_role = havocbot_role_ka_carrier;
348         else
349                 self.havocbot_role = havocbot_role_ka_collector;
350         return TRUE;
351 }
352
353
354 // ==============
355 // Initialization
356 // ==============
357
358 void ka_SpawnBall() // loads various values for the ball, runs only once at start of match
359 {
360         if(!g_keepaway) { return; }
361         
362         entity e;
363         e = spawn();
364         e.model = "models/orbs/orbblue.md3";    
365         precache_model(e.model);
366         setmodel(e, e.model);
367         setsize(e, '-16 -16 -20', '16 16 20'); // 20 20 20 was too big, player is only 16 16 24... gotta cheat with the Z (20) axis so that the particle isn't cut off
368         e.classname = "keepawayball";
369         e.damageforcescale = autocvar_g_keepawayball_damageforcescale;
370         e.takedamage = DAMAGE_YES;
371         e.solid = SOLID_TRIGGER;
372         e.movetype = MOVETYPE_BOUNCE;
373         e.glow_color = autocvar_g_keepawayball_trail_color;
374         e.glow_trail = TRUE;
375         e.flags = FL_ITEM;
376         e.reset = ka_Reset;
377         e.touch = ka_TouchEvent;
378         e.owner = world;
379         ka_ball = e;
380
381         InitializeEntity(e, ka_RespawnBall, INITPRIO_SETLOCATION); // is this the right priority? Neh, I have no idea.. Well-- it works! So. 
382 }
383
384 void ka_ScoreRules()
385 {
386         ScoreRules_basics(0, SFL_SORT_PRIO_PRIMARY, 0, TRUE); // SFL_SORT_PRIO_PRIMARY
387         ScoreInfo_SetLabel_PlayerScore(SP_KEEPAWAY_PICKUPS,                     "pickups",              0);
388         ScoreInfo_SetLabel_PlayerScore(SP_KEEPAWAY_CARRIERKILLS,        "bckills",              0);
389         ScoreInfo_SetLabel_PlayerScore(SP_KEEPAWAY_BCTIME,                      "bctime",               SFL_SORT_PRIO_SECONDARY);
390         ScoreRules_basics_end();
391 }
392
393 void ka_Initialize() // run at the start of a match, initiates game mode
394 {
395         if(!g_keepaway)
396                 return;
397                 
398         precache_sound("keepaway/pickedup.wav");
399         precache_sound("keepaway/dropped.wav");
400         precache_sound("keepaway/respawn.wav");
401         precache_sound("keepaway/touch.wav");
402
403         ka_ScoreRules();
404         ka_SpawnBall();
405 }
406
407
408 MUTATOR_DEFINITION(gamemode_keepaway)
409 {
410         MUTATOR_HOOK(MakePlayerObserver, ka_RemovePlayer, CBC_ORDER_ANY);
411         MUTATOR_HOOK(ClientDisconnect, ka_RemovePlayer, CBC_ORDER_ANY);
412         MUTATOR_HOOK(PlayerDies, ka_Scoring, CBC_ORDER_ANY);
413         MUTATOR_HOOK(GiveFragsForKill, ka_GiveFragsForKill, CBC_ORDER_ANY);
414         MUTATOR_HOOK(PlayerPreThink, ka_PlayerPreThink, CBC_ORDER_ANY);
415         MUTATOR_HOOK(PlayerDamage_Calculate, ka_PlayerDamage, CBC_ORDER_ANY);
416         MUTATOR_HOOK(PlayerPowerups, ka_PlayerPowerups, CBC_ORDER_ANY);
417         MUTATOR_HOOK(PlayerUseKey, ka_PlayerUseKey, CBC_ORDER_ANY);
418         MUTATOR_HOOK(HavocBot_ChooseRule, ka_BotRoles, CBC_ORDER_ANY);
419
420         MUTATOR_ONADD
421         {
422                 if(time > 1) // game loads at time 1
423                         error("This is a game type and it cannot be added at runtime.");
424                 ka_Initialize();
425         }
426
427         MUTATOR_ONROLLBACK_OR_REMOVE
428         {
429                 // we actually cannot roll back ka_Initialize here
430                 // BUT: we don't need to! If this gets called, adding always
431                 // succeeds.
432         }
433
434         MUTATOR_ONREMOVE
435         {
436                 print("This is a game type and it cannot be removed at runtime.");
437                 return -1;
438         }
439
440         return 0;
441 }