]> git.xonotic.org Git - xonotic/xonotic-data.pk3dir.git/blob - qcsrc/server/mutators/gamemode_ctf.qc
Also add unique touch sound
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / mutators / gamemode_ctf.qc
1 // ================================================================
2 //  Official capture the flag game mode coding, reworked by Samual
3 //  Last updated: March 30th, 2012
4 // ================================================================
5
6 float ctf_ReadScore(string parameter) // make this obsolete
7 {
8         //if(g_ctf_win_mode != 2)
9                 return cvar(strcat("g_ctf_personal", parameter));
10         //else
11         //      return cvar(strcat("g_ctf_flag", parameter));
12 }
13
14 void ctf_FakeTimeLimit(entity e, float t)
15 {
16         msg_entity = e;
17         WriteByte(MSG_ONE, 3); // svc_updatestat
18         WriteByte(MSG_ONE, 236); // STAT_TIMELIMIT
19         if(t < 0)
20                 WriteCoord(MSG_ONE, autocvar_timelimit);
21         else
22                 WriteCoord(MSG_ONE, (t + 1) / 60);
23 }
24
25 void ctf_EventLog(string mode, float flagteam, entity actor) // use an alias for easy changing and quick editing later
26 {
27         if(autocvar_sv_eventlog)
28                 GameLogEcho(strcat(":ctf:", mode, ":", ftos(flagteam), ((actor != world) ? (strcat(":", ftos(actor.playerid))) : "")));
29 }
30
31 string ctf_CaptureRecord(entity flag, entity player)
32 {
33         float cap_time, cap_record, success;
34         string cap_message, refername;
35         
36         if((autocvar_g_ctf_captimerecord_always) || (player_count - currentbots)) 
37         {
38                 cap_record = ctf_captimerecord;
39                 cap_time = (time - flag.ctf_pickuptime);
40
41                 refername = db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"));
42                 refername = ((refername == player.netname) ? "their" : strcat(refername, "^7's"));
43
44                 if(!ctf_captimerecord) 
45                         { cap_message = strcat(" in ", ftos_decimals(cap_time, 2), " seconds"); success = TRUE; }
46                 else if(cap_time < cap_record) 
47                         { cap_message = strcat(" in ", ftos_decimals(cap_time, 2), " seconds, breaking ", refername, " previous record of ", ftos_decimals(cap_record, 2), " seconds"); success = TRUE; }
48                 else
49                         { cap_message = strcat(" in ", ftos_decimals(cap_time, 2), " seconds, failing to break ", refername, " record of ", ftos_decimals(cap_record, 2), " seconds"); success = FALSE; }
50
51                 if(success) 
52                 {
53                         ctf_captimerecord = cap_time;
54                         db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time"), ftos(cap_time));
55                         db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"), player.netname);
56                         write_recordmarker(player, (time - cap_time), cap_time); 
57                 } 
58         }
59         
60         return cap_message;
61 }
62
63 void ctf_FlagcarrierWaypoints(entity player)
64 {
65         WaypointSprite_Spawn("flagcarrier", 0, 0, player, FLAG_WAYPOINT_OFFSET, world, player.team, player, wps_flagcarrier, TRUE, RADARICON_FLAG, WPCOLOR_FLAGCARRIER(player.team));
66         WaypointSprite_UpdateMaxHealth(player.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(start_health, start_armorvalue, autocvar_g_balance_armor_blockpercent) * 2);
67         WaypointSprite_UpdateHealth(player.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(player.health, player.armorvalue, autocvar_g_balance_armor_blockpercent));
68         WaypointSprite_UpdateTeamRadar(player.wps_flagcarrier, RADARICON_FLAGCARRIER, WPCOLOR_FLAGCARRIER(player.team));
69 }
70
71
72 // =======================
73 // CaptureShield Functions 
74 // =======================
75
76 float ctf_CaptureShield_CheckStatus(entity p) 
77 {
78         float s, se;
79         entity e;
80         float players_worseeq, players_total;
81
82         if(ctf_captureshield_max_ratio <= 0)
83                 return FALSE;
84
85         s = PlayerScore_Add(p, SP_SCORE, 0);
86         if(s >= -ctf_captureshield_min_negscore)
87                 return FALSE;
88
89         players_total = players_worseeq = 0;
90         FOR_EACH_PLAYER(e)
91         {
92                 if(IsDifferentTeam(e, p))
93                         continue;
94                 se = PlayerScore_Add(e, SP_SCORE, 0);
95                 if(se <= s)
96                         ++players_worseeq;
97                 ++players_total;
98         }
99
100         // player is in the worse half, if >= half the players are better than him, or consequently, if < half of the players are worse
101         // use this rule here
102         
103         if(players_worseeq >= players_total * ctf_captureshield_max_ratio)
104                 return FALSE;
105
106         return TRUE;
107 }
108
109 void ctf_CaptureShield_Update(entity player, float wanted_status)
110 {
111         float updated_status = ctf_CaptureShield_CheckStatus(player);
112         if((wanted_status == player.ctf_captureshielded) && (updated_status != wanted_status)) // 0: shield only, 1: unshield only
113         {
114                 if(updated_status) // TODO csqc notifier for this // Samual: How?
115                         Send_CSQC_Centerprint_Generic(player, CPID_CTF_CAPTURESHIELD, "^3You are now ^4shielded^3 from the flag\n^3for ^1too many unsuccessful attempts^3 to capture.\n\n^3Make some defensive scores before trying again.", 5, 0);
116                 else
117                         Send_CSQC_Centerprint_Generic(player, CPID_CTF_CAPTURESHIELD, "^3You are now free.\n\n^3Feel free to ^1try to capture^3 the flag again\n^3if you think you will succeed.", 5, 0);
118                         
119                 player.ctf_captureshielded = updated_status;
120         }
121 }
122
123 float ctf_CaptureShield_Customize()
124 {
125         if(!other.ctf_captureshielded) { return FALSE; }
126         if(!IsDifferentTeam(self, other)) { return FALSE; }
127         
128         return TRUE;
129 }
130
131 void ctf_CaptureShield_Touch()
132 {
133         if(!other.ctf_captureshielded) { return; }
134         if(!IsDifferentTeam(self, other)) { return; }
135         
136         vector mymid = (self.absmin + self.absmax) * 0.5;
137         vector othermid = (other.absmin + other.absmax) * 0.5;
138
139         Damage(other, self, self, 0, DEATH_HURTTRIGGER, mymid, normalize(othermid - mymid) * ctf_captureshield_force);
140         Send_CSQC_Centerprint_Generic(other, CPID_CTF_CAPTURESHIELD, "^3You are ^4shielded^3 from the flag\n^3for ^1too many unsuccessful attempts^3 to capture.\n\n^3Get some defensive scores before trying again.", 5, 0);
141 }
142
143 void ctf_CaptureShield_Spawn(entity flag)
144 {
145         entity shield = spawn();
146         
147         shield.enemy = self;
148         shield.team = self.team;
149         shield.touch = ctf_CaptureShield_Touch;
150         shield.customizeentityforclient = ctf_CaptureShield_Customize;
151         shield.classname = "ctf_captureshield";
152         shield.effects = EF_ADDITIVE;
153         shield.movetype = MOVETYPE_NOCLIP;
154         shield.solid = SOLID_TRIGGER;
155         shield.avelocity = '7 0 11';
156         shield.scale = 0.5;
157         
158         setorigin(shield, self.origin);
159         setmodel(shield, "models/ctf/shield.md3");
160         setsize(shield, shield.scale * shield.mins, shield.scale * shield.maxs);
161 }
162
163
164 // ====================
165 // Drop/Pass/Throw Code
166 // ====================
167
168 void ctf_Handle_Drop(entity flag, entity player, float droptype)
169 {
170         // declarations
171         player = (player ? player : flag.pass_sender);
172
173         // main
174         flag.movetype = MOVETYPE_TOSS;
175         flag.takedamage = DAMAGE_YES;
176         flag.health = flag.max_flag_health;
177         flag.ctf_droptime = time;
178         flag.ctf_dropper = player;
179         flag.ctf_status = FLAG_DROPPED;
180         
181         // messages and sounds
182         Send_KillNotification(player.netname, flag.netname, "", INFO_LOSTFLAG, MSG_INFO);
183         sound(flag, CH_TRIGGER, flag.snd_flag_dropped, VOL_BASE, ATTN_NONE);
184         ctf_EventLog("dropped", player.team, player);
185
186         // scoring
187         PlayerTeamScore_AddScore(player, -ctf_ReadScore("penalty_drop"));       
188         PlayerScore_Add(player, SP_CTF_DROPS, 1);
189         
190         // waypoints
191         if(autocvar_g_ctf_flag_dropped_waypoint)
192                 WaypointSprite_Spawn("flagdropped", 0, 0, flag, FLAG_WAYPOINT_OFFSET, world, ((autocvar_g_ctf_flag_dropped_waypoint == 2) ? 0 : player.team), flag, wps_flagdropped, TRUE, RADARICON_FLAG, WPCOLOR_DROPPEDFLAG(flag.team));
193
194         if(autocvar_g_ctf_flag_return_time || (autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health))
195         {
196                 WaypointSprite_UpdateMaxHealth(flag.wps_flagdropped, flag.max_flag_health);
197                 WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health);
198         }
199         
200         player.throw_antispam = time + autocvar_g_ctf_pass_wait;
201         
202         if(droptype == DROP_PASS)
203         {
204                 flag.pass_sender = world;
205                 flag.pass_target = world;
206         }
207 }
208
209 void ctf_Handle_Retrieve(entity flag, entity player)
210 {
211         entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
212         entity sender = flag.pass_sender;
213         
214         // transfer flag to player
215         flag.ctf_carrier = player;
216         flag.owner = player;
217         flag.owner.flagcarried = flag;
218         
219         // reset flag
220         setattachment(flag, player, "");
221         setorigin(flag, FLAG_CARRY_OFFSET);
222         flag.movetype = MOVETYPE_NONE;
223         flag.takedamage = DAMAGE_NO;
224         flag.solid = SOLID_NOT;
225         flag.ctf_carrier = player;
226         flag.ctf_status = FLAG_CARRY;
227
228         // messages and sounds
229         sound(player, CH_TRIGGER, flag.snd_flag_pass, VOL_BASE, ATTN_NORM);
230         ctf_EventLog("recieve", flag.team, player);
231         
232         FOR_EACH_REALPLAYER(tmp_player)
233         {
234                 if(tmp_player == sender)
235                         centerprint(tmp_player, strcat("You passed the ", flag.netname, " to ", player.netname));
236                 else if(tmp_player == player)
237                         centerprint(tmp_player, strcat("You recieved the ", flag.netname, " from ", sender.netname));
238                 else if(!IsDifferentTeam(tmp_player, sender))
239                         centerprint(tmp_player, strcat(sender.netname, " passed the ", flag.netname, " to ", player.netname));
240         }
241         
242         // create new waypoint
243         ctf_FlagcarrierWaypoints(player);
244         
245         sender.throw_antispam = time + autocvar_g_ctf_pass_wait;
246         player.throw_antispam = sender.throw_antispam;
247         
248         flag.pass_sender = world;
249         flag.pass_target = world;
250 }
251
252 void ctf_Handle_Throw(entity player, entity reciever, float droptype)
253 {
254         entity flag = player.flagcarried;
255         
256         if(!flag) { return; }
257         if((droptype == DROP_PASS) && !reciever) { return; }
258         
259         if(flag.speedrunning) { ctf_RespawnFlag(flag); return; }
260         
261         // reset the flag
262         setattachment(flag, world, "");
263         setorigin(flag, player.origin + FLAG_DROP_OFFSET);
264         flag.owner.flagcarried = world;
265         flag.owner = world;
266         flag.solid = SOLID_TRIGGER;
267         flag.ctf_droptime = time;
268         
269         flag.flags = FL_ITEM | FL_NOTARGET; // clear FL_ONGROUND for MOVETYPE_TOSS
270         
271         switch(droptype)
272         {
273                 case DROP_PASS:
274                 {
275                         vector targ_origin = WarpZone_RefSys_TransformOrigin(player, reciever, (0.5 * (reciever.absmin + reciever.absmax)));
276                         flag.velocity = (normalize(targ_origin - player.origin) * autocvar_g_ctf_pass_velocity);
277                         break;
278                 }
279                 
280                 case DROP_THROW:
281                 {
282                         makevectors((player.v_angle_y * '0 1 0') + (player.v_angle_x * '0.5 0 0'));
283                         flag.velocity = W_CalculateProjectileVelocity(player.velocity, ('0 0 200' + (v_forward * autocvar_g_ctf_drop_velocity)), FALSE);
284                         break;
285                 }
286                 
287                 case DROP_RESET:
288                 {
289                         flag.velocity = '0 0 0'; // do nothing
290                         break;
291                 }
292                 
293                 default:
294                 case DROP_NORMAL:
295                 {
296                         flag.velocity = W_CalculateProjectileVelocity(player.velocity, ('0 0 200' + ('0 100 0' * crandom()) + ('100 0 0' * crandom())), FALSE);
297                         break;
298                 }
299         }
300         
301         switch(droptype)
302         {
303                 case DROP_PASS:
304                 {
305                         // main
306                         flag.movetype = MOVETYPE_FLY;
307                         flag.takedamage = DAMAGE_NO;
308                         flag.pass_sender = player;
309                         flag.pass_target = reciever;
310                         flag.ctf_status = FLAG_PASSING;
311                         
312                         // other
313                         sound(player, CH_TRIGGER, flag.snd_flag_touch, VOL_BASE, ATTN_NORM);
314                         ctf_EventLog("pass", flag.team, player);
315                         te_lightning2(world, reciever.origin, player.origin);
316                         break;
317                 }
318
319                 case DROP_RESET: 
320                 {
321                         // do nothing
322                         break;
323                 }
324                 
325                 default:
326                 case DROP_THROW:
327                 case DROP_NORMAL:
328                 {
329                         ctf_Handle_Drop(flag, player, droptype);
330                         break;
331                 }
332         }
333
334         // kill old waypointsprite
335         WaypointSprite_Ping(player.wps_flagcarrier);
336         WaypointSprite_Kill(player.wps_flagcarrier);
337         
338         if(player.wps_enemyflagcarrier)
339                 WaypointSprite_Kill(player.wps_enemyflagcarrier);
340         
341         // captureshield
342         ctf_CaptureShield_Update(player, 0); // shield player from picking up flag
343 }
344
345
346 // ==============
347 // Event Handlers
348 // ==============
349
350 void ctf_Handle_Capture(entity flag, entity toucher, float capturetype)
351 {
352         entity enemy_flag = ((capturetype == CAPTURE_NORMAL) ? toucher.flagcarried : toucher);
353         entity player = ((capturetype == CAPTURE_NORMAL) ? toucher : enemy_flag.ctf_dropper);
354         
355         if not(player) { return; } // without someone to give the reward to, we can't possibly cap
356         
357         // messages and sounds
358         Send_KillNotification(player.netname, enemy_flag.netname, ctf_CaptureRecord(enemy_flag, player), INFO_CAPTUREFLAG, MSG_INFO);
359         sound(player, CH_TRIGGER, flag.snd_flag_capture, VOL_BASE, ATTN_NONE);
360         
361         switch(capturetype)
362         {
363                 case CAPTURE_NORMAL: ctf_EventLog("capture", enemy_flag.team, player); break;
364                 case CAPTURE_DROPPED: ctf_EventLog("droppedcapture", enemy_flag.team, player); break;
365                 default: break;
366         }
367         
368         // scoring
369         PlayerTeamScore_AddScore(player, ctf_ReadScore("score_capture"));
370         PlayerTeamScore_Add(player, SP_CTF_CAPS, ST_CTF_CAPS, 1);
371
372         // effects
373         if(autocvar_g_ctf_flag_capture_effects) 
374         {
375                 pointparticles(particleeffectnum((player.team == COLOR_TEAM1) ? "red_ground_quake" : "blue_ground_quake"), flag.origin, '0 0 0', 1);
376                 shockwave_spawn("models/ctf/shockwavetransring.md3", flag.origin - '0 0 15', -0.8, 0, 1);
377         }
378
379         // other
380         if(capturetype == CAPTURE_NORMAL)
381         {
382                 WaypointSprite_Kill(player.wps_flagcarrier);
383                 if(flag.speedrunning) { ctf_FakeTimeLimit(player, -1); }
384         }
385         
386         // reset the flag
387         player.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
388         ctf_RespawnFlag(enemy_flag);
389 }
390
391 void ctf_Handle_Return(entity flag, entity player)
392 {
393         // messages and sounds
394         //centerprint(player, strcat("You returned the ", flag.netname));
395         Send_KillNotification(player.netname, flag.netname, "", INFO_RETURNFLAG, MSG_INFO);
396         sound(player, CH_TRIGGER, flag.snd_flag_returned, VOL_BASE, ATTN_NONE);
397         ctf_EventLog("return", flag.team, player);
398
399         // scoring
400         PlayerTeamScore_AddScore(player, ctf_ReadScore("score_return")); // reward for return
401         PlayerScore_Add(player, SP_CTF_RETURNS, 1); // add to count of returns
402
403         TeamScore_AddToTeam(flag.team, ST_SCORE, -ctf_ReadScore("penalty_returned")); // punish the team who was last carrying it
404         
405         if(flag.ctf_dropper) 
406         {
407                 PlayerScore_Add(flag.ctf_dropper, SP_SCORE, -ctf_ReadScore("penalty_returned")); // punish the player who dropped the flag
408                 ctf_CaptureShield_Update(flag.ctf_dropper, 0); // shield player from picking up flag 
409                 flag.ctf_dropper.next_take_time = time + autocvar_g_ctf_flag_collect_delay; // set next take time
410         }
411         
412         // reset the flag
413         ctf_RespawnFlag(flag);
414 }
415
416 void ctf_Handle_Pickup(entity flag, entity player, float pickuptype)
417 {
418         // declarations
419         entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
420         string verbosename; // holds the name of the player OR no name at all for printing in the centerprints
421         float pickup_dropped_score; // used to calculate dropped pickup score
422         
423         // attach the flag to the player
424         flag.owner = player;
425         player.flagcarried = flag;
426         setattachment(flag, player, "");
427         setorigin(flag, FLAG_CARRY_OFFSET);
428         
429         // flag setup
430         flag.movetype = MOVETYPE_NONE;
431         flag.takedamage = DAMAGE_NO;
432         flag.solid = SOLID_NOT;
433         flag.angles = '0 0 0';
434         flag.ctf_carrier = player;
435         flag.ctf_status = FLAG_CARRY;
436         
437         switch(pickuptype)
438         {
439                 case PICKUP_BASE: flag.ctf_pickuptime = time; break; // used for timing runs
440                 case PICKUP_DROPPED: flag.health = flag.max_flag_health; break; // reset health/return timelimit
441                 default: break;
442         }
443
444         // messages and sounds
445         Send_KillNotification (player.netname, flag.netname, "", INFO_GOTFLAG, MSG_INFO);
446         sound(player, CH_TRIGGER, flag.snd_flag_taken, VOL_BASE, ATTN_NONE);
447         verbosename = ((autocvar_g_ctf_flag_pickup_verbosename) ? strcat(Team_ColorCode(player.team), "(^7", player.netname, Team_ColorCode(player.team), ") ") : "");
448         
449         FOR_EACH_REALPLAYER(tmp_player)
450         {
451                 if(tmp_player == player)
452                         centerprint(tmp_player, strcat("You got the ", flag.netname, "!"));
453                 else if(!IsDifferentTeam(tmp_player, player))
454                         centerprint(tmp_player, strcat("Your ", Team_ColorCode(player.team), "team mate ", verbosename, "^7got the flag! Protect them!"));
455                 else if(!IsDifferentTeam(tmp_player, flag))
456                         centerprint(tmp_player, strcat("The ", Team_ColorCode(player.team), "enemy ", verbosename, "^7got your flag! Retrieve it!"));
457         }
458                 
459         switch(pickuptype)
460         {
461                 case PICKUP_BASE: ctf_EventLog("steal", flag.team, player); break;
462                 case PICKUP_DROPPED: ctf_EventLog("pickup", flag.team, player); break;
463                 default: break;
464         }
465         
466         // scoring
467         PlayerScore_Add(player, SP_CTF_PICKUPS, 1);
468         switch(pickuptype)
469         {               
470                 case PICKUP_BASE:
471                 {
472                         PlayerTeamScore_AddScore(player, ctf_ReadScore("score_pickup_base"));
473                         break;
474                 }
475                 
476                 case PICKUP_DROPPED:
477                 {
478                         pickup_dropped_score = (autocvar_g_ctf_flag_return_time ? bound(0, ((flag.ctf_droptime + autocvar_g_ctf_flag_return_time) - time) / autocvar_g_ctf_flag_return_time, 1) : 1);
479                         pickup_dropped_score = floor((ctf_ReadScore("score_pickup_dropped_late") * (1 - pickup_dropped_score) + ctf_ReadScore("score_pickup_dropped_early") * pickup_dropped_score) + 0.5);
480                         print("pickup_dropped_score is ", ftos(pickup_dropped_score), "\n");
481                         PlayerTeamScore_AddScore(player, pickup_dropped_score);
482                         break;
483                 }
484                 
485                 default: break;
486         }
487         
488         // speedrunning
489         if(pickuptype == PICKUP_BASE)
490         {
491                 flag.speedrunning = player.speedrunning; // if speedrunning, flag will flag-return and teleport the owner back after the record
492                 if((player.speedrunning) && (ctf_captimerecord))
493                         ctf_FakeTimeLimit(player, time + ctf_captimerecord);
494         }
495                 
496         // effects
497         if(autocvar_g_ctf_flag_pickup_effects)
498                 pointparticles(particleeffectnum("smoke_ring"), 0.5 * (flag.absmin + flag.absmax), '0 0 0', 1);
499         
500         // waypoints 
501         if(pickuptype == PICKUP_DROPPED) { WaypointSprite_Kill(flag.wps_flagdropped); }
502         ctf_FlagcarrierWaypoints(player);
503         WaypointSprite_Ping(player.wps_flagcarrier);
504 }
505
506
507 // ===================
508 // Main Flag Functions
509 // ===================
510
511 void ctf_CheckFlagReturn(entity flag, float returntype)
512 {
513         if(flag.wps_flagdropped) { WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health); }
514         
515         if((flag.health <= 0) || (time >= flag.ctf_droptime + autocvar_g_ctf_flag_return_time))
516         {
517                 switch(returntype)
518                 {
519                         case RETURN_DROPPED: bprint("The ", flag.netname, " was dropped in the base and returned itself\n"); break;
520                         case RETURN_DAMAGE: bprint("The ", flag.netname, " was destroyed and returned to base\n"); break;
521                         case RETURN_SPEEDRUN: bprint("The ", flag.netname, " became impatient after ", ftos_decimals(ctf_captimerecord, 2), " seconds and returned itself\n"); break;
522                         case RETURN_NEEDKILL: bprint("The ", flag.netname, " fell somewhere it couldn't be reached and returned to base\n"); break;
523                         
524                         default:
525                         case RETURN_TIMEOUT:
526                                 { bprint("The ", flag.netname, " has returned to base\n"); break; }
527                 }
528                 sound(flag, CH_TRIGGER, flag.snd_flag_respawn, VOL_BASE, ATTN_NONE);
529                 ctf_EventLog("returned", flag.team, world);
530                 ctf_RespawnFlag(flag);
531         }
532 }
533
534 void ctf_CheckStalemate(void)
535 {
536         // declarations
537         float stale_red_flags, stale_blue_flags;
538         entity tmp_entity;
539
540         entity ctf_staleflaglist; // reset the list, we need to build the list each time this function runs
541
542         // build list of stale flags
543         for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
544         {
545                 if(autocvar_g_ctf_flagcarrier_waypointforenemy_stalemate)
546                 if(tmp_entity.ctf_status != FLAG_BASE)
547                 if(time >= tmp_entity.ctf_pickuptime + autocvar_g_ctf_flagcarrier_waypointforenemy_stalemate)
548                 {
549                         tmp_entity.ctf_staleflagnext = ctf_staleflaglist; // link flag into staleflaglist
550                         ctf_staleflaglist = tmp_entity;
551                         
552                         switch(tmp_entity.team)
553                         {
554                                 case COLOR_TEAM1: ++stale_red_flags; break;
555                                 case COLOR_TEAM2: ++stale_blue_flags; break;
556                         }
557                 }
558         }
559
560         if(stale_red_flags && stale_blue_flags)
561                 ctf_stalemate = TRUE;
562         else if(!stale_red_flags && !stale_blue_flags)
563                 ctf_stalemate = FALSE;
564         
565         // if sufficient stalemate, then set up the waypointsprite and announce the stalemate if necessary
566         if(ctf_stalemate)
567         {
568                 for(tmp_entity = ctf_staleflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_staleflagnext)
569                 {
570                         if((tmp_entity.owner) && (!tmp_entity.owner.wps_enemyflagcarrier))
571                                 WaypointSprite_Spawn("enemyflagcarrier", 0, 0, tmp_entity.owner, FLAG_WAYPOINT_OFFSET, world, tmp_entity.team, tmp_entity.owner, wps_enemyflagcarrier, TRUE, RADARICON_FLAG, WPCOLOR_ENEMYFC(tmp_entity.owner.team));
572                 }
573                 
574                 if not(wpforenemy_announced)
575                 {
576                         FOR_EACH_REALPLAYER(tmp_entity)
577                                 if(tmp_entity.flagcarried)
578                                         centerprint(tmp_entity, "Stalemate! Enemies can now see you on radar!");
579                                 else
580                                         centerprint(tmp_entity, "Stalemate! Flag carriers can now be seen by enemies on radar!");
581                         
582                         wpforenemy_announced = TRUE;
583                 }
584         }
585 }
586
587 void ctf_FlagDamage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
588 {
589         if(ITEM_DAMAGE_NEEDKILL(deathtype))
590         {
591                 // automatically kill the flag and return it
592                 self.health = 0;
593                 ctf_CheckFlagReturn(self, RETURN_NEEDKILL);
594                 return;
595         }
596         if(autocvar_g_ctf_flag_return_damage) 
597         {
598                 // reduce health and check if it should be returned
599                 self.health = self.health - damage;
600                 ctf_CheckFlagReturn(self, RETURN_DAMAGE);
601                 return;
602         }
603 }
604
605 void ctf_FlagThink()
606 {
607         // declarations
608         entity tmp_entity;
609
610         self.nextthink = time + FLAG_THINKRATE; // only 5 fps, more is unnecessary.
611
612         // captureshield
613         if(self == ctf_worldflaglist) // only for the first flag
614                 FOR_EACH_CLIENT(tmp_entity)
615                         ctf_CaptureShield_Update(tmp_entity, 1); // release shield only
616
617         // sanity checks
618         if(self.mins != FLAG_MIN || self.maxs != FLAG_MAX) { // reset the flag boundaries in case it got squished
619                 dprint("wtf the flag got squashed?\n");
620                 tracebox(self.origin, FLAG_MIN, FLAG_MAX, self.origin, MOVE_NOMONSTERS, self);
621                 if(!trace_startsolid) // can we resize it without getting stuck?
622                         setsize(self, FLAG_MIN, FLAG_MAX); }
623                         
624         switch(self.ctf_status) // reset flag angles in case warpzones adjust it
625         {
626                 case FLAG_DROPPED:
627                 case FLAG_PASSING:
628                 {
629                         self.angles = '0 0 0';
630                         break;
631                 }
632                 
633                 default: break;
634         }
635
636         // main think method
637         switch(self.ctf_status)
638         {       
639                 case FLAG_BASE:
640                 {
641                         if(autocvar_g_ctf_dropped_capture_radius)
642                         {
643                                 for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
644                                         if(tmp_entity.ctf_status == FLAG_DROPPED)
645                                                 if(vlen(self.origin - tmp_entity.origin) < autocvar_g_ctf_dropped_capture_radius)
646                                                         ctf_Handle_Capture(self, tmp_entity, CAPTURE_DROPPED);
647                         }
648                         return;
649                 }
650                 
651                 case FLAG_DROPPED:
652                 {
653                         if(autocvar_g_ctf_flag_dropped_floatinwater)
654                         {
655                                 vector midpoint = ((self.absmin + self.absmax) * 0.5);
656                                 if(pointcontents(midpoint) == CONTENT_WATER)
657                                 {
658                                         self.velocity = self.velocity * 0.5;
659                                         
660                                         if(pointcontents(midpoint + FLAG_FLOAT_OFFSET) == CONTENT_WATER)
661                                                 { self.velocity_z = autocvar_g_ctf_flag_dropped_floatinwater; }
662                                         else
663                                                 { self.movetype = MOVETYPE_FLY; }
664                                 }
665                                 else if(self.movetype == MOVETYPE_FLY) { self.movetype = MOVETYPE_TOSS; }
666                         }
667                         if(autocvar_g_ctf_flag_return_dropped)
668                         {
669                                 if((vlen(self.origin - self.ctf_spawnorigin) <= autocvar_g_ctf_flag_return_dropped) || (autocvar_g_ctf_flag_return_dropped == -1))
670                                 {
671                                         self.health = 0;
672                                         ctf_CheckFlagReturn(self, RETURN_DROPPED);
673                                         return;
674                                 }
675                         }
676                         if(autocvar_g_ctf_flag_return_time)
677                         {
678                                 self.health -= ((self.max_flag_health / autocvar_g_ctf_flag_return_time) * FLAG_THINKRATE);
679                                 ctf_CheckFlagReturn(self, RETURN_TIMEOUT);
680                                 return;
681                         } 
682                         return;
683                 }
684                         
685                 case FLAG_CARRY:
686                 {
687                         if(self.speedrunning && ctf_captimerecord && (time >= self.ctf_pickuptime + ctf_captimerecord)) 
688                         {
689                                 self.health = 0;
690                                 ctf_CheckFlagReturn(self, RETURN_SPEEDRUN);
691
692                                 tmp_entity = self;
693                                 self = self.owner;
694                                 self.impulse = CHIMPULSE_SPEEDRUN; // move the player back to the waypoint they set
695                                 ImpulseCommands();
696                                 self = tmp_entity;
697                         }
698                         if(autocvar_g_ctf_flagcarrier_waypointforenemy_stalemate)
699                         {
700                                 if(time >= wpforenemy_nextthink)
701                                 {
702                                         ctf_CheckStalemate();
703                                         wpforenemy_nextthink = time + WPFE_THINKRATE; // waypoint for enemy think rate (to reduce unnecessary spam of this check)
704                                 }
705                         }
706                         return;
707                 }
708                 
709                 case FLAG_PASSING: // todo make work with warpzones
710                 {                       
711                         /*vector targ_origin = ((self.pass_target.absmin + self.pass_target.absmax) * 0.5);
712                         vector old_targ_origin = targ_origin;
713                         targ_origin = WarpZone_RefSys_TransformOrigin(self.pass_sender, self.pass_target, targ_origin);
714
715                         print("old: ", vtos(old_targ_origin), ", transformed: ", vtos(targ_origin), ".\n");
716                         
717                         WarpZone_TraceLine(self.origin, targ_origin, MOVE_NOMONSTERS, self);
718                         
719                         te_customflash(self.origin, 40,  2, '1 1 1');
720                         te_customflash(targ_origin, 200, 2, '15 0 0');
721                         
722                         if((self.pass_target.deadflag != DEAD_NO)
723                                 || (vlen(self.origin - targ_origin) > autocvar_g_ctf_pass_radius)
724                                 || ((trace_fraction < 1) && (trace_ent != self.pass_target))
725                                 || (time > self.ctf_droptime + autocvar_g_ctf_pass_timelimit))
726                         {
727                                 ctf_Handle_Drop(self, world, DROP_PASS);
728                         }
729                         else // still a viable target, go for it
730                         {
731                                 vector desired_direction = normalize(targ_origin - self.origin);
732                                 vector current_direction = normalize(self.velocity);
733                                 
734                                 self.velocity = (normalize(current_direction + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_pass_velocity); 
735                         }
736                         return;*/
737
738                         vector targ_origin = ((self.pass_target.absmin + self.pass_target.absmax) * 0.5);
739                         vector old_targ_origin = targ_origin;
740                         targ_origin = WarpZone_RefSys_TransformOrigin(self.pass_sender, self.pass_target, targ_origin);
741                         WarpZone_TraceLine(self.origin, targ_origin, MOVE_NOMONSTERS, self);
742
743                         print("old: ", vtos(old_targ_origin), ", transformed: ", vtos(targ_origin), ".\n");
744                         
745                         if((self.pass_target.deadflag != DEAD_NO)
746                                 || (vlen(self.origin - targ_origin) > autocvar_g_ctf_pass_radius)
747                                 || ((trace_fraction < 1) && (trace_ent != self.pass_target))
748                                 || (time > self.ctf_droptime + autocvar_g_ctf_pass_timelimit))
749                         {
750                                 ctf_Handle_Drop(self, world, DROP_PASS);
751                         }
752                         else // still a viable target, go for it
753                         {
754                                 vector desired_direction = normalize(targ_origin - self.origin);
755                                 vector current_direction = normalize(self.velocity);
756                                 
757                                 // self.velocity = (normalize(current_direction + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_pass_velocity);
758                                 self.velocity = (normalize(current_direction + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_pass_velocity); 
759                         }
760                         return;
761                 }
762
763                 default: // this should never happen
764                 {
765                         dprint("ctf_FlagThink(): Flag exists with no status?\n");
766                         return;
767                 }
768         }
769 }
770
771 void ctf_FlagTouch()
772 {
773         if(gameover) { return; }
774         
775         entity toucher = other;
776         
777         // automatically kill the flag and return it if it touched lava/slime/nodrop surfaces
778         if(ITEM_TOUCH_NEEDKILL())
779         {
780                 self.health = 0;
781                 ctf_CheckFlagReturn(self, RETURN_NEEDKILL);
782                 return;
783         }
784         
785         // special touch behaviors
786         if(toucher.vehicle_flags & VHF_ISVEHICLE)
787         {
788                 if(autocvar_g_ctf_allow_vehicle_touch)
789                         toucher = toucher.owner; // the player is actually the vehicle owner, not other
790                 else
791                         return; // do nothing
792         }
793         else if(toucher.classname != "player") // The flag just touched an object, most likely the world
794         {
795                 if(time > self.wait) // if we haven't in a while, play a sound/effect
796                 {
797                         pointparticles(particleeffectnum(self.toucheffect), self.origin, '0 0 0', 1);
798                         sound(self, CH_TRIGGER, self.snd_flag_touch, VOL_BASE, ATTN_NORM);
799                         self.wait = time + FLAG_TOUCHRATE;
800                 }
801                 return;
802         }
803         else if(toucher.deadflag != DEAD_NO) { return; }
804
805         switch(self.ctf_status) 
806         {       
807                 case FLAG_BASE:
808                 {
809                         if(!IsDifferentTeam(toucher, self) && (toucher.flagcarried) && IsDifferentTeam(toucher.flagcarried, self))
810                                 ctf_Handle_Capture(self, toucher, CAPTURE_NORMAL); // toucher just captured the enemies flag to his base
811                         else if(IsDifferentTeam(toucher, self) && (!toucher.flagcarried) && (!toucher.ctf_captureshielded) && (time > toucher.next_take_time))
812                                 ctf_Handle_Pickup(self, toucher, PICKUP_BASE); // toucher just stole the enemies flag
813                         break;
814                 }
815                 
816                 case FLAG_DROPPED:
817                 {
818                         if(!IsDifferentTeam(toucher, self))
819                                 ctf_Handle_Return(self, toucher); // toucher just returned his own flag
820                         else if((!toucher.flagcarried) && ((toucher != self.ctf_dropper) || (time > self.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
821                                 ctf_Handle_Pickup(self, toucher, PICKUP_DROPPED); // toucher just picked up a dropped enemy flag
822                         break;
823                 }
824                         
825                 case FLAG_CARRY:
826                 {
827                         dprint("Someone touched a flag even though it was being carried?\n");
828                         break;
829                 }
830                 
831                 case FLAG_PASSING:
832                 {
833                         if((toucher.classname == "player") && (toucher.deadflag == DEAD_NO) && (toucher != self.pass_sender))
834                         {
835                                 if(IsDifferentTeam(toucher, self.pass_sender))
836                                         ctf_Handle_Return(self, toucher);
837                                 else
838                                         ctf_Handle_Retrieve(self, toucher);
839                         }
840                         break;
841                 }
842         }
843 }
844
845 void ctf_RespawnFlag(entity flag)
846 {
847         // reset the player (if there is one)
848         if((flag.owner) && (flag.owner.flagcarried == flag))
849         {
850                 if(flag.owner.wps_enemyflagcarrier)
851                         WaypointSprite_Kill(flag.owner.wps_enemyflagcarrier);
852                         
853                 WaypointSprite_Kill(flag.wps_flagcarrier);
854                 
855                 flag.owner.flagcarried = world;
856
857                 if(flag.speedrunning)
858                         ctf_FakeTimeLimit(flag.owner, -1);
859         }
860
861         if((flag.ctf_status == FLAG_DROPPED) && (flag.wps_flagdropped))
862                 { WaypointSprite_Kill(flag.wps_flagdropped); }
863
864         // reset the flag
865         setattachment(flag, world, "");
866         setorigin(flag, flag.ctf_spawnorigin);
867         
868         flag.movetype = ((flag.noalign) ? MOVETYPE_NONE : MOVETYPE_TOSS);
869         flag.takedamage = DAMAGE_NO;
870         flag.health = flag.max_flag_health;
871         flag.solid = SOLID_TRIGGER;
872         flag.velocity = '0 0 0';
873         flag.angles = flag.mangle;
874         flag.flags = FL_ITEM | FL_NOTARGET;
875         
876         flag.ctf_status = FLAG_BASE;
877         flag.owner = world;
878         flag.pass_sender = world;
879         flag.pass_target = world;
880         flag.ctf_carrier = world;
881         flag.ctf_dropper = world;
882         flag.ctf_pickuptime = 0;
883         flag.ctf_droptime = 0;
884
885         wpforenemy_announced = FALSE;
886 }
887
888 void ctf_Reset()
889 {
890         if(self.owner)
891                 if(self.owner.classname == "player")
892                         ctf_Handle_Throw(self.owner, world, DROP_RESET);
893                         
894         ctf_RespawnFlag(self);
895 }
896
897 void ctf_DelayedFlagSetup(void) // called after a flag is placed on a map by ctf_FlagSetup()
898 {
899         // bot waypoints
900         waypoint_spawnforitem_force(self, self.origin);
901         self.nearestwaypointtimeout = 0; // activate waypointing again
902         self.bot_basewaypoint = self.nearestwaypoint;
903
904         // waypointsprites
905         WaypointSprite_SpawnFixed(((self.team == COLOR_TEAM1) ? "redbase" : "bluebase"), self.origin + FLAG_WAYPOINT_OFFSET, self, wps_flagbase, RADARICON_FLAG, colormapPaletteColor(self.team - 1, FALSE));
906         WaypointSprite_UpdateTeamRadar(self.wps_flagbase, RADARICON_FLAG, colormapPaletteColor(self.team - 1, FALSE));
907
908         // captureshield setup
909         ctf_CaptureShield_Spawn(self);
910 }
911
912 void ctf_FlagSetup(float teamnumber, entity flag) // called when spawning a flag entity on the map as a spawnfunc 
913 {       
914         // declarations
915         teamnumber = fabs(teamnumber - bound(0, autocvar_g_ctf_reverse, 1)); // if we were originally 1, this will become 0. If we were originally 0, this will become 1. 
916         self = flag; // for later usage with droptofloor()
917         
918         // main setup
919         flag.ctf_worldflagnext = ctf_worldflaglist; // link flag into ctf_worldflaglist
920         ctf_worldflaglist = flag;
921
922         setattachment(flag, world, ""); 
923
924         flag.netname = ((teamnumber) ? "^1RED^7 flag" : "^4BLUE^7 flag");
925         flag.team = ((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2); // COLOR_TEAM1: color 4 team (red) - COLOR_TEAM2: color 13 team (blue)
926         flag.items = ((teamnumber) ? IT_KEY2 : IT_KEY1); // IT_KEY2: gold key (redish enough) - IT_KEY1: silver key (bluish enough)
927         flag.classname = "item_flag_team";
928         flag.target = "###item###"; // wut?
929         flag.flags = FL_ITEM | FL_NOTARGET;
930         flag.solid = SOLID_TRIGGER;
931         flag.takedamage = DAMAGE_NO;
932         flag.damageforcescale = autocvar_g_ctf_flag_damageforcescale;   
933         flag.max_flag_health = ((autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health) ? autocvar_g_ctf_flag_health : 100);
934         flag.health = flag.max_flag_health;
935         flag.event_damage = ctf_FlagDamage;
936         flag.pushable = TRUE;
937         flag.teleportable = TELEPORT_NORMAL;
938         flag.damagedbytriggers = autocvar_g_ctf_flag_return_when_unreachable;
939         flag.damagedbycontents = autocvar_g_ctf_flag_return_when_unreachable;
940         flag.velocity = '0 0 0';
941         flag.mangle = flag.angles;
942         flag.reset = ctf_Reset;
943         flag.touch = ctf_FlagTouch;
944         flag.think = ctf_FlagThink;
945         flag.nextthink = time + FLAG_THINKRATE;
946         flag.ctf_status = FLAG_BASE;
947         
948         if(!flag.model) { flag.model = ((teamnumber) ? autocvar_g_ctf_flag_red_model : autocvar_g_ctf_flag_blue_model); }
949         if(!flag.scale) { flag.scale = FLAG_SCALE; }
950         if(!flag.skin) { flag.skin = ((teamnumber) ? autocvar_g_ctf_flag_red_skin : autocvar_g_ctf_flag_blue_skin); }
951         if(!flag.toucheffect) { flag.toucheffect = ((teamnumber) ? "redflag_touch" : "blueflag_touch"); }
952         
953         // sound 
954         if(!flag.snd_flag_taken) { flag.snd_flag_taken  = ((teamnumber) ? "ctf/red_taken.wav" : "ctf/blue_taken.wav"); }
955         if(!flag.snd_flag_returned) { flag.snd_flag_returned = ((teamnumber) ? "ctf/red_returned.wav" : "ctf/blue_returned.wav"); }
956         if(!flag.snd_flag_capture) { flag.snd_flag_capture = ((teamnumber) ? "ctf/red_capture.wav" : "ctf/blue_capture.wav"); } // blue team scores by capturing the red flag
957         if(!flag.snd_flag_respawn) { flag.snd_flag_respawn = "ctf/flag_respawn.wav"; } // if there is ever a team-based sound for this, update the code to match.
958         if(!flag.snd_flag_dropped) { flag.snd_flag_dropped = ((teamnumber) ? "ctf/red_dropped.wav" : "ctf/blue_dropped.wav"); }
959         if(!flag.snd_flag_touch) { flag.snd_flag_touch = "ctf/touch.wav"; } // again has no team-based sound
960         if(!flag.snd_flag_pass) { flag.snd_flag_pass = "ctf/pass.wav"; } // same story here
961         
962         // precache
963         precache_sound(flag.snd_flag_taken);
964         precache_sound(flag.snd_flag_returned);
965         precache_sound(flag.snd_flag_capture);
966         precache_sound(flag.snd_flag_respawn);
967         precache_sound(flag.snd_flag_dropped);
968         precache_sound(flag.snd_flag_touch);
969         precache_sound(flag.snd_flag_pass);
970         precache_model(flag.model);
971         precache_model("models/ctf/shield.md3");
972         precache_model("models/ctf/shockwavetransring.md3");
973
974         // appearence
975         setmodel(flag, flag.model); // precision set below
976         setsize(flag, FLAG_MIN, FLAG_MAX);
977         setorigin(flag, (flag.origin + FLAG_SPAWN_OFFSET));
978         
979         if(autocvar_g_ctf_flag_glowtrails)
980         {
981                 flag.glow_color = ((teamnumber) ? 251 : 210); // 251: red - 210: blue
982                 flag.glow_size = 25;
983                 flag.glow_trail = 1;
984         }
985         
986         flag.effects |= EF_LOWPRECISION;
987         if(autocvar_g_ctf_fullbrightflags) { flag.effects |= EF_FULLBRIGHT; }
988         if(autocvar_g_ctf_dynamiclights)   { flag.effects |= ((teamnumber) ? EF_RED : EF_BLUE); }
989         
990         // flag placement
991         if((flag.spawnflags & 1) || flag.noalign) // don't drop to floor, just stay at fixed location
992         {       
993                 flag.dropped_origin = flag.origin; 
994                 flag.noalign = TRUE;
995                 flag.movetype = MOVETYPE_NONE;
996         }
997         else // drop to floor, automatically find a platform and set that as spawn origin
998         { 
999                 flag.noalign = FALSE;
1000                 self = flag;
1001                 droptofloor();
1002                 flag.movetype = MOVETYPE_TOSS; 
1003         }       
1004         
1005         InitializeEntity(flag, ctf_DelayedFlagSetup, INITPRIO_SETLOCATION);
1006 }
1007
1008
1009 // ==============
1010 // Hook Functions
1011 // ==============
1012
1013 MUTATOR_HOOKFUNCTION(ctf_PlayerPreThink)
1014 {
1015         entity flag;
1016         
1017         // initially clear items so they can be set as necessary later.
1018         self.items &~= (IT_RED_FLAG_CARRYING | IT_RED_FLAG_TAKEN | IT_RED_FLAG_LOST 
1019                 | IT_BLUE_FLAG_CARRYING | IT_BLUE_FLAG_TAKEN | IT_BLUE_FLAG_LOST | IT_CTF_SHIELDED);
1020
1021         // scan through all the flags and notify the client about them 
1022         for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
1023         {
1024                 switch(flag.ctf_status)
1025                 {
1026                         case FLAG_CARRY:
1027                         {
1028                                 if(flag.owner == self)
1029                                         self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_CARRYING : IT_BLUE_FLAG_CARRYING); // carrying: self is currently carrying the flag
1030                                 else 
1031                                         self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_TAKEN : IT_BLUE_FLAG_TAKEN); // taken: someone on self's team is carrying the flag
1032                                 break;
1033                         }
1034                         case FLAG_DROPPED:
1035                         {
1036                                 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_LOST : IT_BLUE_FLAG_LOST); // lost: the flag is dropped somewhere on the map
1037                                 break;
1038                         }
1039                 }
1040         }
1041         
1042         // item for stopping players from capturing the flag too often
1043         if(self.ctf_captureshielded)
1044                 self.items |= IT_CTF_SHIELDED;
1045         
1046         // update the health of the flag carrier waypointsprite
1047         if(self.wps_flagcarrier) 
1048                 WaypointSprite_UpdateHealth(self.wps_flagcarrier, self.health);
1049         
1050         return 0;
1051 }
1052
1053 MUTATOR_HOOKFUNCTION(ctf_PlayerDamage) // for changing damage and force values that are applied to players in g_damage.qc
1054 {
1055         if(frag_attacker.flagcarried) // if the attacker is a flagcarrier
1056         {
1057                 if(frag_target == frag_attacker) // damage done to yourself
1058                 {
1059                         frag_damage *= autocvar_g_ctf_flagcarrier_selfdamagefactor;
1060                         frag_force *= autocvar_g_ctf_flagcarrier_selfforcefactor;
1061                 }
1062                 else // damage done to everyone else
1063                 {
1064                         frag_damage *= autocvar_g_ctf_flagcarrier_damagefactor;
1065                         frag_force *= autocvar_g_ctf_flagcarrier_forcefactor;
1066                 }
1067         }
1068         else if(frag_target.flagcarried && (frag_target.deadflag == DEAD_NO) && IsDifferentTeam(frag_target, frag_attacker)) // if the target is a flagcarrier
1069         {
1070                 if(autocvar_g_ctf_flagcarrier_auto_helpme_when_damaged > frag_target.health)
1071                         WaypointSprite_HelpMePing(frag_target.wps_flagcarrier); // TODO: only do this if there is a significant loss of health?
1072         }
1073         return 0;
1074 }
1075
1076 MUTATOR_HOOKFUNCTION(ctf_PlayerDies)
1077 {
1078         if((frag_attacker != frag_target) && (frag_attacker.classname == "player") && (frag_target.flagcarried))
1079         {
1080                 PlayerTeamScore_AddScore(frag_attacker, ctf_ReadScore("score_kill"));
1081                 PlayerScore_Add(frag_attacker, SP_CTF_FCKILLS, 1);
1082         }
1083                                 
1084         if(frag_target.flagcarried)
1085                 { ctf_Handle_Throw(frag_target, world, DROP_NORMAL); }
1086                 
1087         return 0;
1088 }
1089
1090 MUTATOR_HOOKFUNCTION(ctf_GiveFragsForKill)
1091 {
1092         frag_score = 0;
1093         return (autocvar_g_ctf_ignore_frags); // no frags counted in ctf if this is true
1094 }
1095
1096 MUTATOR_HOOKFUNCTION(ctf_RemovePlayer)
1097 {
1098         if(self.flagcarried)
1099                 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
1100                 
1101         return 0;
1102 }
1103
1104 MUTATOR_HOOKFUNCTION(ctf_PortalTeleport)
1105 {
1106         if(self.flagcarried) 
1107         if(!autocvar_g_ctf_portalteleport)
1108                 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
1109
1110         return 0;
1111 }
1112
1113 MUTATOR_HOOKFUNCTION(ctf_PlayerUseKey)
1114 {
1115         entity player = self;
1116
1117         if((time > player.throw_antispam) && (player.deadflag == DEAD_NO) && !player.speedrunning && (!player.vehicle || autocvar_g_ctf_allow_vehicle_touch))
1118         {
1119                 // pass the flag to a team mate
1120                 if(autocvar_g_ctf_pass)
1121                 {
1122                         entity head, closest_target;
1123                         head = WarpZone_FindRadius(player.origin, autocvar_g_ctf_pass_radius, TRUE);
1124                         
1125                         while(head) // find the closest acceptable target to pass to
1126                         {
1127                                 if(head.classname == "player" && head.deadflag == DEAD_NO)
1128                                 if(head != player && !IsDifferentTeam(head, player))
1129                                 if(!head.speedrunning && (!head.vehicle || autocvar_g_ctf_allow_vehicle_touch))
1130                                 {
1131                                         if(autocvar_g_ctf_pass_request && !player.flagcarried && head.flagcarried) 
1132                                         { 
1133                                                 if(clienttype(head) == CLIENTTYPE_BOT)
1134                                                 {
1135                                                         centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname)); 
1136                                                         ctf_Handle_Throw(head, player, DROP_PASS);
1137                                                 }
1138                                                 else
1139                                                 {
1140                                                         centerprint(head, strcat(player.netname, " requests you to pass the ", head.flagcarried.netname)); 
1141                                                         centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname)); 
1142                                                 }
1143                                                 player.throw_antispam = time + autocvar_g_ctf_pass_wait; 
1144                                                 return 0; 
1145                                         }
1146                                         else if(player.flagcarried)
1147                                         {
1148                                                 if(closest_target)
1149                                                 {
1150                                                         if(vlen(player.origin - WarpZone_RefSys_TransformOrigin(player, head, head.origin)) < vlen(player.origin - WarpZone_RefSys_TransformOrigin(player, head, closest_target.origin)))
1151                                                                 { closest_target = head; }
1152                                                 }
1153                                                 else { closest_target = head; }
1154                                         }
1155                                 }
1156                                 head = head.chain;
1157                         }
1158                         
1159                         if(closest_target) { ctf_Handle_Throw(player, closest_target, DROP_PASS); return 0; }
1160                 }
1161                 
1162                 // throw the flag in front of you
1163                 if(autocvar_g_ctf_drop && player.flagcarried)
1164                         { ctf_Handle_Throw(player, world, DROP_THROW); }
1165         }
1166                 
1167         return 0;
1168 }
1169
1170 MUTATOR_HOOKFUNCTION(ctf_HelpMePing)
1171 {
1172         if(self.wps_flagcarrier) // update the flagcarrier waypointsprite with "NEEDING HELP" notification
1173         {
1174                 WaypointSprite_HelpMePing(self.wps_flagcarrier);
1175         } 
1176         else // create a normal help me waypointsprite
1177         {
1178                 WaypointSprite_Spawn("helpme", waypointsprite_deployed_lifetime, waypointsprite_limitedrange, self, FLAG_WAYPOINT_OFFSET, world, self.team, self, wps_helpme, FALSE, RADARICON_HELPME, '1 0.5 0');
1179                 WaypointSprite_Ping(self.wps_helpme);
1180         }
1181
1182         return 1;
1183 }
1184
1185 MUTATOR_HOOKFUNCTION(ctf_VehicleEnter)
1186 {
1187         if(other.flagcarried)
1188         {
1189                 if(!autocvar_g_ctf_flagcarrier_allow_vehicle_carry)
1190                 {
1191                         ctf_Handle_Throw(self, world, DROP_NORMAL);
1192                 }
1193                 else
1194                 {            
1195                         setattachment(other.flagcarried, self, ""); 
1196                         setorigin(other, VEHICLE_FLAG_OFFSET);
1197                         other.flagcarried.scale = VEHICLE_FLAG_SCALE;
1198                         //other.flagcarried.angles = '0 0 0';   
1199                 }
1200         }
1201                 
1202         return 0;
1203 }
1204
1205 MUTATOR_HOOKFUNCTION(ctf_VehicleExit)
1206 {
1207         if(self.owner.flagcarried)
1208         {
1209                 setattachment(self.owner.flagcarried, self.owner, ""); 
1210                 setorigin(self.owner.flagcarried, FLAG_CARRY_OFFSET);
1211                 self.owner.flagcarried.scale = FLAG_SCALE;
1212                 self.owner.flagcarried.angles = '0 0 0';        
1213         }
1214
1215         return 0;
1216 }
1217
1218 MUTATOR_HOOKFUNCTION(ctf_AbortSpeedrun)
1219 {
1220         if(self.flagcarried)
1221         {
1222                 bprint("The ", self.flagcarried.netname, " was returned to base by its carrier\n");
1223                 ctf_RespawnFlag(self);
1224         }
1225         
1226         return 0;
1227 }
1228
1229 MUTATOR_HOOKFUNCTION(ctf_MatchEnd)
1230 {
1231         entity flag; // temporary entity for the search method
1232         
1233         for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
1234         {
1235                 switch(flag.ctf_status)
1236                 {
1237                         case FLAG_DROPPED:
1238                         case FLAG_PASSING:
1239                         {
1240                                 // lock the flag, game is over
1241                                 flag.movetype = MOVETYPE_NONE;
1242                                 flag.takedamage = DAMAGE_NO;
1243                                 flag.solid = SOLID_NOT;
1244                                 flag.nextthink = 0; // stop thinking
1245                                 
1246                                 print("stopping the ", flag.netname, " from moving.\n");
1247                                 break;
1248                         }
1249                         
1250                         default:
1251                         case FLAG_BASE:
1252                         case FLAG_CARRY:
1253                         {
1254                                 // do nothing for these flags
1255                                 break;
1256                         }
1257                 }
1258         }
1259         
1260         return 0;
1261 }
1262
1263
1264 // ==========
1265 // Spawnfuncs
1266 // ==========
1267
1268 /*QUAKED spawnfunc_info_player_team1 (1 0 0) (-16 -16 -24) (16 16 24)
1269 CTF Starting point for a player in team one (Red).
1270 Keys: "angle" viewing angle when spawning. */
1271 void spawnfunc_info_player_team1()
1272 {
1273         if(g_assault) { remove(self); return; }
1274         
1275         self.team = COLOR_TEAM1; // red
1276         spawnfunc_info_player_deathmatch();
1277 }
1278
1279
1280 /*QUAKED spawnfunc_info_player_team2 (1 0 0) (-16 -16 -24) (16 16 24)
1281 CTF Starting point for a player in team two (Blue).
1282 Keys: "angle" viewing angle when spawning. */
1283 void spawnfunc_info_player_team2()
1284 {
1285         if(g_assault) { remove(self); return; }
1286         
1287         self.team = COLOR_TEAM2; // blue
1288         spawnfunc_info_player_deathmatch();
1289 }
1290
1291 /*QUAKED spawnfunc_info_player_team3 (1 0 0) (-16 -16 -24) (16 16 24)
1292 CTF Starting point for a player in team three (Yellow).
1293 Keys: "angle" viewing angle when spawning. */
1294 void spawnfunc_info_player_team3()
1295 {
1296         if(g_assault) { remove(self); return; }
1297         
1298         self.team = COLOR_TEAM3; // yellow
1299         spawnfunc_info_player_deathmatch();
1300 }
1301
1302
1303 /*QUAKED spawnfunc_info_player_team4 (1 0 0) (-16 -16 -24) (16 16 24)
1304 CTF Starting point for a player in team four (Purple).
1305 Keys: "angle" viewing angle when spawning. */
1306 void spawnfunc_info_player_team4()
1307 {
1308         if(g_assault) { remove(self); return; }
1309         
1310         self.team = COLOR_TEAM4; // purple
1311         spawnfunc_info_player_deathmatch();
1312 }
1313
1314 /*QUAKED spawnfunc_item_flag_team1 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1315 CTF flag for team one (Red).
1316 Keys: 
1317 "angle" Angle the flag will point (minus 90 degrees)... 
1318 "model" model to use, note this needs red and blue as skins 0 and 1...
1319 "noise" sound played when flag is picked up...
1320 "noise1" sound played when flag is returned by a teammate...
1321 "noise2" sound played when flag is captured...
1322 "noise3" sound played when flag is lost in the field and respawns itself... 
1323 "noise4" sound played when flag is dropped by a player...
1324 "noise5" sound played when flag touches the ground... */
1325 void spawnfunc_item_flag_team1()
1326 {
1327         if(!g_ctf) { remove(self); return; }
1328
1329         ctf_FlagSetup(1, self); // 1 = red
1330 }
1331
1332 /*QUAKED spawnfunc_item_flag_team2 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1333 CTF flag for team two (Blue).
1334 Keys: 
1335 "angle" Angle the flag will point (minus 90 degrees)... 
1336 "model" model to use, note this needs red and blue as skins 0 and 1...
1337 "noise" sound played when flag is picked up...
1338 "noise1" sound played when flag is returned by a teammate...
1339 "noise2" sound played when flag is captured...
1340 "noise3" sound played when flag is lost in the field and respawns itself... 
1341 "noise4" sound played when flag is dropped by a player...
1342 "noise5" sound played when flag touches the ground... */
1343 void spawnfunc_item_flag_team2()
1344 {
1345         if(!g_ctf) { remove(self); return; }
1346
1347         ctf_FlagSetup(0, self); // the 0 is misleading, but -- 0 = blue.
1348 }
1349
1350 /*QUAKED spawnfunc_ctf_team (0 .5 .8) (-16 -16 -24) (16 16 32)
1351 Team declaration for CTF gameplay, this allows you to decide what team names and control point models are used in your map.
1352 Note: If you use spawnfunc_ctf_team entities you must define at least 2!  However, unlike domination, you don't need to make a blank one too.
1353 Keys:
1354 "netname" Name of the team (for example Red, Blue, Green, Yellow, Life, Death, Offense, Defense, etc)...
1355 "cnt" Scoreboard color of the team (for example 4 is red and 13 is blue)... */
1356 void spawnfunc_ctf_team()
1357 {
1358         if(!g_ctf) { remove(self); return; }
1359         
1360         self.classname = "ctf_team";
1361         self.team = self.cnt + 1;
1362 }
1363
1364
1365 // ==============
1366 // Initialization
1367 // ==============
1368
1369 // code from here on is just to support maps that don't have flag and team entities
1370 void ctf_SpawnTeam (string teamname, float teamcolor)
1371 {
1372         entity oldself;
1373         oldself = self;
1374         self = spawn();
1375         self.classname = "ctf_team";
1376         self.netname = teamname;
1377         self.cnt = teamcolor;
1378
1379         spawnfunc_ctf_team();
1380
1381         self = oldself;
1382 }
1383
1384 void ctf_DelayedInit() // Do this check with a delay so we can wait for teams to be set up.
1385 {
1386         // if no teams are found, spawn defaults
1387         if(find(world, classname, "ctf_team") == world)
1388         {
1389                 print("No ""ctf_team"" entities found on this map, creating them anyway.\n");
1390                 ctf_SpawnTeam("Red", COLOR_TEAM1 - 1);
1391                 ctf_SpawnTeam("Blue", COLOR_TEAM2 - 1);
1392         }
1393         
1394         ScoreRules_ctf();
1395 }
1396
1397 void ctf_Initialize()
1398 {
1399         ctf_captimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));
1400
1401         ctf_captureshield_min_negscore = autocvar_g_ctf_shield_min_negscore;
1402         ctf_captureshield_max_ratio = autocvar_g_ctf_shield_max_ratio;
1403         ctf_captureshield_force = autocvar_g_ctf_shield_force;
1404         
1405         InitializeEntity(world, ctf_DelayedInit, INITPRIO_GAMETYPE);
1406 }
1407
1408
1409 MUTATOR_DEFINITION(gamemode_ctf)
1410 {
1411         MUTATOR_HOOK(MakePlayerObserver, ctf_RemovePlayer, CBC_ORDER_ANY);
1412         MUTATOR_HOOK(ClientDisconnect, ctf_RemovePlayer, CBC_ORDER_ANY);
1413         MUTATOR_HOOK(PlayerDies, ctf_PlayerDies, CBC_ORDER_ANY);
1414         MUTATOR_HOOK(MatchEnd, ctf_MatchEnd, CBC_ORDER_ANY);
1415         MUTATOR_HOOK(PortalTeleport, ctf_PortalTeleport, CBC_ORDER_ANY);
1416         MUTATOR_HOOK(GiveFragsForKill, ctf_GiveFragsForKill, CBC_ORDER_ANY);
1417         MUTATOR_HOOK(PlayerPreThink, ctf_PlayerPreThink, CBC_ORDER_ANY);
1418         MUTATOR_HOOK(PlayerDamage_Calculate, ctf_PlayerDamage, CBC_ORDER_ANY);
1419         MUTATOR_HOOK(PlayerUseKey, ctf_PlayerUseKey, CBC_ORDER_ANY);
1420         MUTATOR_HOOK(HelpMePing, ctf_HelpMePing, CBC_ORDER_ANY);
1421         MUTATOR_HOOK(VehicleEnter, ctf_VehicleEnter, CBC_ORDER_ANY);
1422         MUTATOR_HOOK(VehicleExit, ctf_VehicleExit, CBC_ORDER_ANY);
1423         MUTATOR_HOOK(AbortSpeedrun, ctf_AbortSpeedrun, CBC_ORDER_ANY);
1424         
1425         MUTATOR_ONADD
1426         {
1427                 if(time > 1) // game loads at time 1
1428                         error("This is a game type and it cannot be added at runtime.");
1429                 g_ctf = 1;
1430                 ctf_Initialize();
1431         }
1432
1433         MUTATOR_ONREMOVE
1434         {
1435                 g_ctf = 0;
1436                 error("This is a game type and it cannot be removed at runtime.");
1437         }
1438
1439         return 0;
1440 }