]> de.git.xonotic.org Git - xonotic/xonotic-data.pk3dir.git/blob - qcsrc/server/mutators/gamemode_ctf.qc
More waypoint_for_enemy flagcarrier stuff, plus some cleanups/tweaks
[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, "keepaway/respawn.wav", VOL_BASE, ATTN_NORM);
230         ctf_EventLog("recieve", flag.team, player);
231         FOR_EACH_PLAYER(tmp_player)
232                 if(tmp_player == sender)
233                         centerprint(tmp_player, strcat("You passed the ", flag.netname, " to ", player.netname));
234                 else if(tmp_player == player)
235                         centerprint(tmp_player, strcat("You recieved the ", flag.netname, " from ", sender.netname));
236                 else if(!IsDifferentTeam(tmp_player, sender))
237                         centerprint(tmp_player, strcat(sender.netname, " passed the ", flag.netname, " to ", player.netname));
238         
239         // create new waypoint
240         ctf_FlagcarrierWaypoints(player);
241         
242         sender.throw_antispam = time + autocvar_g_ctf_pass_wait;
243         player.throw_antispam = sender.throw_antispam;
244         
245         flag.pass_sender = world;
246         flag.pass_target = world;
247 }
248
249 void ctf_Handle_Throw(entity player, entity reciever, float droptype)
250 {
251         entity flag = player.flagcarried;
252         
253         if(!flag) { return; }
254         if((droptype == DROP_PASS) && !reciever) { return; }
255         
256         if(flag.speedrunning) { ctf_RespawnFlag(flag); return; }
257         
258         // reset the flag
259         setattachment(flag, world, "");
260         setorigin(flag, player.origin + FLAG_DROP_OFFSET);
261         flag.owner.flagcarried = world;
262         flag.owner = world;
263         flag.solid = SOLID_TRIGGER;
264         flag.ctf_droptime = time;
265         
266         flag.flags = FL_ITEM | FL_NOTARGET; // clear FL_ONGROUND for MOVETYPE_TOSS
267         
268         switch(droptype)
269         {
270                 case DROP_PASS:
271                 {
272                         vector targ_origin = (0.5 * (reciever.absmin + reciever.absmax));
273                         flag.velocity = (normalize(targ_origin - player.origin) * autocvar_g_ctf_pass_velocity);
274                         break;
275                 }
276                 
277                 case DROP_THROW:
278                 {
279                         makevectors((player.v_angle_y * '0 1 0') + (player.v_angle_x * '0.5 0 0'));
280                         flag.velocity = W_CalculateProjectileVelocity(player.velocity, ('0 0 200' + (v_forward * autocvar_g_ctf_drop_velocity)), FALSE);
281                         break;
282                 }
283                 
284                 case DROP_RESET:
285                 {
286                         flag.velocity = '0 0 0'; // do nothing
287                         break;
288                 }
289                 
290                 default:
291                 case DROP_NORMAL:
292                 {
293                         flag.velocity = ('0 0 200' + ('0 100 0' * crandom()) + ('100 0 0' * crandom()));
294                         break;
295                 }
296         }
297         
298         switch(droptype)
299         {
300                 case DROP_PASS:
301                 {
302                         // main
303                         flag.movetype = MOVETYPE_FLY;
304                         flag.takedamage = DAMAGE_NO;
305                         flag.pass_sender = player;
306                         flag.pass_target = reciever;
307                         flag.ctf_status = FLAG_PASSING;
308                         
309                         // other
310                         sound(player, CH_TRIGGER, flag.snd_flag_touch, VOL_BASE, ATTN_NORM);
311                         ctf_EventLog("pass", flag.team, player);
312                         te_lightning2(world, reciever.origin, player.origin);
313                         break;
314                 }
315
316                 case DROP_RESET: 
317                 {
318                         // do nothing
319                         break;
320                 }
321                 
322                 default:
323                 case DROP_THROW:
324                 case DROP_NORMAL:
325                 {
326                         ctf_Handle_Drop(flag, player, droptype);
327                         break;
328                 }
329         }
330
331         // kill old waypointsprite
332         WaypointSprite_Ping(player.wps_flagcarrier);
333         WaypointSprite_Kill(player.wps_flagcarrier);
334         
335         if(player.wps_enemyflagcarrier)
336                         WaypointSprite_Kill(player.wps_enemyflagcarrier);
337         
338         // captureshield
339         //ctf_CaptureShield_Update(player, 0); // shield only
340 }
341
342
343 // ==============
344 // Event Handlers
345 // ==============
346
347 void ctf_Handle_Capture(entity flag, entity toucher, float capturetype)
348 {
349         entity enemy_flag = ((capturetype == CAPTURE_NORMAL) ? toucher.flagcarried : toucher);
350         entity player = ((capturetype == CAPTURE_NORMAL) ? toucher : enemy_flag.ctf_dropper);
351         
352         if not(player) { return; } // without someone to give the reward to, we can't possibly cap
353         
354         // messages and sounds
355         Send_KillNotification(player.netname, enemy_flag.netname, ctf_CaptureRecord(enemy_flag, player), INFO_CAPTUREFLAG, MSG_INFO);
356         sound(player, CH_TRIGGER, flag.snd_flag_capture, VOL_BASE, ATTN_NONE);
357         
358         switch(capturetype)
359         {
360                 case CAPTURE_NORMAL: ctf_EventLog("capture", enemy_flag.team, player); break;
361                 case CAPTURE_DROPPED: ctf_EventLog("droppedcapture", enemy_flag.team, player); break;
362                 default: break;
363         }
364         
365         // scoring
366         PlayerTeamScore_AddScore(player, ctf_ReadScore("score_capture"));
367         PlayerTeamScore_Add(player, SP_CTF_CAPS, ST_CTF_CAPS, 1);
368
369         // effects
370         if(autocvar_g_ctf_flag_capture_effects) 
371         {
372                 pointparticles(particleeffectnum((player.team == COLOR_TEAM1) ? "red_ground_quake" : "blue_ground_quake"), flag.origin, '0 0 0', 1);
373                 shockwave_spawn("models/ctf/shockwavetransring.md3", flag.origin - '0 0 15', -0.8, 0, 1);
374         }
375
376         // other
377         if(capturetype == CAPTURE_NORMAL)
378         {
379                 WaypointSprite_Kill(player.wps_flagcarrier);
380                 if(flag.speedrunning) { ctf_FakeTimeLimit(player, -1); }
381         }
382         
383         // reset the flag
384         player.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
385         ctf_RespawnFlag(enemy_flag);
386 }
387
388 void ctf_Handle_Return(entity flag, entity player)
389 {
390         // messages and sounds
391         //centerprint(player, strcat("You returned the ", flag.netname));
392         Send_KillNotification (player.netname, flag.netname, "", INFO_RETURNFLAG, MSG_INFO);
393         sound(player, CH_TRIGGER, flag.snd_flag_returned, VOL_BASE, ATTN_NONE);
394         ctf_EventLog("return", flag.team, player);
395
396         // scoring
397         PlayerTeamScore_AddScore(player, ctf_ReadScore("score_return")); // reward for return
398         PlayerScore_Add(player, SP_CTF_RETURNS, 1); // add to count of returns
399
400         TeamScore_AddToTeam(flag.ctf_dropper.team, ST_SCORE, -ctf_ReadScore("penalty_returned")); // punish the team who was last carrying it
401         FOR_EACH_PLAYER(player) if(player == flag.ctf_dropper) // punish the player who dropped the flag
402         {
403                 PlayerScore_Add(player, SP_SCORE, -ctf_ReadScore("penalty_returned"));
404                 ctf_CaptureShield_Update(player, 0); // shield only
405         }
406         
407         // reset the flag
408         flag.ctf_dropper.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
409         ctf_RespawnFlag(flag);
410 }
411
412 void ctf_Handle_Pickup(entity flag, entity player, float pickuptype)
413 {
414         // declarations
415         entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
416         string verbosename; // holds the name of the player OR no name at all for printing in the centerprints
417         float pickup_dropped_score; // used to calculate dropped pickup score
418         
419         // attach the flag to the player
420         flag.owner = player;
421         player.flagcarried = flag;
422         setattachment(flag, player, "");
423         setorigin(flag, FLAG_CARRY_OFFSET);
424         
425         // flag setup
426         flag.movetype = MOVETYPE_NONE;
427         flag.takedamage = DAMAGE_NO;
428         flag.solid = SOLID_NOT;
429         flag.angles = '0 0 0';
430         flag.ctf_carrier = player;
431         flag.ctf_status = FLAG_CARRY;
432         
433         switch(pickuptype)
434         {
435                 case PICKUP_BASE: flag.ctf_pickuptime = time; break; // used for timing runs
436                 case PICKUP_DROPPED: flag.health = flag.max_flag_health; break; // reset health/return timelimit
437                 default: break;
438         }
439
440         // messages and sounds
441         Send_KillNotification (player.netname, flag.netname, "", INFO_GOTFLAG, MSG_INFO);
442         sound(player, CH_TRIGGER, flag.snd_flag_taken, VOL_BASE, ATTN_NONE);
443         verbosename = ((autocvar_g_ctf_flag_pickup_verbosename) ? strcat(Team_ColorCode(player.team), "(^7", player.netname, Team_ColorCode(player.team), ") ") : "");
444         
445         FOR_EACH_PLAYER(tmp_player)
446                 if(tmp_player == player)
447                         centerprint(tmp_player, strcat("You got the ", flag.netname, "!"));
448                 else if(!IsDifferentTeam(tmp_player, player))
449                         centerprint(tmp_player, strcat("Your ", Team_ColorCode(player.team), "team mate ", verbosename, "^7got the flag! Protect them!"));
450                 else if(!IsDifferentTeam(tmp_player, flag))
451                         centerprint(tmp_player, strcat("The ", Team_ColorCode(player.team), "enemy ", verbosename, "^7got your flag! Retrieve it!"));
452                         
453         switch(pickuptype)
454         {
455                 case PICKUP_BASE: ctf_EventLog("steal", flag.team, player); break;
456                 case PICKUP_DROPPED: ctf_EventLog("pickup", flag.team, player); break;
457                 default: break;
458         }
459         
460         // scoring
461         PlayerScore_Add(player, SP_CTF_PICKUPS, 1);
462         switch(pickuptype)
463         {               
464                 case PICKUP_BASE:
465                 {
466                         PlayerTeamScore_AddScore(player, ctf_ReadScore("score_pickup_base"));
467                         break;
468                 }
469                 
470                 case PICKUP_DROPPED:
471                 {
472                         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);
473                         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);
474                         print("pickup_dropped_score is ", ftos(pickup_dropped_score), "\n");
475                         PlayerTeamScore_AddScore(player, pickup_dropped_score);
476                         break;
477                 }
478                 
479                 default: break;
480         }
481         
482         // speedrunning
483         if(pickuptype == PICKUP_BASE)
484         {
485                 flag.speedrunning = player.speedrunning; // if speedrunning, flag will flag-return and teleport the owner back after the record
486                 if((player.speedrunning) && (ctf_captimerecord))
487                         ctf_FakeTimeLimit(player, time + ctf_captimerecord);
488         }
489                 
490         // effects
491         if(autocvar_g_ctf_flag_pickup_effects)
492                 pointparticles(particleeffectnum("smoke_ring"), 0.5 * (flag.absmin + flag.absmax), '0 0 0', 1);
493         
494         // waypoints 
495         if(pickuptype == PICKUP_DROPPED) { WaypointSprite_Kill(flag.wps_flagdropped); }
496         ctf_FlagcarrierWaypoints(player);
497         WaypointSprite_Ping(player.wps_flagcarrier);
498 }
499
500
501 // ===================
502 // Main Flag Functions
503 // ===================
504
505 void ctf_CheckFlagReturn(entity flag)
506 {
507         if(flag.wps_flagdropped) { WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health); }
508         
509         if((flag.health <= 0) || (time >= flag.ctf_droptime + autocvar_g_ctf_flag_return_time))
510         {
511                 bprint("The ", flag.netname, " has returned to base\n");
512                 sound(flag, CH_TRIGGER, flag.snd_flag_respawn, VOL_BASE, ATTN_NONE);
513                 ctf_EventLog("returned", flag.team, world);
514                 ctf_RespawnFlag(flag);
515         }
516 }
517
518 void ctf_FlagDamage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
519 {
520         if(ITEM_DAMAGE_NEEDKILL(deathtype))
521         {
522                 // automatically kill the flag and return it
523                 self.health = 0;
524                 ctf_CheckFlagReturn(self);
525                 return;
526         }
527         
528         if(autocvar_g_ctf_flag_return_damage) 
529         {
530                 self.health = self.health - damage;
531                 ctf_CheckFlagReturn(self);
532                 return;
533         }
534 }
535
536 void ctf_FlagThink()
537 {
538         // declarations
539         entity tmp_entity;
540
541         self.nextthink = time + FLAG_THINKRATE; // only 5 fps, more is unnecessary.
542
543         // captureshield
544         if(self == ctf_worldflaglist) // only for the first flag
545                 FOR_EACH_CLIENT(tmp_entity)
546                         ctf_CaptureShield_Update(tmp_entity, 1); // release shield only
547
548         // sanity checks
549         if(self.mins != FLAG_MIN || self.maxs != FLAG_MAX) { // reset the flag boundaries in case it got squished
550                 dprint("wtf the flag got squashed?\n");
551                 tracebox(self.origin, FLAG_MIN, FLAG_MAX, self.origin, MOVE_NOMONSTERS, self);
552                 if(!trace_startsolid) // can we resize it without getting stuck?
553                         setsize(self, FLAG_MIN, FLAG_MAX); }
554
555         // main think method
556         switch(self.ctf_status)
557         {       
558                 case FLAG_BASE:
559                 {
560                         if(autocvar_g_ctf_dropped_capture_radius)
561                         {
562                                 for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
563                                         if(tmp_entity.ctf_status == FLAG_DROPPED)
564                                                 if(vlen(self.origin - tmp_entity.origin) < autocvar_g_ctf_dropped_capture_radius)
565                                                         ctf_Handle_Capture(self, tmp_entity, CAPTURE_DROPPED);
566                         }
567                         return;
568                 }
569                 
570                 case FLAG_DROPPED:
571                 {
572                         if(autocvar_g_ctf_flag_return_dropped)
573                         {
574                                 if((vlen(self.origin - self.ctf_spawnorigin) <= autocvar_g_ctf_flag_return_dropped) || (autocvar_g_ctf_flag_return_dropped == -1))
575                                 {
576                                         self.health = 0;
577                                         ctf_CheckFlagReturn(self);
578                                         return;
579                                 }
580                         }
581                         if(autocvar_g_ctf_flag_return_time)
582                         {
583                                 self.health -= ((self.max_flag_health / autocvar_g_ctf_flag_return_time) * FLAG_THINKRATE);
584                                 ctf_CheckFlagReturn(self);
585                                 return;
586                         } 
587                         return;
588                 }
589                         
590                 case FLAG_CARRY:
591                 {
592                         if(self.speedrunning && ctf_captimerecord && (time >= self.ctf_pickuptime + ctf_captimerecord)) 
593                         {
594                                 bprint("The ", self.netname, " became impatient after ", ftos_decimals(ctf_captimerecord, 2), " seconds and returned itself\n");
595                                 sound(self, CH_TRIGGER, self.snd_flag_respawn, VOL_BASE, ATTN_NONE);
596                                 ctf_EventLog("returned", self.team, world);
597                                 ctf_RespawnFlag(tmp_entity);
598
599                                 tmp_entity = self;
600                                 self = self.owner;
601                                 self.impulse = CHIMPULSE_SPEEDRUN; // move the player back to the waypoint they set
602                                 ImpulseCommands();
603                                 self = tmp_entity;
604                         }
605                         
606                         if(autocvar_g_ctf_flagcarrier_waypointforenemy_time)
607                         if((time >= self.ctf_pickuptime + autocvar_g_ctf_flagcarrier_waypointforenemy_time) && !self.owner.wps_enemyflagcarrier)
608                         {
609                                 WaypointSprite_Spawn("enemyflagcarrier", 0, 0, self.owner, FLAG_WAYPOINT_OFFSET, world, self.team, self.owner, wps_enemyflagcarrier, TRUE, RADARICON_FLAG, WPCOLOR_ENEMYFC(self.owner.team));
610                                 
611                                 if(!self.wpforenemy_announced)
612                                 {
613                                         FOR_EACH_PLAYER(tmp_entity)
614                                                 if(tmp_entity == self.owner)
615                                                         centerprint(tmp_entity, strcat("Enemies can now see you on radar! (held ", self.netname, " for ", ftos(autocvar_g_ctf_flagcarrier_waypointforenemy_time), " seconds)"));
616                                                 else if(!IsDifferentTeam(tmp_entity, self.owner))
617                                                         centerprint(tmp_entity, strcat("Enemies can now see your flag carrier on radar! (held ", self.netname, " for ", ftos(autocvar_g_ctf_flagcarrier_waypointforenemy_time), " seconds)"));
618                                                 else if(!IsDifferentTeam(tmp_entity, self))
619                                                         centerprint(tmp_entity, strcat("You can now see the enemy flag carrier on radar! (held ", self.netname, " for ", ftos(autocvar_g_ctf_flagcarrier_waypointforenemy_time), " seconds)"));
620                                         
621                                         self.wpforenemy_announced = TRUE;
622                                 }
623                         }
624                                         
625                         return;
626                 }
627                 
628                 case FLAG_PASSING: // todo make work with warpzones
629                 {                       
630                         vector targ_origin = ((self.pass_target.absmin + self.pass_target.absmax) * 0.5);
631                         
632                         traceline(self.origin, targ_origin, MOVE_NOMONSTERS, self);
633                         
634                         if((self.pass_target.deadflag != DEAD_NO)
635                                 || (vlen(self.origin - targ_origin) > autocvar_g_ctf_pass_radius)
636                                 || ((trace_fraction < 1) && (trace_ent != self.pass_target))
637                                 || (time > self.ctf_droptime + autocvar_g_ctf_pass_timelimit))
638                         {
639                                 ctf_Handle_Drop(self, world, DROP_PASS);
640                         }
641                         else // still a viable target, go for it
642                         {
643                                 vector desired_direction = normalize(targ_origin - self.origin);
644                                 vector current_direction = normalize(self.velocity);
645                                 
646                                 self.velocity = (normalize(current_direction + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_pass_velocity); 
647                         }
648                         return;
649                 }
650
651                 default: // this should never happen
652                 {
653                         dprint("ctf_FlagThink(): Flag exists with no status?\n");
654                         return;
655                 }
656         }
657 }
658
659 void ctf_FlagTouch()
660 {
661         if(gameover) { return; }
662         if(!self) { return; }
663         if(other.deadflag != DEAD_NO) { return; }
664         if(ITEM_TOUCH_NEEDKILL())
665         {
666                 // automatically kill the flag and return it
667                 self.health = 0;
668                 ctf_CheckFlagReturn(self);
669                 return;
670         }
671         if(other.classname != "player") // The flag just touched an object, most likely the world
672         {
673                 if(time > self.wait) // if we haven't in a while, play a sound/effect
674                 {
675                         pointparticles(particleeffectnum("kaball_sparks"), self.origin, '0 0 0', 1);
676                         sound(self, CH_TRIGGER, self.snd_flag_touch, VOL_BASE, ATTN_NORM);
677                         self.wait = time + FLAG_TOUCHRATE;
678                 }
679                 return;
680         }
681
682         switch(self.ctf_status) 
683         {       
684                 case FLAG_BASE:
685                 {
686                         if(!IsDifferentTeam(other, self) && (other.flagcarried) && IsDifferentTeam(other.flagcarried, self))
687                                 ctf_Handle_Capture(self, other, CAPTURE_NORMAL); // other just captured the enemies flag to his base
688                         else if(IsDifferentTeam(other, self) && (!other.flagcarried) && (!other.ctf_captureshielded) && (time > other.next_take_time))
689                                 ctf_Handle_Pickup(self, other, PICKUP_BASE); // other just stole the enemies flag
690                         break;
691                 }
692                 
693                 case FLAG_DROPPED:
694                 {
695                         if(!IsDifferentTeam(other, self))
696                                 ctf_Handle_Return(self, other); // other just returned his own flag
697                         else if((!other.flagcarried) && ((other != self.ctf_dropper) || (time > self.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
698                                 ctf_Handle_Pickup(self, other, PICKUP_DROPPED); // other just picked up a dropped enemy flag
699                         break;
700                 }
701                         
702                 case FLAG_CARRY:
703                 {
704                         dprint("Someone touched a flag even though it was being carried?\n");
705                         break;
706                 }
707                 
708                 case FLAG_PASSING:
709                 {
710                         if((other.classname == "player") && (other.deadflag == DEAD_NO) && (other != self.pass_sender))
711                         {
712                                 if(IsDifferentTeam(other, self.pass_sender))
713                                         ctf_Handle_Return(self, other);
714                                 else
715                                         ctf_Handle_Retrieve(self, other);
716                         }
717                         break;
718                 }
719                 
720                 default: // this should never happen
721                 {
722                         dprint("Touch: Flag exists with no status?\n");
723                         break;
724                 }
725         }
726 }
727
728 void ctf_RespawnFlag(entity flag)
729 {
730         // reset the player (if there is one)
731         if((flag.owner) && (flag.owner.flagcarried == flag))
732         {
733                 if(flag.owner.wps_enemyflagcarrier)
734                         WaypointSprite_Kill(flag.owner.wps_enemyflagcarrier);
735                         
736                 WaypointSprite_Kill(flag.wps_flagcarrier);
737                 
738                 flag.owner.flagcarried = world;
739
740                 if(flag.speedrunning)
741                         ctf_FakeTimeLimit(flag.owner, -1);
742         }
743
744         if((flag.ctf_status == FLAG_DROPPED) && (flag.wps_flagdropped))
745                 { WaypointSprite_Kill(flag.wps_flagdropped); }
746
747         // reset the flag
748         setattachment(flag, world, "");
749         setorigin(flag, flag.ctf_spawnorigin);
750         
751         flag.movetype = ((flag.noalign) ? MOVETYPE_NONE : MOVETYPE_TOSS);
752         flag.takedamage = DAMAGE_NO;
753         flag.health = flag.max_flag_health;
754         flag.solid = SOLID_TRIGGER;
755         flag.velocity = '0 0 0';
756         flag.angles = flag.mangle;
757         flag.flags = FL_ITEM | FL_NOTARGET;
758         
759         flag.ctf_status = FLAG_BASE;
760         flag.owner = world;
761         flag.pass_sender = world;
762         flag.pass_target = world;
763         flag.ctf_carrier = world;
764         flag.ctf_dropper = world;
765         flag.ctf_pickuptime = 0;
766         flag.ctf_droptime = 0;
767         flag.wpforenemy_announced = FALSE;
768 }
769
770 void ctf_Reset()
771 {
772         if(self.owner)
773                 if(self.owner.classname == "player")
774                         ctf_Handle_Throw(self.owner, world, DROP_RESET);
775                         
776         ctf_RespawnFlag(self);
777 }
778
779 void ctf_DelayedFlagSetup(void) // called after a flag is placed on a map by ctf_FlagSetup()
780 {
781         // bot waypoints
782         waypoint_spawnforitem_force(self, self.origin);
783         self.nearestwaypointtimeout = 0; // activate waypointing again
784         self.bot_basewaypoint = self.nearestwaypoint;
785
786         // waypointsprites
787         WaypointSprite_SpawnFixed(((self.team == COLOR_TEAM1) ? "redbase" : "bluebase"), self.origin + FLAG_WAYPOINT_OFFSET, self, wps_flagbase, RADARICON_FLAG, colormapPaletteColor(self.team - 1, FALSE));
788         WaypointSprite_UpdateTeamRadar(self.wps_flagbase, RADARICON_FLAG, colormapPaletteColor(self.team - 1, FALSE));
789
790         // captureshield setup
791         ctf_CaptureShield_Spawn(self);
792 }
793
794 void ctf_FlagSetup(float teamnumber, entity flag) // called when spawning a flag entity on the map as a spawnfunc 
795 {       
796         // declarations
797         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. 
798         self = flag; // for later usage with droptofloor()
799         
800         // main setup
801         flag.ctf_worldflagnext = ctf_worldflaglist; // link flag into ctf_worldflaglist
802         ctf_worldflaglist = flag;
803
804         setattachment(flag, world, ""); 
805
806         flag.netname = ((teamnumber) ? "^1RED^7 flag" : "^4BLUE^7 flag");
807         flag.team = ((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2); // COLOR_TEAM1: color 4 team (red) - COLOR_TEAM2: color 13 team (blue)
808         flag.items = ((teamnumber) ? IT_KEY2 : IT_KEY1); // IT_KEY2: gold key (redish enough) - IT_KEY1: silver key (bluish enough)
809         flag.classname = "item_flag_team";
810         flag.target = "###item###"; // wut?
811         flag.flags = FL_ITEM | FL_NOTARGET;
812         flag.solid = SOLID_TRIGGER;
813         flag.takedamage = DAMAGE_NO;
814         flag.damageforcescale = autocvar_g_ctf_flag_damageforcescale;   
815         flag.max_flag_health = ((autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health) ? autocvar_g_ctf_flag_health : 100);
816         flag.health = flag.max_flag_health;
817         flag.event_damage = ctf_FlagDamage;
818         flag.pushable = TRUE;
819         flag.damagedbytriggers = autocvar_g_ctf_flag_return_when_unreachable;
820         flag.damagedbycontents = autocvar_g_ctf_flag_return_when_unreachable;
821         flag.velocity = '0 0 0';
822         flag.mangle = flag.angles;
823         flag.reset = ctf_Reset;
824         flag.touch = ctf_FlagTouch;
825         flag.think = ctf_FlagThink;
826         flag.nextthink = time + FLAG_THINKRATE;
827         flag.ctf_status = FLAG_BASE;
828         
829         if(!flag.model) { flag.model = ((teamnumber) ? autocvar_g_ctf_flag_red_model : autocvar_g_ctf_flag_blue_model); }
830         if(!flag.scale) { flag.scale = FLAG_SCALE; }
831         if(!flag.skin) { flag.skin = ((teamnumber) ? autocvar_g_ctf_flag_red_skin : autocvar_g_ctf_flag_blue_skin); }
832         
833         // sound 
834         if(!flag.snd_flag_taken) { flag.snd_flag_taken  = ((teamnumber) ? "ctf/red_taken.wav" : "ctf/blue_taken.wav"); }
835         if(!flag.snd_flag_returned) { flag.snd_flag_returned = ((teamnumber) ? "ctf/red_returned.wav" : "ctf/blue_returned.wav"); }
836         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
837         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.
838         if(!flag.snd_flag_dropped) { flag.snd_flag_dropped = ((teamnumber) ? "ctf/red_dropped.wav" : "ctf/blue_dropped.wav"); }
839         if(!flag.snd_flag_touch) { flag.snd_flag_touch = "keepaway/touch.wav"; } // again has no team-based sound // FIXME
840         
841         // precache
842         precache_sound(flag.snd_flag_taken);
843         precache_sound(flag.snd_flag_returned);
844         precache_sound(flag.snd_flag_capture);
845         precache_sound(flag.snd_flag_respawn);
846         precache_sound(flag.snd_flag_dropped);
847         precache_sound(flag.snd_flag_touch);
848         precache_model(flag.model);
849         precache_model("models/ctf/shield.md3");
850         precache_model("models/ctf/shockwavetransring.md3");
851
852         // appearence
853         setmodel(flag, flag.model); // precision set below
854         setsize(flag, FLAG_MIN, FLAG_MAX);
855         setorigin(flag, (flag.origin + FLAG_SPAWN_OFFSET));
856         
857         if(autocvar_g_ctf_flag_glowtrails)
858         {
859                 flag.glow_color = ((teamnumber) ? 251 : 210); // 251: red - 210: blue
860                 flag.glow_size = 25;
861                 flag.glow_trail = 1;
862         }
863         
864         flag.effects |= EF_LOWPRECISION;
865         if(autocvar_g_ctf_fullbrightflags) { flag.effects |= EF_FULLBRIGHT; }
866         if(autocvar_g_ctf_dynamiclights)   { flag.effects |= ((teamnumber) ? EF_RED : EF_BLUE); }
867         
868         // flag placement
869         if((flag.spawnflags & 1) || flag.noalign) // don't drop to floor, just stay at fixed location
870         {       
871                 flag.dropped_origin = flag.origin; 
872                 flag.noalign = TRUE;
873                 flag.movetype = MOVETYPE_NONE;
874         }
875         else // drop to floor, automatically find a platform and set that as spawn origin
876         { 
877                 flag.noalign = FALSE;
878                 self = flag;
879                 droptofloor();
880                 flag.movetype = MOVETYPE_TOSS; 
881         }       
882         
883         InitializeEntity(flag, ctf_DelayedFlagSetup, INITPRIO_SETLOCATION);
884 }
885
886
887 // ==============
888 // Hook Functions
889 // ==============
890
891 MUTATOR_HOOKFUNCTION(ctf_RemovePlayer)
892 {
893         if(self.flagcarried)
894                 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
895                 
896         return 0;
897 }
898
899 MUTATOR_HOOKFUNCTION(ctf_PortalTeleport)
900 {
901         if(self.flagcarried) 
902         if(!autocvar_g_ctf_portalteleport)
903                 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
904
905         return 0;
906 }
907
908 MUTATOR_HOOKFUNCTION(ctf_PlayerPreThink)
909 {
910         entity flag;
911         
912         // initially clear items so they can be set as necessary later.
913         self.items &~= (IT_RED_FLAG_CARRYING | IT_RED_FLAG_TAKEN | IT_RED_FLAG_LOST 
914                 | IT_BLUE_FLAG_CARRYING | IT_BLUE_FLAG_TAKEN | IT_BLUE_FLAG_LOST | IT_CTF_SHIELDED);
915
916         // scan through all the flags and notify the client about them 
917         for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
918         {
919                 if(flag.ctf_status == FLAG_CARRY)
920                         if(flag.owner == self)
921                                 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_CARRYING : IT_BLUE_FLAG_CARRYING); // carrying: self is currently carrying the flag
922                         else 
923                                 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_TAKEN : IT_BLUE_FLAG_TAKEN); // taken: someone on self's team is carrying the flag
924                 else if(flag.ctf_status == FLAG_DROPPED) 
925                         self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_LOST : IT_BLUE_FLAG_LOST); // lost: the flag is dropped somewhere on the map
926         }
927         
928         // item for stopping players from capturing the flag too often
929         if(self.ctf_captureshielded)
930                 self.items |= IT_CTF_SHIELDED;
931         
932         // update the health of the flag carrier waypointsprite
933         if(self.wps_flagcarrier) 
934                 WaypointSprite_UpdateHealth(self.wps_flagcarrier, self.health);
935         
936         return 0;
937 }
938
939 MUTATOR_HOOKFUNCTION(ctf_PlayerDamage) // for changing damage and force values that are applied to players in g_damage.qc
940 {
941         if(frag_attacker.flagcarried) // if the attacker is a flagcarrier
942         {
943                 if(frag_target == frag_attacker) // damage done to yourself
944                 {
945                         frag_damage *= autocvar_g_ctf_flagcarrier_selfdamagefactor;
946                         frag_force *= autocvar_g_ctf_flagcarrier_selfforcefactor;
947                 }
948                 else // damage done everyone else
949                 {
950                         frag_damage *= autocvar_g_ctf_flagcarrier_damagefactor;
951                         frag_force *= autocvar_g_ctf_flagcarrier_forcefactor;
952                 }
953         }
954         return 0;
955 }
956
957 MUTATOR_HOOKFUNCTION(ctf_GiveFragsForKill)
958 {
959         frag_score = 0;
960         return (autocvar_g_ctf_ignore_frags); // no frags counted in ctf if this is true
961 }
962
963 MUTATOR_HOOKFUNCTION(ctf_PlayerUseKey)
964 {
965         entity player = self;
966
967         if(time > player.throw_antispam)
968         {
969                 // pass the flag to a team mate
970                 if(autocvar_g_ctf_pass)
971                 {
972                         entity head, closest_target;
973                         head = findradius(player.origin, autocvar_g_ctf_pass_radius);
974                         
975                         while(head) // find the closest acceptable target to pass to
976                         {
977                                 if(head.classname == "player" && head.deadflag == DEAD_NO)
978                                 if(head != player && !IsDifferentTeam(head, player))
979                                 if(!player.speedrunning && !head.speedrunning)
980                                 {
981                                         traceline(player.origin, head.origin, MOVE_NOMONSTERS, player);
982                                         if not((trace_fraction < 1) && (trace_ent != head))
983                                         {
984                                                 if(autocvar_g_ctf_pass_request && !player.flagcarried && head.flagcarried) 
985                                                 { 
986                                                         if(clienttype(head) == CLIENTTYPE_BOT)
987                                                         {
988                                                                 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname)); 
989                                                                 ctf_Handle_Throw(head, player, DROP_PASS);
990                                                         }
991                                                         else
992                                                         {
993                                                                 centerprint(head, strcat(player.netname, " requests you to pass the ", head.flagcarried.netname)); 
994                                                                 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname)); 
995                                                         }
996                                                         player.throw_antispam = time + autocvar_g_ctf_pass_wait; 
997                                                         return 0; 
998                                                 }
999                                                 else if(player.flagcarried)
1000                                                 {
1001                                                         if(closest_target) { if(vlen(player.origin - head.origin) < vlen(player.origin - closest_target.origin)) { closest_target = head; } }
1002                                                         else { closest_target = head; }
1003                                                 }
1004                                         }
1005                                 }
1006                                 head = head.chain;
1007                         }
1008                         
1009                         if(closest_target) { ctf_Handle_Throw(player, closest_target, DROP_PASS); return 0; }
1010                 }
1011                 
1012                 // throw the flag in front of you
1013                 if(autocvar_g_ctf_drop && player.flagcarried && !player.speedrunning)
1014                         { ctf_Handle_Throw(player, world, DROP_THROW); }
1015         }
1016                 
1017         return 0;
1018 }
1019
1020 // ==========
1021 // Spawnfuncs
1022 // ==========
1023
1024 /*QUAKED spawnfunc_info_player_team1 (1 0 0) (-16 -16 -24) (16 16 24)
1025 CTF Starting point for a player in team one (Red).
1026 Keys: "angle" viewing angle when spawning. */
1027 void spawnfunc_info_player_team1()
1028 {
1029         if(g_assault) { remove(self); return; }
1030         
1031         self.team = COLOR_TEAM1; // red
1032         spawnfunc_info_player_deathmatch();
1033 }
1034
1035
1036 /*QUAKED spawnfunc_info_player_team2 (1 0 0) (-16 -16 -24) (16 16 24)
1037 CTF Starting point for a player in team two (Blue).
1038 Keys: "angle" viewing angle when spawning. */
1039 void spawnfunc_info_player_team2()
1040 {
1041         if(g_assault) { remove(self); return; }
1042         
1043         self.team = COLOR_TEAM2; // blue
1044         spawnfunc_info_player_deathmatch();
1045 }
1046
1047 /*QUAKED spawnfunc_info_player_team3 (1 0 0) (-16 -16 -24) (16 16 24)
1048 CTF Starting point for a player in team three (Yellow).
1049 Keys: "angle" viewing angle when spawning. */
1050 void spawnfunc_info_player_team3()
1051 {
1052         if(g_assault) { remove(self); return; }
1053         
1054         self.team = COLOR_TEAM3; // yellow
1055         spawnfunc_info_player_deathmatch();
1056 }
1057
1058
1059 /*QUAKED spawnfunc_info_player_team4 (1 0 0) (-16 -16 -24) (16 16 24)
1060 CTF Starting point for a player in team four (Purple).
1061 Keys: "angle" viewing angle when spawning. */
1062 void spawnfunc_info_player_team4()
1063 {
1064         if(g_assault) { remove(self); return; }
1065         
1066         self.team = COLOR_TEAM4; // purple
1067         spawnfunc_info_player_deathmatch();
1068 }
1069
1070 /*QUAKED spawnfunc_item_flag_team1 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1071 CTF flag for team one (Red).
1072 Keys: 
1073 "angle" Angle the flag will point (minus 90 degrees)... 
1074 "model" model to use, note this needs red and blue as skins 0 and 1...
1075 "noise" sound played when flag is picked up...
1076 "noise1" sound played when flag is returned by a teammate...
1077 "noise2" sound played when flag is captured...
1078 "noise3" sound played when flag is lost in the field and respawns itself... 
1079 "noise4" sound played when flag is dropped by a player...
1080 "noise5" sound played when flag touches the ground... */
1081 void spawnfunc_item_flag_team1()
1082 {
1083         if(!g_ctf) { remove(self); return; }
1084
1085         ctf_FlagSetup(1, self); // 1 = red
1086 }
1087
1088 /*QUAKED spawnfunc_item_flag_team2 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1089 CTF flag for team two (Blue).
1090 Keys: 
1091 "angle" Angle the flag will point (minus 90 degrees)... 
1092 "model" model to use, note this needs red and blue as skins 0 and 1...
1093 "noise" sound played when flag is picked up...
1094 "noise1" sound played when flag is returned by a teammate...
1095 "noise2" sound played when flag is captured...
1096 "noise3" sound played when flag is lost in the field and respawns itself... 
1097 "noise4" sound played when flag is dropped by a player...
1098 "noise5" sound played when flag touches the ground... */
1099 void spawnfunc_item_flag_team2()
1100 {
1101         if(!g_ctf) { remove(self); return; }
1102
1103         ctf_FlagSetup(0, self); // the 0 is misleading, but -- 0 = blue.
1104 }
1105
1106 /*QUAKED spawnfunc_ctf_team (0 .5 .8) (-16 -16 -24) (16 16 32)
1107 Team declaration for CTF gameplay, this allows you to decide what team names and control point models are used in your map.
1108 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.
1109 Keys:
1110 "netname" Name of the team (for example Red, Blue, Green, Yellow, Life, Death, Offense, Defense, etc)...
1111 "cnt" Scoreboard color of the team (for example 4 is red and 13 is blue)... */
1112 void spawnfunc_ctf_team()
1113 {
1114         if(!g_ctf) { remove(self); return; }
1115         
1116         self.classname = "ctf_team";
1117         self.team = self.cnt + 1;
1118 }
1119
1120
1121 // ==============
1122 // Initialization
1123 // ==============
1124
1125 // code from here on is just to support maps that don't have flag and team entities
1126 void ctf_SpawnTeam (string teamname, float teamcolor)
1127 {
1128         entity oldself;
1129         oldself = self;
1130         self = spawn();
1131         self.classname = "ctf_team";
1132         self.netname = teamname;
1133         self.cnt = teamcolor;
1134
1135         spawnfunc_ctf_team();
1136
1137         self = oldself;
1138 }
1139
1140 void ctf_DelayedInit() // Do this check with a delay so we can wait for teams to be set up.
1141 {
1142         // if no teams are found, spawn defaults
1143         if(find(world, classname, "ctf_team") == world)
1144         {
1145                 print("No ""ctf_team"" entities found on this map, creating them anyway.\n");
1146                 ctf_SpawnTeam("Red", COLOR_TEAM1 - 1);
1147                 ctf_SpawnTeam("Blue", COLOR_TEAM2 - 1);
1148         }
1149         
1150         ScoreRules_ctf();
1151 }
1152
1153 void ctf_Initialize()
1154 {
1155         ctf_captimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));
1156
1157         ctf_captureshield_min_negscore = autocvar_g_ctf_shield_min_negscore;
1158         ctf_captureshield_max_ratio = autocvar_g_ctf_shield_max_ratio;
1159         ctf_captureshield_force = autocvar_g_ctf_shield_force;
1160         
1161         InitializeEntity(world, ctf_DelayedInit, INITPRIO_GAMETYPE);
1162 }
1163
1164
1165 MUTATOR_DEFINITION(gamemode_ctf)
1166 {
1167         MUTATOR_HOOK(MakePlayerObserver, ctf_RemovePlayer, CBC_ORDER_ANY);
1168         MUTATOR_HOOK(ClientDisconnect, ctf_RemovePlayer, CBC_ORDER_ANY);
1169         MUTATOR_HOOK(PlayerDies, ctf_RemovePlayer, CBC_ORDER_ANY);
1170         MUTATOR_HOOK(PortalTeleport, ctf_PortalTeleport, CBC_ORDER_ANY);
1171         MUTATOR_HOOK(GiveFragsForKill, ctf_GiveFragsForKill, CBC_ORDER_ANY);
1172         MUTATOR_HOOK(PlayerPreThink, ctf_PlayerPreThink, CBC_ORDER_ANY);
1173         MUTATOR_HOOK(PlayerDamage_Calculate, ctf_PlayerDamage, CBC_ORDER_ANY);
1174         MUTATOR_HOOK(PlayerUseKey, ctf_PlayerUseKey, CBC_ORDER_ANY);
1175
1176         MUTATOR_ONADD
1177         {
1178                 if(time > 1) // game loads at time 1
1179                         error("This is a game type and it cannot be added at runtime.");
1180                 g_ctf = 1;
1181                 ctf_Initialize();
1182         }
1183
1184         MUTATOR_ONREMOVE
1185         {
1186                 g_ctf = 0;
1187                 error("This is a game type and it cannot be removed at runtime.");
1188         }
1189
1190         return 0;
1191 }