1 // ================================================================
2 // Official capture the flag game mode coding, reworked by Samual
3 // Last updated: March 30th, 2012
4 // ================================================================
6 float ctf_ReadScore(string parameter) // make this obsolete
8 //if(g_ctf_win_mode != 2)
9 return cvar(strcat("g_ctf_personal", parameter));
11 // return cvar(strcat("g_ctf_flag", parameter));
14 void ctf_FakeTimeLimit(entity e, float t)
17 WriteByte(MSG_ONE, 3); // svc_updatestat
18 WriteByte(MSG_ONE, 236); // STAT_TIMELIMIT
20 WriteCoord(MSG_ONE, autocvar_timelimit);
22 WriteCoord(MSG_ONE, (t + 1) / 60);
25 void ctf_EventLog(string mode, float flagteam, entity actor) // use an alias for easy changing and quick editing later
27 if(autocvar_sv_eventlog)
28 GameLogEcho(strcat(":ctf:", mode, ":", ftos(flagteam), ((actor != world) ? (strcat(":", ftos(actor.playerid))) : "")));
31 string ctf_CaptureRecord(entity flag, entity player)
33 float cap_time, cap_record, success;
34 string cap_message, refername;
36 if((autocvar_g_ctf_captimerecord_always) || (player_count - currentbots))
38 cap_record = ctf_captimerecord;
39 cap_time = (time - flag.ctf_pickuptime);
41 refername = db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"));
42 refername = ((refername == player.netname) ? "their" : strcat(refername, "^7's"));
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; }
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; }
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);
63 void ctf_FlagcarrierWaypoints(entity player)
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));
72 // =======================
73 // CaptureShield Functions
74 // =======================
76 float ctf_CaptureShield_CheckStatus(entity p)
80 float players_worseeq, players_total;
82 if(ctf_captureshield_max_ratio <= 0)
85 s = PlayerScore_Add(p, SP_SCORE, 0);
86 if(s >= -ctf_captureshield_min_negscore)
89 players_total = players_worseeq = 0;
92 if(IsDifferentTeam(e, p))
94 se = PlayerScore_Add(e, SP_SCORE, 0);
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
103 if(players_worseeq >= players_total * ctf_captureshield_max_ratio)
109 void ctf_CaptureShield_Update(entity player, float wanted_status)
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
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);
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);
119 player.ctf_captureshielded = updated_status;
123 float ctf_CaptureShield_Customize()
125 if(!other.ctf_captureshielded) { return FALSE; }
126 if(!IsDifferentTeam(self, other)) { return FALSE; }
131 void ctf_CaptureShield_Touch()
133 if(!other.ctf_captureshielded) { return; }
134 if(!IsDifferentTeam(self, other)) { return; }
136 vector mymid = (self.absmin + self.absmax) * 0.5;
137 vector othermid = (other.absmin + other.absmax) * 0.5;
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);
143 void ctf_CaptureShield_Spawn(entity flag)
145 entity shield = spawn();
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';
158 setorigin(shield, self.origin);
159 setmodel(shield, "models/ctf/shield.md3");
160 setsize(shield, shield.scale * shield.mins, shield.scale * shield.maxs);
164 // ====================
165 // Drop/Pass/Throw Code
166 // ====================
168 void ctf_Handle_Drop(entity flag, entity player, float droptype)
171 player = (player ? player : flag.pass_sender);
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;
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);
187 PlayerTeamScore_AddScore(player, -ctf_ReadScore("penalty_drop"));
188 PlayerScore_Add(player, SP_CTF_DROPS, 1);
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));
194 if(autocvar_g_ctf_flag_return_time || (autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health))
196 WaypointSprite_UpdateMaxHealth(flag.wps_flagdropped, flag.max_flag_health);
197 WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health);
200 player.throw_antispam = time + autocvar_g_ctf_pass_wait;
202 if(droptype == DROP_PASS)
204 flag.pass_sender = world;
205 flag.pass_target = world;
209 void ctf_Handle_Retrieve(entity flag, entity player)
211 entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
212 entity sender = flag.pass_sender;
214 // transfer flag to player
215 flag.ctf_carrier = player;
217 flag.owner.flagcarried = 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;
228 // messages and sounds
229 sound(player, CH_TRIGGER, flag.snd_flag_pass, VOL_BASE, ATTN_NORM);
230 ctf_EventLog("recieve", flag.team, player);
232 FOR_EACH_REALPLAYER(tmp_player)
234 if(tmp_player == sender)
235 centerprint(tmp_player, strcat("You passed the ", flag.netname, " to ", player.netname));
236 else if(tmp_player == player)
237 centerprint(tmp_player, strcat("You recieved the ", flag.netname, " from ", sender.netname));
238 else if(!IsDifferentTeam(tmp_player, sender))
239 centerprint(tmp_player, strcat(sender.netname, " passed the ", flag.netname, " to ", player.netname));
242 // create new waypoint
243 ctf_FlagcarrierWaypoints(player);
245 sender.throw_antispam = time + autocvar_g_ctf_pass_wait;
246 player.throw_antispam = sender.throw_antispam;
248 flag.pass_sender = world;
249 flag.pass_target = world;
252 void ctf_Handle_Throw(entity player, entity reciever, float droptype)
254 entity flag = player.flagcarried;
256 if(!flag) { return; }
257 if((droptype == DROP_PASS) && !reciever) { return; }
259 if(flag.speedrunning) { ctf_RespawnFlag(flag); return; }
262 setattachment(flag, world, "");
263 setorigin(flag, player.origin + FLAG_DROP_OFFSET);
264 flag.owner.flagcarried = world;
266 flag.solid = SOLID_TRIGGER;
267 flag.ctf_droptime = time;
269 flag.flags = FL_ITEM | FL_NOTARGET; // clear FL_ONGROUND for MOVETYPE_TOSS
275 vector targ_origin = WarpZone_RefSys_TransformOrigin(player, reciever, (0.5 * (reciever.absmin + reciever.absmax)));
276 flag.velocity = (normalize(targ_origin - player.origin) * autocvar_g_ctf_pass_velocity);
282 makevectors((player.v_angle_y * '0 1 0') + (player.v_angle_x * '0.5 0 0'));
283 flag.velocity = W_CalculateProjectileVelocity(player.velocity, ('0 0 200' + (v_forward * autocvar_g_ctf_drop_velocity)), FALSE);
289 flag.velocity = '0 0 0'; // do nothing
296 flag.velocity = W_CalculateProjectileVelocity(player.velocity, ('0 0 200' + ('0 100 0' * crandom()) + ('100 0 0' * crandom())), FALSE);
306 flag.movetype = MOVETYPE_FLY;
307 flag.takedamage = DAMAGE_NO;
308 flag.pass_sender = player;
309 flag.pass_target = reciever;
310 flag.ctf_status = FLAG_PASSING;
313 sound(player, CH_TRIGGER, flag.snd_flag_touch, VOL_BASE, ATTN_NORM);
314 WarpZone_TrailParticles(world, particleeffectnum(flag.passeffect), reciever.origin, player.origin);
315 ctf_EventLog("pass", flag.team, player);
329 ctf_Handle_Drop(flag, player, droptype);
334 // kill old waypointsprite
335 WaypointSprite_Ping(player.wps_flagcarrier);
336 WaypointSprite_Kill(player.wps_flagcarrier);
338 if(player.wps_enemyflagcarrier)
339 WaypointSprite_Kill(player.wps_enemyflagcarrier);
342 ctf_CaptureShield_Update(player, 0); // shield player from picking up flag
350 void ctf_Handle_Capture(entity flag, entity toucher, float capturetype)
352 entity enemy_flag = ((capturetype == CAPTURE_NORMAL) ? toucher.flagcarried : toucher);
353 entity player = ((capturetype == CAPTURE_NORMAL) ? toucher : enemy_flag.ctf_dropper);
355 if not(player) { return; } // without someone to give the reward to, we can't possibly cap
357 // messages and sounds
358 Send_KillNotification(player.netname, enemy_flag.netname, ctf_CaptureRecord(enemy_flag, player), INFO_CAPTUREFLAG, MSG_INFO);
359 sound(player, CH_TRIGGER, flag.snd_flag_capture, VOL_BASE, ATTN_NONE);
363 case CAPTURE_NORMAL: ctf_EventLog("capture", enemy_flag.team, player); break;
364 case CAPTURE_DROPPED: ctf_EventLog("droppedcapture", enemy_flag.team, player); break;
369 PlayerTeamScore_AddScore(player, ctf_ReadScore("score_capture"));
370 PlayerTeamScore_Add(player, SP_CTF_CAPS, ST_CTF_CAPS, 1);
373 if(autocvar_g_ctf_flag_capture_effects)
375 pointparticles(particleeffectnum((player.team == COLOR_TEAM1) ? "red_ground_quake" : "blue_ground_quake"), flag.origin, '0 0 0', 1);
376 shockwave_spawn("models/ctf/shockwavetransring.md3", flag.origin - '0 0 15', -0.8, 0, 1);
380 if(capturetype == CAPTURE_NORMAL)
382 WaypointSprite_Kill(player.wps_flagcarrier);
383 if(flag.speedrunning) { ctf_FakeTimeLimit(player, -1); }
387 player.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
388 ctf_RespawnFlag(enemy_flag);
391 void ctf_Handle_Return(entity flag, entity player)
393 // messages and sounds
394 //centerprint(player, strcat("You returned the ", flag.netname));
395 Send_KillNotification(player.netname, flag.netname, "", INFO_RETURNFLAG, MSG_INFO);
396 sound(player, CH_TRIGGER, flag.snd_flag_returned, VOL_BASE, ATTN_NONE);
397 ctf_EventLog("return", flag.team, player);
400 PlayerTeamScore_AddScore(player, ctf_ReadScore("score_return")); // reward for return
401 PlayerScore_Add(player, SP_CTF_RETURNS, 1); // add to count of returns
403 TeamScore_AddToTeam(flag.team, ST_SCORE, -ctf_ReadScore("penalty_returned")); // punish the team who was last carrying it
407 PlayerScore_Add(flag.ctf_dropper, SP_SCORE, -ctf_ReadScore("penalty_returned")); // punish the player who dropped the flag
408 ctf_CaptureShield_Update(flag.ctf_dropper, 0); // shield player from picking up flag
409 flag.ctf_dropper.next_take_time = time + autocvar_g_ctf_flag_collect_delay; // set next take time
413 ctf_RespawnFlag(flag);
416 void ctf_Handle_Pickup(entity flag, entity player, float pickuptype)
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
423 // attach the flag to the player
425 player.flagcarried = flag;
426 setattachment(flag, player, "");
427 setorigin(flag, FLAG_CARRY_OFFSET);
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;
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
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), ") ") : "");
449 FOR_EACH_REALPLAYER(tmp_player)
451 if(tmp_player == player)
452 centerprint(tmp_player, strcat("You got the ", flag.netname, "!"));
453 else if(!IsDifferentTeam(tmp_player, player))
454 centerprint(tmp_player, strcat("Your ", Team_ColorCode(player.team), "team mate ", verbosename, "^7got the flag! Protect them!"));
455 else if(!IsDifferentTeam(tmp_player, flag))
456 centerprint(tmp_player, strcat("The ", Team_ColorCode(player.team), "enemy ", verbosename, "^7got your flag! Retrieve it!"));
461 case PICKUP_BASE: ctf_EventLog("steal", flag.team, player); break;
462 case PICKUP_DROPPED: ctf_EventLog("pickup", flag.team, player); break;
467 PlayerScore_Add(player, SP_CTF_PICKUPS, 1);
472 PlayerTeamScore_AddScore(player, ctf_ReadScore("score_pickup_base"));
478 pickup_dropped_score = (autocvar_g_ctf_flag_return_time ? bound(0, ((flag.ctf_droptime + autocvar_g_ctf_flag_return_time) - time) / autocvar_g_ctf_flag_return_time, 1) : 1);
479 pickup_dropped_score = floor((ctf_ReadScore("score_pickup_dropped_late") * (1 - pickup_dropped_score) + ctf_ReadScore("score_pickup_dropped_early") * pickup_dropped_score) + 0.5);
480 print("pickup_dropped_score is ", ftos(pickup_dropped_score), "\n");
481 PlayerTeamScore_AddScore(player, pickup_dropped_score);
489 if(pickuptype == PICKUP_BASE)
491 flag.speedrunning = player.speedrunning; // if speedrunning, flag will flag-return and teleport the owner back after the record
492 if((player.speedrunning) && (ctf_captimerecord))
493 ctf_FakeTimeLimit(player, time + ctf_captimerecord);
497 if(autocvar_g_ctf_flag_pickup_effects)
498 pointparticles(particleeffectnum("smoke_ring"), 0.5 * (flag.absmin + flag.absmax), '0 0 0', 1);
501 if(pickuptype == PICKUP_DROPPED) { WaypointSprite_Kill(flag.wps_flagdropped); }
502 ctf_FlagcarrierWaypoints(player);
503 WaypointSprite_Ping(player.wps_flagcarrier);
507 // ===================
508 // Main Flag Functions
509 // ===================
511 void ctf_CheckFlagReturn(entity flag, float returntype)
513 if(flag.wps_flagdropped) { WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health); }
515 if((flag.health <= 0) || (time >= flag.ctf_droptime + autocvar_g_ctf_flag_return_time))
519 case RETURN_DROPPED: bprint("The ", flag.netname, " was dropped in the base and returned itself\n"); break;
520 case RETURN_DAMAGE: bprint("The ", flag.netname, " was destroyed and returned to base\n"); break;
521 case RETURN_SPEEDRUN: bprint("The ", flag.netname, " became impatient after ", ftos_decimals(ctf_captimerecord, 2), " seconds and returned itself\n"); break;
522 case RETURN_NEEDKILL: bprint("The ", flag.netname, " fell somewhere it couldn't be reached and returned to base\n"); break;
526 { bprint("The ", flag.netname, " has returned to base\n"); break; }
528 sound(flag, CH_TRIGGER, flag.snd_flag_respawn, VOL_BASE, ATTN_NONE);
529 ctf_EventLog("returned", flag.team, world);
530 ctf_RespawnFlag(flag);
534 void ctf_CheckStalemate(void)
537 float stale_red_flags, stale_blue_flags;
540 entity ctf_staleflaglist; // reset the list, we need to build the list each time this function runs
542 // build list of stale flags
543 for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
545 if(autocvar_g_ctf_flagcarrier_waypointforenemy_stalemate)
546 if(tmp_entity.ctf_status != FLAG_BASE)
547 if(time >= tmp_entity.ctf_pickuptime + autocvar_g_ctf_flagcarrier_waypointforenemy_stalemate)
549 tmp_entity.ctf_staleflagnext = ctf_staleflaglist; // link flag into staleflaglist
550 ctf_staleflaglist = tmp_entity;
552 switch(tmp_entity.team)
554 case COLOR_TEAM1: ++stale_red_flags; break;
555 case COLOR_TEAM2: ++stale_blue_flags; break;
560 if(stale_red_flags && stale_blue_flags)
561 ctf_stalemate = TRUE;
562 else if(!stale_red_flags && !stale_blue_flags)
563 ctf_stalemate = FALSE;
565 // if sufficient stalemate, then set up the waypointsprite and announce the stalemate if necessary
568 for(tmp_entity = ctf_staleflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_staleflagnext)
570 if((tmp_entity.owner) && (!tmp_entity.owner.wps_enemyflagcarrier))
571 WaypointSprite_Spawn("enemyflagcarrier", 0, 0, tmp_entity.owner, FLAG_WAYPOINT_OFFSET, world, tmp_entity.team, tmp_entity.owner, wps_enemyflagcarrier, TRUE, RADARICON_FLAG, WPCOLOR_ENEMYFC(tmp_entity.owner.team));
574 if not(wpforenemy_announced)
576 FOR_EACH_REALPLAYER(tmp_entity)
577 if(tmp_entity.flagcarried)
578 centerprint(tmp_entity, "Stalemate! Enemies can now see you on radar!");
580 centerprint(tmp_entity, "Stalemate! Flag carriers can now be seen by enemies on radar!");
582 wpforenemy_announced = TRUE;
587 void ctf_FlagDamage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
589 if(ITEM_DAMAGE_NEEDKILL(deathtype))
591 // automatically kill the flag and return it
593 ctf_CheckFlagReturn(self, RETURN_NEEDKILL);
596 if(autocvar_g_ctf_flag_return_damage)
598 // reduce health and check if it should be returned
599 self.health = self.health - damage;
600 ctf_CheckFlagReturn(self, RETURN_DAMAGE);
610 self.nextthink = time + FLAG_THINKRATE; // only 5 fps, more is unnecessary.
613 if(self == ctf_worldflaglist) // only for the first flag
614 FOR_EACH_CLIENT(tmp_entity)
615 ctf_CaptureShield_Update(tmp_entity, 1); // release shield only
618 if(self.mins != FLAG_MIN || self.maxs != FLAG_MAX) { // reset the flag boundaries in case it got squished
619 dprint("wtf the flag got squashed?\n");
620 tracebox(self.origin, FLAG_MIN, FLAG_MAX, self.origin, MOVE_NOMONSTERS, self);
621 if(!trace_startsolid) // can we resize it without getting stuck?
622 setsize(self, FLAG_MIN, FLAG_MAX); }
624 switch(self.ctf_status) // reset flag angles in case warpzones adjust it
629 self.angles = '0 0 0';
637 switch(self.ctf_status)
641 if(autocvar_g_ctf_dropped_capture_radius)
643 for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
644 if(tmp_entity.ctf_status == FLAG_DROPPED)
645 if(vlen(self.origin - tmp_entity.origin) < autocvar_g_ctf_dropped_capture_radius)
646 ctf_Handle_Capture(self, tmp_entity, CAPTURE_DROPPED);
653 if(autocvar_g_ctf_flag_dropped_floatinwater)
655 vector midpoint = ((self.absmin + self.absmax) * 0.5);
656 if(pointcontents(midpoint) == CONTENT_WATER)
658 self.velocity = self.velocity * 0.5;
660 if(pointcontents(midpoint + FLAG_FLOAT_OFFSET) == CONTENT_WATER)
661 { self.velocity_z = autocvar_g_ctf_flag_dropped_floatinwater; }
663 { self.movetype = MOVETYPE_FLY; }
665 else if(self.movetype == MOVETYPE_FLY) { self.movetype = MOVETYPE_TOSS; }
667 if(autocvar_g_ctf_flag_return_dropped)
669 if((vlen(self.origin - self.ctf_spawnorigin) <= autocvar_g_ctf_flag_return_dropped) || (autocvar_g_ctf_flag_return_dropped == -1))
672 ctf_CheckFlagReturn(self, RETURN_DROPPED);
676 if(autocvar_g_ctf_flag_return_time)
678 self.health -= ((self.max_flag_health / autocvar_g_ctf_flag_return_time) * FLAG_THINKRATE);
679 ctf_CheckFlagReturn(self, RETURN_TIMEOUT);
687 if(self.speedrunning && ctf_captimerecord && (time >= self.ctf_pickuptime + ctf_captimerecord))
690 ctf_CheckFlagReturn(self, RETURN_SPEEDRUN);
694 self.impulse = CHIMPULSE_SPEEDRUN; // move the player back to the waypoint they set
698 if(autocvar_g_ctf_flagcarrier_waypointforenemy_stalemate)
700 if(time >= wpforenemy_nextthink)
702 ctf_CheckStalemate();
703 wpforenemy_nextthink = time + WPFE_THINKRATE; // waypoint for enemy think rate (to reduce unnecessary spam of this check)
709 case FLAG_PASSING: // todo make work with warpzones
711 /*vector targ_origin = ((self.pass_target.absmin + self.pass_target.absmax) * 0.5);
712 vector old_targ_origin = targ_origin;
713 targ_origin = WarpZone_RefSys_TransformOrigin(self.pass_sender, self.pass_target, targ_origin);
715 print("old: ", vtos(old_targ_origin), ", transformed: ", vtos(targ_origin), ".\n");
717 WarpZone_TraceLine(self.origin, targ_origin, MOVE_NOMONSTERS, self);
719 te_customflash(self.origin, 40, 2, '1 1 1');
720 te_customflash(targ_origin, 200, 2, '15 0 0');
722 if((self.pass_target.deadflag != DEAD_NO)
723 || (vlen(self.origin - targ_origin) > autocvar_g_ctf_pass_radius)
724 || ((trace_fraction < 1) && (trace_ent != self.pass_target))
725 || (time > self.ctf_droptime + autocvar_g_ctf_pass_timelimit))
727 ctf_Handle_Drop(self, world, DROP_PASS);
729 else // still a viable target, go for it
731 vector desired_direction = normalize(targ_origin - self.origin);
732 vector current_direction = normalize(self.velocity);
734 self.velocity = (normalize(current_direction + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_pass_velocity);
738 vector targ_origin = ((self.pass_target.absmin + self.pass_target.absmax) * 0.5);
739 vector old_targ_origin = targ_origin;
740 targ_origin = WarpZone_RefSys_TransformOrigin(self.pass_sender, self.pass_target, targ_origin);
741 WarpZone_TraceLine(self.origin, targ_origin, MOVE_NOMONSTERS, self);
743 print("old: ", vtos(old_targ_origin), ", transformed: ", vtos(targ_origin), ".\n");
745 if((self.pass_target.deadflag != DEAD_NO)
746 || (vlen(self.origin - targ_origin) > autocvar_g_ctf_pass_radius)
747 || ((trace_fraction < 1) && (trace_ent != self.pass_target))
748 || (time > self.ctf_droptime + autocvar_g_ctf_pass_timelimit))
750 ctf_Handle_Drop(self, world, DROP_PASS);
752 else // still a viable target, go for it
754 vector desired_direction = normalize(targ_origin - self.origin);
755 vector current_direction = normalize(self.velocity);
757 // self.velocity = (normalize(current_direction + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_pass_velocity);
758 self.velocity = (normalize(current_direction + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_pass_velocity);
763 default: // this should never happen
765 dprint("ctf_FlagThink(): Flag exists with no status?\n");
773 if(gameover) { return; }
775 entity toucher = other;
777 // automatically kill the flag and return it if it touched lava/slime/nodrop surfaces
778 if(ITEM_TOUCH_NEEDKILL())
781 ctf_CheckFlagReturn(self, RETURN_NEEDKILL);
785 // special touch behaviors
786 if(toucher.vehicle_flags & VHF_ISVEHICLE)
788 if(autocvar_g_ctf_allow_vehicle_touch)
789 toucher = toucher.owner; // the player is actually the vehicle owner, not other
791 return; // do nothing
793 else if(toucher.classname != "player") // The flag just touched an object, most likely the world
795 if(time > self.wait) // if we haven't in a while, play a sound/effect
797 pointparticles(particleeffectnum(self.toucheffect), self.origin, '0 0 0', 1);
798 sound(self, CH_TRIGGER, self.snd_flag_touch, VOL_BASE, ATTN_NORM);
799 self.wait = time + FLAG_TOUCHRATE;
803 else if(toucher.deadflag != DEAD_NO) { return; }
805 switch(self.ctf_status)
809 if(!IsDifferentTeam(toucher, self) && (toucher.flagcarried) && IsDifferentTeam(toucher.flagcarried, self))
810 ctf_Handle_Capture(self, toucher, CAPTURE_NORMAL); // toucher just captured the enemies flag to his base
811 else if(IsDifferentTeam(toucher, self) && (!toucher.flagcarried) && (!toucher.ctf_captureshielded) && (time > toucher.next_take_time))
812 ctf_Handle_Pickup(self, toucher, PICKUP_BASE); // toucher just stole the enemies flag
818 if(!IsDifferentTeam(toucher, self))
819 ctf_Handle_Return(self, toucher); // toucher just returned his own flag
820 else if((!toucher.flagcarried) && ((toucher != self.ctf_dropper) || (time > self.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
821 ctf_Handle_Pickup(self, toucher, PICKUP_DROPPED); // toucher just picked up a dropped enemy flag
827 dprint("Someone touched a flag even though it was being carried?\n");
833 if((toucher.classname == "player") && (toucher.deadflag == DEAD_NO) && (toucher != self.pass_sender))
835 if(IsDifferentTeam(toucher, self.pass_sender))
836 ctf_Handle_Return(self, toucher);
838 ctf_Handle_Retrieve(self, toucher);
845 void ctf_RespawnFlag(entity flag)
847 // reset the player (if there is one)
848 if((flag.owner) && (flag.owner.flagcarried == flag))
850 if(flag.owner.wps_enemyflagcarrier)
851 WaypointSprite_Kill(flag.owner.wps_enemyflagcarrier);
853 WaypointSprite_Kill(flag.wps_flagcarrier);
855 flag.owner.flagcarried = world;
857 if(flag.speedrunning)
858 ctf_FakeTimeLimit(flag.owner, -1);
861 if((flag.ctf_status == FLAG_DROPPED) && (flag.wps_flagdropped))
862 { WaypointSprite_Kill(flag.wps_flagdropped); }
865 setattachment(flag, world, "");
866 setorigin(flag, flag.ctf_spawnorigin);
868 flag.movetype = ((flag.noalign) ? MOVETYPE_NONE : MOVETYPE_TOSS);
869 flag.takedamage = DAMAGE_NO;
870 flag.health = flag.max_flag_health;
871 flag.solid = SOLID_TRIGGER;
872 flag.velocity = '0 0 0';
873 flag.angles = flag.mangle;
874 flag.flags = FL_ITEM | FL_NOTARGET;
876 flag.ctf_status = FLAG_BASE;
878 flag.pass_sender = world;
879 flag.pass_target = world;
880 flag.ctf_carrier = world;
881 flag.ctf_dropper = world;
882 flag.ctf_pickuptime = 0;
883 flag.ctf_droptime = 0;
885 wpforenemy_announced = FALSE;
891 if(self.owner.classname == "player")
892 ctf_Handle_Throw(self.owner, world, DROP_RESET);
894 ctf_RespawnFlag(self);
897 void ctf_DelayedFlagSetup(void) // called after a flag is placed on a map by ctf_FlagSetup()
900 waypoint_spawnforitem_force(self, self.origin);
901 self.nearestwaypointtimeout = 0; // activate waypointing again
902 self.bot_basewaypoint = self.nearestwaypoint;
905 WaypointSprite_SpawnFixed(((self.team == COLOR_TEAM1) ? "redbase" : "bluebase"), self.origin + FLAG_WAYPOINT_OFFSET, self, wps_flagbase, RADARICON_FLAG, colormapPaletteColor(self.team - 1, FALSE));
906 WaypointSprite_UpdateTeamRadar(self.wps_flagbase, RADARICON_FLAG, colormapPaletteColor(self.team - 1, FALSE));
908 // captureshield setup
909 ctf_CaptureShield_Spawn(self);
912 void ctf_FlagSetup(float teamnumber, entity flag) // called when spawning a flag entity on the map as a spawnfunc
915 teamnumber = fabs(teamnumber - bound(0, autocvar_g_ctf_reverse, 1)); // if we were originally 1, this will become 0. If we were originally 0, this will become 1.
916 self = flag; // for later usage with droptofloor()
919 flag.ctf_worldflagnext = ctf_worldflaglist; // link flag into ctf_worldflaglist
920 ctf_worldflaglist = flag;
922 setattachment(flag, world, "");
924 flag.netname = ((teamnumber) ? "^1RED^7 flag" : "^4BLUE^7 flag");
925 flag.team = ((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2); // COLOR_TEAM1: color 4 team (red) - COLOR_TEAM2: color 13 team (blue)
926 flag.items = ((teamnumber) ? IT_KEY2 : IT_KEY1); // IT_KEY2: gold key (redish enough) - IT_KEY1: silver key (bluish enough)
927 flag.classname = "item_flag_team";
928 flag.target = "###item###"; // wut?
929 flag.flags = FL_ITEM | FL_NOTARGET;
930 flag.solid = SOLID_TRIGGER;
931 flag.takedamage = DAMAGE_NO;
932 flag.damageforcescale = autocvar_g_ctf_flag_damageforcescale;
933 flag.max_flag_health = ((autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health) ? autocvar_g_ctf_flag_health : 100);
934 flag.health = flag.max_flag_health;
935 flag.event_damage = ctf_FlagDamage;
936 flag.pushable = TRUE;
937 flag.teleportable = TELEPORT_NORMAL;
938 flag.damagedbytriggers = autocvar_g_ctf_flag_return_when_unreachable;
939 flag.damagedbycontents = autocvar_g_ctf_flag_return_when_unreachable;
940 flag.velocity = '0 0 0';
941 flag.mangle = flag.angles;
942 flag.reset = ctf_Reset;
943 flag.touch = ctf_FlagTouch;
944 flag.think = ctf_FlagThink;
945 flag.nextthink = time + FLAG_THINKRATE;
946 flag.ctf_status = FLAG_BASE;
948 if(!flag.model) { flag.model = ((teamnumber) ? autocvar_g_ctf_flag_red_model : autocvar_g_ctf_flag_blue_model); }
949 if(!flag.scale) { flag.scale = FLAG_SCALE; }
950 if(!flag.skin) { flag.skin = ((teamnumber) ? autocvar_g_ctf_flag_red_skin : autocvar_g_ctf_flag_blue_skin); }
951 if(!flag.toucheffect) { flag.toucheffect = ((teamnumber) ? "redflag_touch" : "blueflag_touch"); }
952 if(!flag.passeffect) { flag.passeffect = ((!teamnumber) ? "red_pass" : "blue_pass"); } // invert the team number of the flag to pass as enemy team color
955 if(!flag.snd_flag_taken) { flag.snd_flag_taken = ((teamnumber) ? "ctf/red_taken.wav" : "ctf/blue_taken.wav"); }
956 if(!flag.snd_flag_returned) { flag.snd_flag_returned = ((teamnumber) ? "ctf/red_returned.wav" : "ctf/blue_returned.wav"); }
957 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
958 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.
959 if(!flag.snd_flag_dropped) { flag.snd_flag_dropped = ((teamnumber) ? "ctf/red_dropped.wav" : "ctf/blue_dropped.wav"); }
960 if(!flag.snd_flag_touch) { flag.snd_flag_touch = "ctf/touch.wav"; } // again has no team-based sound
961 if(!flag.snd_flag_pass) { flag.snd_flag_pass = "ctf/pass.wav"; } // same story here
964 precache_sound(flag.snd_flag_taken);
965 precache_sound(flag.snd_flag_returned);
966 precache_sound(flag.snd_flag_capture);
967 precache_sound(flag.snd_flag_respawn);
968 precache_sound(flag.snd_flag_dropped);
969 precache_sound(flag.snd_flag_touch);
970 precache_sound(flag.snd_flag_pass);
971 precache_model(flag.model);
972 precache_model("models/ctf/shield.md3");
973 precache_model("models/ctf/shockwavetransring.md3");
976 setmodel(flag, flag.model); // precision set below
977 setsize(flag, FLAG_MIN, FLAG_MAX);
978 setorigin(flag, (flag.origin + FLAG_SPAWN_OFFSET));
980 if(autocvar_g_ctf_flag_glowtrails)
982 flag.glow_color = ((teamnumber) ? 251 : 210); // 251: red - 210: blue
987 flag.effects |= EF_LOWPRECISION;
988 if(autocvar_g_ctf_fullbrightflags) { flag.effects |= EF_FULLBRIGHT; }
989 if(autocvar_g_ctf_dynamiclights) { flag.effects |= ((teamnumber) ? EF_RED : EF_BLUE); }
992 if((flag.spawnflags & 1) || flag.noalign) // don't drop to floor, just stay at fixed location
994 flag.dropped_origin = flag.origin;
996 flag.movetype = MOVETYPE_NONE;
998 else // drop to floor, automatically find a platform and set that as spawn origin
1000 flag.noalign = FALSE;
1003 flag.movetype = MOVETYPE_TOSS;
1006 InitializeEntity(flag, ctf_DelayedFlagSetup, INITPRIO_SETLOCATION);
1014 MUTATOR_HOOKFUNCTION(ctf_PlayerPreThink)
1018 // initially clear items so they can be set as necessary later.
1019 self.items &~= (IT_RED_FLAG_CARRYING | IT_RED_FLAG_TAKEN | IT_RED_FLAG_LOST
1020 | IT_BLUE_FLAG_CARRYING | IT_BLUE_FLAG_TAKEN | IT_BLUE_FLAG_LOST | IT_CTF_SHIELDED);
1022 // scan through all the flags and notify the client about them
1023 for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
1025 switch(flag.ctf_status)
1029 if(flag.owner == self)
1030 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_CARRYING : IT_BLUE_FLAG_CARRYING); // carrying: self is currently carrying the flag
1032 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_TAKEN : IT_BLUE_FLAG_TAKEN); // taken: someone on self's team is carrying the flag
1037 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_LOST : IT_BLUE_FLAG_LOST); // lost: the flag is dropped somewhere on the map
1043 // item for stopping players from capturing the flag too often
1044 if(self.ctf_captureshielded)
1045 self.items |= IT_CTF_SHIELDED;
1047 // update the health of the flag carrier waypointsprite
1048 if(self.wps_flagcarrier)
1049 WaypointSprite_UpdateHealth(self.wps_flagcarrier, self.health);
1054 MUTATOR_HOOKFUNCTION(ctf_PlayerDamage) // for changing damage and force values that are applied to players in g_damage.qc
1056 if(frag_attacker.flagcarried) // if the attacker is a flagcarrier
1058 if(frag_target == frag_attacker) // damage done to yourself
1060 frag_damage *= autocvar_g_ctf_flagcarrier_selfdamagefactor;
1061 frag_force *= autocvar_g_ctf_flagcarrier_selfforcefactor;
1063 else // damage done to everyone else
1065 frag_damage *= autocvar_g_ctf_flagcarrier_damagefactor;
1066 frag_force *= autocvar_g_ctf_flagcarrier_forcefactor;
1069 else if(frag_target.flagcarried && (frag_target.deadflag == DEAD_NO) && IsDifferentTeam(frag_target, frag_attacker)) // if the target is a flagcarrier
1071 if(autocvar_g_ctf_flagcarrier_auto_helpme_when_damaged > frag_target.health)
1072 WaypointSprite_HelpMePing(frag_target.wps_flagcarrier); // TODO: only do this if there is a significant loss of health?
1077 MUTATOR_HOOKFUNCTION(ctf_PlayerDies)
1079 if((frag_attacker != frag_target) && (frag_attacker.classname == "player") && (frag_target.flagcarried))
1081 PlayerTeamScore_AddScore(frag_attacker, ctf_ReadScore("score_kill"));
1082 PlayerScore_Add(frag_attacker, SP_CTF_FCKILLS, 1);
1085 if(frag_target.flagcarried)
1086 { ctf_Handle_Throw(frag_target, world, DROP_NORMAL); }
1091 MUTATOR_HOOKFUNCTION(ctf_GiveFragsForKill)
1094 return (autocvar_g_ctf_ignore_frags); // no frags counted in ctf if this is true
1097 MUTATOR_HOOKFUNCTION(ctf_RemovePlayer)
1099 if(self.flagcarried)
1100 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
1105 MUTATOR_HOOKFUNCTION(ctf_PortalTeleport)
1107 if(self.flagcarried)
1108 if(!autocvar_g_ctf_portalteleport)
1109 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
1114 MUTATOR_HOOKFUNCTION(ctf_PlayerUseKey)
1116 entity player = self;
1118 if((time > player.throw_antispam) && (player.deadflag == DEAD_NO) && !player.speedrunning && (!player.vehicle || autocvar_g_ctf_allow_vehicle_touch))
1120 // pass the flag to a team mate
1121 if(autocvar_g_ctf_pass)
1123 entity head, closest_target;
1124 head = WarpZone_FindRadius(player.origin, autocvar_g_ctf_pass_radius, TRUE);
1126 while(head) // find the closest acceptable target to pass to
1128 if(head.classname == "player" && head.deadflag == DEAD_NO)
1129 if(head != player && !IsDifferentTeam(head, player))
1130 if(!head.speedrunning && (!head.vehicle || autocvar_g_ctf_allow_vehicle_touch))
1132 if(autocvar_g_ctf_pass_request && !player.flagcarried && head.flagcarried)
1134 if(clienttype(head) == CLIENTTYPE_BOT)
1136 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
1137 ctf_Handle_Throw(head, player, DROP_PASS);
1141 centerprint(head, strcat(player.netname, " requests you to pass the ", head.flagcarried.netname));
1142 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
1144 player.throw_antispam = time + autocvar_g_ctf_pass_wait;
1147 else if(player.flagcarried)
1151 if(vlen(player.origin - WarpZone_RefSys_TransformOrigin(player, head, head.origin)) < vlen(player.origin - WarpZone_RefSys_TransformOrigin(player, head, closest_target.origin)))
1152 { closest_target = head; }
1154 else { closest_target = head; }
1160 if(closest_target) { ctf_Handle_Throw(player, closest_target, DROP_PASS); return 0; }
1163 // throw the flag in front of you
1164 if(autocvar_g_ctf_drop && player.flagcarried)
1165 { ctf_Handle_Throw(player, world, DROP_THROW); }
1171 MUTATOR_HOOKFUNCTION(ctf_HelpMePing)
1173 if(self.wps_flagcarrier) // update the flagcarrier waypointsprite with "NEEDING HELP" notification
1175 WaypointSprite_HelpMePing(self.wps_flagcarrier);
1177 else // create a normal help me waypointsprite
1179 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');
1180 WaypointSprite_Ping(self.wps_helpme);
1186 MUTATOR_HOOKFUNCTION(ctf_VehicleEnter)
1188 if(other.flagcarried)
1190 if(!autocvar_g_ctf_flagcarrier_allow_vehicle_carry)
1192 ctf_Handle_Throw(self, world, DROP_NORMAL);
1196 setattachment(other.flagcarried, self, "");
1197 setorigin(other, VEHICLE_FLAG_OFFSET);
1198 other.flagcarried.scale = VEHICLE_FLAG_SCALE;
1199 //other.flagcarried.angles = '0 0 0';
1206 MUTATOR_HOOKFUNCTION(ctf_VehicleExit)
1208 if(self.owner.flagcarried)
1210 setattachment(self.owner.flagcarried, self.owner, "");
1211 setorigin(self.owner.flagcarried, FLAG_CARRY_OFFSET);
1212 self.owner.flagcarried.scale = FLAG_SCALE;
1213 self.owner.flagcarried.angles = '0 0 0';
1219 MUTATOR_HOOKFUNCTION(ctf_AbortSpeedrun)
1221 if(self.flagcarried)
1223 bprint("The ", self.flagcarried.netname, " was returned to base by its carrier\n");
1224 ctf_RespawnFlag(self);
1230 MUTATOR_HOOKFUNCTION(ctf_MatchEnd)
1232 entity flag; // temporary entity for the search method
1234 for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
1236 switch(flag.ctf_status)
1241 // lock the flag, game is over
1242 flag.movetype = MOVETYPE_NONE;
1243 flag.takedamage = DAMAGE_NO;
1244 flag.solid = SOLID_NOT;
1245 flag.nextthink = 0; // stop thinking
1247 print("stopping the ", flag.netname, " from moving.\n");
1255 // do nothing for these flags
1269 /*QUAKED spawnfunc_info_player_team1 (1 0 0) (-16 -16 -24) (16 16 24)
1270 CTF Starting point for a player in team one (Red).
1271 Keys: "angle" viewing angle when spawning. */
1272 void spawnfunc_info_player_team1()
1274 if(g_assault) { remove(self); return; }
1276 self.team = COLOR_TEAM1; // red
1277 spawnfunc_info_player_deathmatch();
1281 /*QUAKED spawnfunc_info_player_team2 (1 0 0) (-16 -16 -24) (16 16 24)
1282 CTF Starting point for a player in team two (Blue).
1283 Keys: "angle" viewing angle when spawning. */
1284 void spawnfunc_info_player_team2()
1286 if(g_assault) { remove(self); return; }
1288 self.team = COLOR_TEAM2; // blue
1289 spawnfunc_info_player_deathmatch();
1292 /*QUAKED spawnfunc_info_player_team3 (1 0 0) (-16 -16 -24) (16 16 24)
1293 CTF Starting point for a player in team three (Yellow).
1294 Keys: "angle" viewing angle when spawning. */
1295 void spawnfunc_info_player_team3()
1297 if(g_assault) { remove(self); return; }
1299 self.team = COLOR_TEAM3; // yellow
1300 spawnfunc_info_player_deathmatch();
1304 /*QUAKED spawnfunc_info_player_team4 (1 0 0) (-16 -16 -24) (16 16 24)
1305 CTF Starting point for a player in team four (Purple).
1306 Keys: "angle" viewing angle when spawning. */
1307 void spawnfunc_info_player_team4()
1309 if(g_assault) { remove(self); return; }
1311 self.team = COLOR_TEAM4; // purple
1312 spawnfunc_info_player_deathmatch();
1315 /*QUAKED spawnfunc_item_flag_team1 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1316 CTF flag for team one (Red).
1318 "angle" Angle the flag will point (minus 90 degrees)...
1319 "model" model to use, note this needs red and blue as skins 0 and 1...
1320 "noise" sound played when flag is picked up...
1321 "noise1" sound played when flag is returned by a teammate...
1322 "noise2" sound played when flag is captured...
1323 "noise3" sound played when flag is lost in the field and respawns itself...
1324 "noise4" sound played when flag is dropped by a player...
1325 "noise5" sound played when flag touches the ground... */
1326 void spawnfunc_item_flag_team1()
1328 if(!g_ctf) { remove(self); return; }
1330 ctf_FlagSetup(1, self); // 1 = red
1333 /*QUAKED spawnfunc_item_flag_team2 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1334 CTF flag for team two (Blue).
1336 "angle" Angle the flag will point (minus 90 degrees)...
1337 "model" model to use, note this needs red and blue as skins 0 and 1...
1338 "noise" sound played when flag is picked up...
1339 "noise1" sound played when flag is returned by a teammate...
1340 "noise2" sound played when flag is captured...
1341 "noise3" sound played when flag is lost in the field and respawns itself...
1342 "noise4" sound played when flag is dropped by a player...
1343 "noise5" sound played when flag touches the ground... */
1344 void spawnfunc_item_flag_team2()
1346 if(!g_ctf) { remove(self); return; }
1348 ctf_FlagSetup(0, self); // the 0 is misleading, but -- 0 = blue.
1351 /*QUAKED spawnfunc_ctf_team (0 .5 .8) (-16 -16 -24) (16 16 32)
1352 Team declaration for CTF gameplay, this allows you to decide what team names and control point models are used in your map.
1353 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.
1355 "netname" Name of the team (for example Red, Blue, Green, Yellow, Life, Death, Offense, Defense, etc)...
1356 "cnt" Scoreboard color of the team (for example 4 is red and 13 is blue)... */
1357 void spawnfunc_ctf_team()
1359 if(!g_ctf) { remove(self); return; }
1361 self.classname = "ctf_team";
1362 self.team = self.cnt + 1;
1370 // code from here on is just to support maps that don't have flag and team entities
1371 void ctf_SpawnTeam (string teamname, float teamcolor)
1376 self.classname = "ctf_team";
1377 self.netname = teamname;
1378 self.cnt = teamcolor;
1380 spawnfunc_ctf_team();
1385 void ctf_DelayedInit() // Do this check with a delay so we can wait for teams to be set up.
1387 // if no teams are found, spawn defaults
1388 if(find(world, classname, "ctf_team") == world)
1390 print("No ""ctf_team"" entities found on this map, creating them anyway.\n");
1391 ctf_SpawnTeam("Red", COLOR_TEAM1 - 1);
1392 ctf_SpawnTeam("Blue", COLOR_TEAM2 - 1);
1398 void ctf_Initialize()
1400 ctf_captimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));
1402 ctf_captureshield_min_negscore = autocvar_g_ctf_shield_min_negscore;
1403 ctf_captureshield_max_ratio = autocvar_g_ctf_shield_max_ratio;
1404 ctf_captureshield_force = autocvar_g_ctf_shield_force;
1406 InitializeEntity(world, ctf_DelayedInit, INITPRIO_GAMETYPE);
1410 MUTATOR_DEFINITION(gamemode_ctf)
1412 MUTATOR_HOOK(MakePlayerObserver, ctf_RemovePlayer, CBC_ORDER_ANY);
1413 MUTATOR_HOOK(ClientDisconnect, ctf_RemovePlayer, CBC_ORDER_ANY);
1414 MUTATOR_HOOK(PlayerDies, ctf_PlayerDies, CBC_ORDER_ANY);
1415 MUTATOR_HOOK(MatchEnd, ctf_MatchEnd, CBC_ORDER_ANY);
1416 MUTATOR_HOOK(PortalTeleport, ctf_PortalTeleport, CBC_ORDER_ANY);
1417 MUTATOR_HOOK(GiveFragsForKill, ctf_GiveFragsForKill, CBC_ORDER_ANY);
1418 MUTATOR_HOOK(PlayerPreThink, ctf_PlayerPreThink, CBC_ORDER_ANY);
1419 MUTATOR_HOOK(PlayerDamage_Calculate, ctf_PlayerDamage, CBC_ORDER_ANY);
1420 MUTATOR_HOOK(PlayerUseKey, ctf_PlayerUseKey, CBC_ORDER_ANY);
1421 MUTATOR_HOOK(HelpMePing, ctf_HelpMePing, CBC_ORDER_ANY);
1422 MUTATOR_HOOK(VehicleEnter, ctf_VehicleEnter, CBC_ORDER_ANY);
1423 MUTATOR_HOOK(VehicleExit, ctf_VehicleExit, CBC_ORDER_ANY);
1424 MUTATOR_HOOK(AbortSpeedrun, ctf_AbortSpeedrun, CBC_ORDER_ANY);
1428 if(time > 1) // game loads at time 1
1429 error("This is a game type and it cannot be added at runtime.");
1437 error("This is a game type and it cannot be removed at runtime.");