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