1 // ================================================================
2 // Official capture the flag game mode coding, reworked by Samual
3 // Last updated: March 30th, 2012
4 // ================================================================
6 void ctf_FakeTimeLimit(entity e, float t)
9 WriteByte(MSG_ONE, 3); // svc_updatestat
10 WriteByte(MSG_ONE, 236); // STAT_TIMELIMIT
12 WriteCoord(MSG_ONE, autocvar_timelimit);
14 WriteCoord(MSG_ONE, (t + 1) / 60);
17 void ctf_EventLog(string mode, float flagteam, entity actor) // use an alias for easy changing and quick editing later
19 if(autocvar_sv_eventlog)
20 GameLogEcho(strcat(":ctf:", mode, ":", ftos(flagteam), ((actor != world) ? (strcat(":", ftos(actor.playerid))) : "")));
23 string ctf_CaptureRecord(entity flag, entity player)
25 float cap_time, cap_record, success;
26 string cap_message, refername;
28 if((autocvar_g_ctf_captimerecord_always) || (player_count - currentbots))
30 cap_record = ctf_captimerecord;
31 cap_time = (time - flag.ctf_pickuptime);
33 refername = db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"));
34 refername = ((refername == player.netname) ? "their" : strcat(refername, "^7's"));
36 if(!ctf_captimerecord)
37 { cap_message = strcat(" in ", ftos_decimals(cap_time, 2), " seconds"); success = TRUE; }
38 else if(cap_time < cap_record)
39 { cap_message = strcat(" in ", ftos_decimals(cap_time, 2), " seconds, breaking ", refername, " previous record of ", ftos_decimals(cap_record, 2), " seconds"); success = TRUE; }
41 { cap_message = strcat(" in ", ftos_decimals(cap_time, 2), " seconds, failing to break ", refername, " record of ", ftos_decimals(cap_record, 2), " seconds"); success = FALSE; }
45 ctf_captimerecord = cap_time;
46 db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time"), ftos(cap_time));
47 db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"), player.netname);
48 write_recordmarker(player, (time - cap_time), cap_time);
55 void ctf_FlagcarrierWaypoints(entity player)
57 WaypointSprite_Spawn("flagcarrier", 0, 0, player, FLAG_WAYPOINT_OFFSET, world, player.team, player, wps_flagcarrier, TRUE, RADARICON_FLAG, WPCOLOR_FLAGCARRIER(player.team));
58 WaypointSprite_UpdateMaxHealth(player.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(start_health, start_armorvalue, autocvar_g_balance_armor_blockpercent) * 2);
59 WaypointSprite_UpdateHealth(player.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(player.health, player.armorvalue, autocvar_g_balance_armor_blockpercent));
60 WaypointSprite_UpdateTeamRadar(player.wps_flagcarrier, RADARICON_FLAGCARRIER, WPCOLOR_FLAGCARRIER(player.team));
64 // =======================
65 // CaptureShield Functions
66 // =======================
68 float ctf_CaptureShield_CheckStatus(entity p)
72 float players_worseeq, players_total;
74 if(ctf_captureshield_max_ratio <= 0)
77 s = PlayerScore_Add(p, SP_SCORE, 0);
78 if(s >= -ctf_captureshield_min_negscore)
81 players_total = players_worseeq = 0;
84 if(IsDifferentTeam(e, p))
86 se = PlayerScore_Add(e, SP_SCORE, 0);
92 // player is in the worse half, if >= half the players are better than him, or consequently, if < half of the players are worse
95 if(players_worseeq >= players_total * ctf_captureshield_max_ratio)
101 void ctf_CaptureShield_Update(entity player, float wanted_status)
103 float updated_status = ctf_CaptureShield_CheckStatus(player);
104 if((wanted_status == player.ctf_captureshielded) && (updated_status != wanted_status)) // 0: shield only, 1: unshield only
106 if(updated_status) // TODO csqc notifier for this // Samual: How?
107 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);
109 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);
111 player.ctf_captureshielded = updated_status;
115 float ctf_CaptureShield_Customize()
117 if(!other.ctf_captureshielded) { return FALSE; }
118 if(!IsDifferentTeam(self, other)) { return FALSE; }
123 void ctf_CaptureShield_Touch()
125 if(!other.ctf_captureshielded) { return; }
126 if(!IsDifferentTeam(self, other)) { return; }
128 vector mymid = (self.absmin + self.absmax) * 0.5;
129 vector othermid = (other.absmin + other.absmax) * 0.5;
131 Damage(other, self, self, 0, DEATH_HURTTRIGGER, mymid, normalize(othermid - mymid) * ctf_captureshield_force);
132 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);
135 void ctf_CaptureShield_Spawn(entity flag)
137 entity shield = spawn();
140 shield.team = self.team;
141 shield.touch = ctf_CaptureShield_Touch;
142 shield.customizeentityforclient = ctf_CaptureShield_Customize;
143 shield.classname = "ctf_captureshield";
144 shield.effects = EF_ADDITIVE;
145 shield.movetype = MOVETYPE_NOCLIP;
146 shield.solid = SOLID_TRIGGER;
147 shield.avelocity = '7 0 11';
150 setorigin(shield, self.origin);
151 setmodel(shield, "models/ctf/shield.md3");
152 setsize(shield, shield.scale * shield.mins, shield.scale * shield.maxs);
156 // ====================
157 // Drop/Pass/Throw Code
158 // ====================
160 void ctf_Handle_Drop(entity flag, entity player, float droptype)
163 player = (player ? player : flag.pass_sender);
166 flag.movetype = MOVETYPE_TOSS;
167 flag.takedamage = DAMAGE_YES;
168 flag.health = flag.max_flag_health;
169 flag.ctf_droptime = time;
170 flag.ctf_dropper = player;
171 flag.ctf_status = FLAG_DROPPED;
173 // messages and sounds
174 Send_KillNotification(player.netname, flag.netname, "", INFO_LOSTFLAG, MSG_INFO);
175 sound(flag, CH_TRIGGER, flag.snd_flag_dropped, VOL_BASE, ATTN_NONE);
176 ctf_EventLog("dropped", player.team, player);
179 PlayerTeamScore_AddScore(player, -autocvar_g_ctf_score_penalty_drop);
180 PlayerScore_Add(player, SP_CTF_DROPS, 1);
183 if(autocvar_g_ctf_flag_dropped_waypoint)
184 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));
186 if(autocvar_g_ctf_flag_return_time || (autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health))
188 WaypointSprite_UpdateMaxHealth(flag.wps_flagdropped, flag.max_flag_health);
189 WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health);
192 player.throw_antispam = time + autocvar_g_ctf_pass_wait;
194 if(droptype == DROP_PASS)
196 flag.pass_sender = world;
197 flag.pass_target = world;
201 void ctf_Handle_Retrieve(entity flag, entity player)
203 entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
204 entity sender = flag.pass_sender;
206 // transfer flag to player
208 flag.owner.flagcarried = flag;
211 setattachment(flag, player, "");
212 setorigin(flag, FLAG_CARRY_OFFSET);
213 flag.movetype = MOVETYPE_NONE;
214 flag.takedamage = DAMAGE_NO;
215 flag.solid = SOLID_NOT;
216 flag.ctf_carrier = player;
217 flag.ctf_status = FLAG_CARRY;
219 // messages and sounds
220 sound(player, CH_TRIGGER, flag.snd_flag_pass, VOL_BASE, ATTN_NORM);
221 ctf_EventLog("recieve", flag.team, player);
223 FOR_EACH_REALPLAYER(tmp_player)
225 if(tmp_player == sender)
226 centerprint(tmp_player, strcat("You passed the ", flag.netname, " to ", player.netname));
227 else if(tmp_player == player)
228 centerprint(tmp_player, strcat("You recieved the ", flag.netname, " from ", sender.netname));
229 else if(!IsDifferentTeam(tmp_player, sender))
230 centerprint(tmp_player, strcat(sender.netname, " passed the ", flag.netname, " to ", player.netname));
233 // create new waypoint
234 ctf_FlagcarrierWaypoints(player);
236 sender.throw_antispam = time + autocvar_g_ctf_pass_wait;
237 player.throw_antispam = sender.throw_antispam;
239 flag.pass_sender = world;
240 flag.pass_target = world;
243 void ctf_Handle_Throw(entity player, entity reciever, float droptype)
245 entity flag = player.flagcarried;
248 if(!flag) { return; }
249 if((droptype == DROP_PASS) && !reciever) { return; }
251 if(flag.speedrunning) { ctf_RespawnFlag(flag); return; }
254 setattachment(flag, world, "");
255 setorigin(flag, player.origin + FLAG_DROP_OFFSET);
256 flag.owner.flagcarried = world;
258 flag.solid = SOLID_TRIGGER;
259 flag.ctf_dropper = player;
260 flag.ctf_droptime = time;
262 flag.flags = FL_ITEM | FL_NOTARGET; // clear FL_ONGROUND for MOVETYPE_TOSS
268 WarpZone_RefSys_MakeSameRefSys(flag, player);
269 targ_origin = WarpZone_RefSys_TransformOrigin(reciever, flag, (0.5 * (reciever.absmin + reciever.absmax)));
270 flag.velocity = (normalize(targ_origin - player.origin) * autocvar_g_ctf_pass_velocity);
276 makevectors((player.v_angle_y * '0 1 0') + (player.v_angle_x * '0.5 0 0'));
277 flag.velocity = W_CalculateProjectileVelocity(player.velocity, ('0 0 200' + (v_forward * autocvar_g_ctf_drop_velocity)), FALSE);
283 flag.velocity = '0 0 0'; // do nothing
290 flag.velocity = W_CalculateProjectileVelocity(player.velocity, ('0 0 200' + ('0 100 0' * crandom()) + ('100 0 0' * crandom())), FALSE);
300 flag.movetype = MOVETYPE_FLY;
301 flag.takedamage = DAMAGE_NO;
302 flag.pass_sender = player;
303 flag.pass_target = reciever;
304 flag.ctf_status = FLAG_PASSING;
307 sound(player, CH_TRIGGER, flag.snd_flag_touch, VOL_BASE, ATTN_NORM);
308 WarpZone_TrailParticles(world, particleeffectnum(flag.passeffect), targ_origin, player.origin);
309 ctf_EventLog("pass", flag.team, player);
323 ctf_Handle_Drop(flag, player, droptype);
328 // kill old waypointsprite
329 WaypointSprite_Ping(player.wps_flagcarrier);
330 WaypointSprite_Kill(player.wps_flagcarrier);
332 if(player.wps_enemyflagcarrier)
333 WaypointSprite_Kill(player.wps_enemyflagcarrier);
336 ctf_CaptureShield_Update(player, 0); // shield player from picking up flag
344 void ctf_Handle_Capture(entity flag, entity toucher, float capturetype)
346 entity enemy_flag = ((capturetype == CAPTURE_NORMAL) ? toucher.flagcarried : toucher);
347 entity player = ((capturetype == CAPTURE_NORMAL) ? toucher : enemy_flag.ctf_dropper);
348 float old_time, new_time;
350 if not(player) { return; } // without someone to give the reward to, we can't possibly cap
352 // messages and sounds
353 Send_KillNotification(player.netname, enemy_flag.netname, ctf_CaptureRecord(enemy_flag, player), INFO_CAPTUREFLAG, MSG_INFO);
354 sound(player, CH_TRIGGER, flag.snd_flag_capture, VOL_BASE, ATTN_NONE);
358 case CAPTURE_NORMAL: ctf_EventLog("capture", enemy_flag.team, player); break;
359 case CAPTURE_DROPPED: ctf_EventLog("droppedcapture", enemy_flag.team, player); break;
364 PlayerTeamScore_AddScore(player, autocvar_g_ctf_score_capture);
365 PlayerTeamScore_Add(player, SP_CTF_CAPS, ST_CTF_CAPS, 1);
367 old_time = PlayerScore_Add(player, SP_CTF_CAPTIME, 0);
368 new_time = TIME_ENCODE(time - enemy_flag.ctf_pickuptime);
369 if(!old_time || new_time < old_time)
370 PlayerScore_Add(player, SP_CTF_CAPTIME, new_time - old_time);
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); }
385 if((enemy_flag.ctf_dropper) && (player != enemy_flag.ctf_dropper))
386 { PlayerTeamScore_AddScore(enemy_flag.ctf_dropper, autocvar_g_ctf_score_capture_assist); }
390 player.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
391 ctf_RespawnFlag(enemy_flag);
394 void ctf_Handle_Return(entity flag, entity player)
396 // messages and sounds
397 //centerprint(player, strcat("You returned the ", flag.netname));
398 Send_KillNotification(player.netname, flag.netname, "", INFO_RETURNFLAG, MSG_INFO);
399 sound(player, CH_TRIGGER, flag.snd_flag_returned, VOL_BASE, ATTN_NONE);
400 ctf_EventLog("return", flag.team, player);
403 PlayerTeamScore_AddScore(player, autocvar_g_ctf_score_return); // reward for return
404 PlayerScore_Add(player, SP_CTF_RETURNS, 1); // add to count of returns
406 TeamScore_AddToTeam(flag.team, ST_SCORE, -autocvar_g_ctf_score_penalty_returned); // punish the team who was last carrying it
410 PlayerScore_Add(flag.ctf_dropper, SP_SCORE, -autocvar_g_ctf_score_penalty_returned); // punish the player who dropped the flag
411 ctf_CaptureShield_Update(flag.ctf_dropper, 0); // shield player from picking up flag
412 flag.ctf_dropper.next_take_time = time + autocvar_g_ctf_flag_collect_delay; // set next take time
416 ctf_RespawnFlag(flag);
419 void ctf_Handle_Pickup(entity flag, entity player, float pickuptype)
422 entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
423 string verbosename; // holds the name of the player OR no name at all for printing in the centerprints
424 float pickup_dropped_score; // used to calculate dropped pickup score
426 // attach the flag to the player
428 player.flagcarried = flag;
429 setattachment(flag, player, "");
430 setorigin(flag, FLAG_CARRY_OFFSET);
433 flag.movetype = MOVETYPE_NONE;
434 flag.takedamage = DAMAGE_NO;
435 flag.solid = SOLID_NOT;
436 flag.angles = '0 0 0';
437 flag.ctf_carrier = player;
438 flag.ctf_status = FLAG_CARRY;
442 case PICKUP_BASE: flag.ctf_pickuptime = time; break; // used for timing runs
443 case PICKUP_DROPPED: flag.health = flag.max_flag_health; break; // reset health/return timelimit
447 // messages and sounds
448 Send_KillNotification (player.netname, flag.netname, "", INFO_GOTFLAG, MSG_INFO);
449 sound(player, CH_TRIGGER, flag.snd_flag_taken, VOL_BASE, ATTN_NONE);
450 verbosename = ((autocvar_g_ctf_flag_pickup_verbosename) ? strcat(Team_ColorCode(player.team), "(^7", player.netname, Team_ColorCode(player.team), ") ") : "");
452 FOR_EACH_REALPLAYER(tmp_player)
454 if(tmp_player == player)
455 centerprint(tmp_player, strcat("You got the ", flag.netname, "!"));
456 else if(!IsDifferentTeam(tmp_player, player))
457 centerprint(tmp_player, strcat("Your ", Team_ColorCode(player.team), "team mate ", verbosename, "^7got the flag! Protect them!"));
458 else if(!IsDifferentTeam(tmp_player, flag))
459 centerprint(tmp_player, strcat("The ", Team_ColorCode(player.team), "enemy ", verbosename, "^7got your flag! Retrieve it!"));
464 case PICKUP_BASE: ctf_EventLog("steal", flag.team, player); break;
465 case PICKUP_DROPPED: ctf_EventLog("pickup", flag.team, player); break;
470 PlayerScore_Add(player, SP_CTF_PICKUPS, 1);
475 PlayerTeamScore_AddScore(player, autocvar_g_ctf_score_pickup_base);
481 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);
482 pickup_dropped_score = floor((autocvar_g_ctf_score_pickup_dropped_late * (1 - pickup_dropped_score) + autocvar_g_ctf_score_pickup_dropped_early * pickup_dropped_score) + 0.5);
483 print("pickup_dropped_score is ", ftos(pickup_dropped_score), "\n");
484 PlayerTeamScore_AddScore(player, pickup_dropped_score);
492 if(pickuptype == PICKUP_BASE)
494 flag.speedrunning = player.speedrunning; // if speedrunning, flag will flag-return and teleport the owner back after the record
495 if((player.speedrunning) && (ctf_captimerecord))
496 ctf_FakeTimeLimit(player, time + ctf_captimerecord);
500 if(autocvar_g_ctf_flag_pickup_effects)
501 pointparticles(particleeffectnum("smoke_ring"), 0.5 * (flag.absmin + flag.absmax), '0 0 0', 1);
504 if(pickuptype == PICKUP_DROPPED) { WaypointSprite_Kill(flag.wps_flagdropped); }
505 ctf_FlagcarrierWaypoints(player);
506 WaypointSprite_Ping(player.wps_flagcarrier);
510 // ===================
511 // Main Flag Functions
512 // ===================
514 void ctf_CheckFlagReturn(entity flag, float returntype)
516 if(flag.wps_flagdropped) { WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health); }
518 if((flag.health <= 0) || (time >= flag.ctf_droptime + autocvar_g_ctf_flag_return_time))
522 case RETURN_DROPPED: bprint("The ", flag.netname, " was dropped in the base and returned itself\n"); break;
523 case RETURN_DAMAGE: bprint("The ", flag.netname, " was destroyed and returned to base\n"); break;
524 case RETURN_SPEEDRUN: bprint("The ", flag.netname, " became impatient after ", ftos_decimals(ctf_captimerecord, 2), " seconds and returned itself\n"); break;
525 case RETURN_NEEDKILL: bprint("The ", flag.netname, " fell somewhere it couldn't be reached and returned to base\n"); break;
529 { bprint("The ", flag.netname, " has returned to base\n"); break; }
531 sound(flag, CH_TRIGGER, flag.snd_flag_respawn, VOL_BASE, ATTN_NONE);
532 ctf_EventLog("returned", flag.team, world);
533 ctf_RespawnFlag(flag);
537 void ctf_CheckStalemate(void)
540 float stale_red_flags, stale_blue_flags;
543 entity ctf_staleflaglist; // reset the list, we need to build the list each time this function runs
545 // build list of stale flags
546 for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
548 if(autocvar_g_ctf_flagcarrier_waypointforenemy_stalemate)
549 if(tmp_entity.ctf_status != FLAG_BASE)
550 if(time >= tmp_entity.ctf_pickuptime + autocvar_g_ctf_flagcarrier_waypointforenemy_stalemate)
552 tmp_entity.ctf_staleflagnext = ctf_staleflaglist; // link flag into staleflaglist
553 ctf_staleflaglist = tmp_entity;
555 switch(tmp_entity.team)
557 case COLOR_TEAM1: ++stale_red_flags; break;
558 case COLOR_TEAM2: ++stale_blue_flags; break;
563 if(stale_red_flags && stale_blue_flags)
564 ctf_stalemate = TRUE;
565 else if(!stale_red_flags && !stale_blue_flags)
566 ctf_stalemate = FALSE;
568 // if sufficient stalemate, then set up the waypointsprite and announce the stalemate if necessary
571 for(tmp_entity = ctf_staleflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_staleflagnext)
573 if((tmp_entity.owner) && (!tmp_entity.owner.wps_enemyflagcarrier))
574 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));
577 if not(wpforenemy_announced)
579 FOR_EACH_REALPLAYER(tmp_entity)
580 if(tmp_entity.flagcarried)
581 centerprint(tmp_entity, "Stalemate! Enemies can now see you on radar!");
583 centerprint(tmp_entity, "Stalemate! Flag carriers can now be seen by enemies on radar!");
585 wpforenemy_announced = TRUE;
590 void ctf_FlagDamage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
592 if(ITEM_DAMAGE_NEEDKILL(deathtype))
594 // automatically kill the flag and return it
596 ctf_CheckFlagReturn(self, RETURN_NEEDKILL);
599 if(autocvar_g_ctf_flag_return_damage)
601 // reduce health and check if it should be returned
602 self.health = self.health - damage;
603 ctf_CheckFlagReturn(self, RETURN_DAMAGE);
613 self.nextthink = time + FLAG_THINKRATE; // only 5 fps, more is unnecessary.
616 if(self == ctf_worldflaglist) // only for the first flag
617 FOR_EACH_CLIENT(tmp_entity)
618 ctf_CaptureShield_Update(tmp_entity, 1); // release shield only
621 if(self.mins != FLAG_MIN || self.maxs != FLAG_MAX) { // reset the flag boundaries in case it got squished
622 dprint("wtf the flag got squashed?\n");
623 tracebox(self.origin, FLAG_MIN, FLAG_MAX, self.origin, MOVE_NOMONSTERS, self);
624 if(!trace_startsolid) // can we resize it without getting stuck?
625 setsize(self, FLAG_MIN, FLAG_MAX); }
627 switch(self.ctf_status) // reset flag angles in case warpzones adjust it
632 self.angles = '0 0 0';
640 switch(self.ctf_status)
644 if(autocvar_g_ctf_dropped_capture_radius)
646 for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
647 if(tmp_entity.ctf_status == FLAG_DROPPED)
648 if(vlen(self.origin - tmp_entity.origin) < autocvar_g_ctf_dropped_capture_radius)
649 ctf_Handle_Capture(self, tmp_entity, CAPTURE_DROPPED);
656 if(autocvar_g_ctf_flag_dropped_floatinwater)
658 vector midpoint = ((self.absmin + self.absmax) * 0.5);
659 if(pointcontents(midpoint) == CONTENT_WATER)
661 self.velocity = self.velocity * 0.5;
663 if(pointcontents(midpoint + FLAG_FLOAT_OFFSET) == CONTENT_WATER)
664 { self.velocity_z = autocvar_g_ctf_flag_dropped_floatinwater; }
666 { self.movetype = MOVETYPE_FLY; }
668 else if(self.movetype == MOVETYPE_FLY) { self.movetype = MOVETYPE_TOSS; }
670 if(autocvar_g_ctf_flag_return_dropped)
672 if((vlen(self.origin - self.ctf_spawnorigin) <= autocvar_g_ctf_flag_return_dropped) || (autocvar_g_ctf_flag_return_dropped == -1))
675 ctf_CheckFlagReturn(self, RETURN_DROPPED);
679 if(autocvar_g_ctf_flag_return_time)
681 self.health -= ((self.max_flag_health / autocvar_g_ctf_flag_return_time) * FLAG_THINKRATE);
682 ctf_CheckFlagReturn(self, RETURN_TIMEOUT);
690 if(self.speedrunning && ctf_captimerecord && (time >= self.ctf_pickuptime + ctf_captimerecord))
693 ctf_CheckFlagReturn(self, RETURN_SPEEDRUN);
697 self.impulse = CHIMPULSE_SPEEDRUN; // move the player back to the waypoint they set
701 if(autocvar_g_ctf_flagcarrier_waypointforenemy_stalemate)
703 if(time >= wpforenemy_nextthink)
705 ctf_CheckStalemate();
706 wpforenemy_nextthink = time + WPFE_THINKRATE; // waypoint for enemy think rate (to reduce unnecessary spam of this check)
712 case FLAG_PASSING: // todo make work with warpzones
714 vector targ_origin = ((self.pass_target.absmin + self.pass_target.absmax) * 0.5);
715 vector old_targ_origin = targ_origin;
716 targ_origin = WarpZone_RefSys_TransformOrigin(self.pass_target, self, targ_origin);
717 WarpZone_TraceLine(self.origin, targ_origin, MOVE_NOMONSTERS, self);
719 print(strcat("self: ", vtos(self.origin), ", old: ", vtos(old_targ_origin), " (", ftos(vlen(self.origin - old_targ_origin)), "qu)"), ", transformed: ", vtos(targ_origin), " (", ftos(vlen(self.origin - targ_origin)), "qu)", ".\n");
721 if((self.pass_target.deadflag != DEAD_NO)
722 || (vlen(self.origin - targ_origin) > autocvar_g_ctf_pass_radius)
723 || ((trace_fraction < 1) && (trace_ent != self.pass_target))
724 || (time > self.ctf_droptime + autocvar_g_ctf_pass_timelimit))
726 ctf_Handle_Drop(self, world, DROP_PASS);
728 else // still a viable target, go for it
730 vector desired_direction = normalize(targ_origin - self.origin);
731 vector current_direction = normalize(self.velocity);
733 self.velocity = (normalize(current_direction + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_pass_velocity);
738 default: // this should never happen
740 dprint("ctf_FlagThink(): Flag exists with no status?\n");
748 if(gameover) { return; }
750 entity toucher = other;
752 // automatically kill the flag and return it if it touched lava/slime/nodrop surfaces
753 if(ITEM_TOUCH_NEEDKILL())
756 ctf_CheckFlagReturn(self, RETURN_NEEDKILL);
760 // special touch behaviors
761 if(toucher.vehicle_flags & VHF_ISVEHICLE)
763 if(autocvar_g_ctf_allow_vehicle_touch)
764 toucher = toucher.owner; // the player is actually the vehicle owner, not other
766 return; // do nothing
768 else if(toucher.classname != "player") // The flag just touched an object, most likely the world
770 if(time > self.wait) // if we haven't in a while, play a sound/effect
772 pointparticles(particleeffectnum(self.toucheffect), self.origin, '0 0 0', 1);
773 sound(self, CH_TRIGGER, self.snd_flag_touch, VOL_BASE, ATTN_NORM);
774 self.wait = time + FLAG_TOUCHRATE;
778 else if(toucher.deadflag != DEAD_NO) { return; }
780 switch(self.ctf_status)
784 if(!IsDifferentTeam(toucher, self) && (toucher.flagcarried) && IsDifferentTeam(toucher.flagcarried, self))
785 ctf_Handle_Capture(self, toucher, CAPTURE_NORMAL); // toucher just captured the enemies flag to his base
786 else if(IsDifferentTeam(toucher, self) && (!toucher.flagcarried) && (!toucher.ctf_captureshielded) && (time > toucher.next_take_time))
787 ctf_Handle_Pickup(self, toucher, PICKUP_BASE); // toucher just stole the enemies flag
793 if(!IsDifferentTeam(toucher, self))
794 ctf_Handle_Return(self, toucher); // toucher just returned his own flag
795 else if((!toucher.flagcarried) && ((toucher != self.ctf_dropper) || (time > self.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
796 ctf_Handle_Pickup(self, toucher, PICKUP_DROPPED); // toucher just picked up a dropped enemy flag
802 dprint("Someone touched a flag even though it was being carried?\n");
808 if((toucher.classname == "player") && (toucher.deadflag == DEAD_NO) && (toucher != self.pass_sender))
810 if(IsDifferentTeam(toucher, self.pass_sender))
811 ctf_Handle_Return(self, toucher);
813 ctf_Handle_Retrieve(self, toucher);
820 void ctf_RespawnFlag(entity flag)
822 // reset the player (if there is one)
823 if((flag.owner) && (flag.owner.flagcarried == flag))
825 if(flag.owner.wps_enemyflagcarrier)
826 WaypointSprite_Kill(flag.owner.wps_enemyflagcarrier);
828 WaypointSprite_Kill(flag.wps_flagcarrier);
830 flag.owner.flagcarried = world;
832 if(flag.speedrunning)
833 ctf_FakeTimeLimit(flag.owner, -1);
836 if((flag.ctf_status == FLAG_DROPPED) && (flag.wps_flagdropped))
837 { WaypointSprite_Kill(flag.wps_flagdropped); }
840 setattachment(flag, world, "");
841 setorigin(flag, flag.ctf_spawnorigin);
843 flag.movetype = ((flag.noalign) ? MOVETYPE_NONE : MOVETYPE_TOSS);
844 flag.takedamage = DAMAGE_NO;
845 flag.health = flag.max_flag_health;
846 flag.solid = SOLID_TRIGGER;
847 flag.velocity = '0 0 0';
848 flag.angles = flag.mangle;
849 flag.flags = FL_ITEM | FL_NOTARGET;
851 flag.ctf_status = FLAG_BASE;
853 flag.pass_sender = world;
854 flag.pass_target = world;
855 flag.ctf_carrier = world;
856 flag.ctf_dropper = world;
857 flag.ctf_pickuptime = 0;
858 flag.ctf_droptime = 0;
860 wpforenemy_announced = FALSE;
866 if(self.owner.classname == "player")
867 ctf_Handle_Throw(self.owner, world, DROP_RESET);
869 ctf_RespawnFlag(self);
872 void ctf_DelayedFlagSetup(void) // called after a flag is placed on a map by ctf_FlagSetup()
875 waypoint_spawnforitem_force(self, self.origin);
876 self.nearestwaypointtimeout = 0; // activate waypointing again
877 self.bot_basewaypoint = self.nearestwaypoint;
880 WaypointSprite_SpawnFixed(((self.team == COLOR_TEAM1) ? "redbase" : "bluebase"), self.origin + FLAG_WAYPOINT_OFFSET, self, wps_flagbase, RADARICON_FLAG, colormapPaletteColor(self.team - 1, FALSE));
881 WaypointSprite_UpdateTeamRadar(self.wps_flagbase, RADARICON_FLAG, colormapPaletteColor(self.team - 1, FALSE));
883 // captureshield setup
884 ctf_CaptureShield_Spawn(self);
887 void ctf_FlagSetup(float teamnumber, entity flag) // called when spawning a flag entity on the map as a spawnfunc
890 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.
891 self = flag; // for later usage with droptofloor()
894 flag.ctf_worldflagnext = ctf_worldflaglist; // link flag into ctf_worldflaglist
895 ctf_worldflaglist = flag;
897 setattachment(flag, world, "");
899 flag.netname = ((teamnumber) ? "^1RED^7 flag" : "^4BLUE^7 flag");
900 flag.team = ((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2); // COLOR_TEAM1: color 4 team (red) - COLOR_TEAM2: color 13 team (blue)
901 flag.items = ((teamnumber) ? IT_KEY2 : IT_KEY1); // IT_KEY2: gold key (redish enough) - IT_KEY1: silver key (bluish enough)
902 flag.classname = "item_flag_team";
903 flag.target = "###item###"; // wut?
904 flag.flags = FL_ITEM | FL_NOTARGET;
905 flag.solid = SOLID_TRIGGER;
906 flag.takedamage = DAMAGE_NO;
907 flag.damageforcescale = autocvar_g_ctf_flag_damageforcescale;
908 flag.max_flag_health = ((autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health) ? autocvar_g_ctf_flag_health : 100);
909 flag.health = flag.max_flag_health;
910 flag.event_damage = ctf_FlagDamage;
911 flag.pushable = TRUE;
912 flag.teleportable = TELEPORT_NORMAL;
913 flag.damagedbytriggers = autocvar_g_ctf_flag_return_when_unreachable;
914 flag.damagedbycontents = autocvar_g_ctf_flag_return_when_unreachable;
915 flag.velocity = '0 0 0';
916 flag.mangle = flag.angles;
917 flag.reset = ctf_Reset;
918 flag.touch = ctf_FlagTouch;
919 flag.think = ctf_FlagThink;
920 flag.nextthink = time + FLAG_THINKRATE;
921 flag.ctf_status = FLAG_BASE;
923 if(!flag.model) { flag.model = ((teamnumber) ? autocvar_g_ctf_flag_red_model : autocvar_g_ctf_flag_blue_model); }
924 if(!flag.scale) { flag.scale = FLAG_SCALE; }
925 if(!flag.skin) { flag.skin = ((teamnumber) ? autocvar_g_ctf_flag_red_skin : autocvar_g_ctf_flag_blue_skin); }
926 if(!flag.toucheffect) { flag.toucheffect = ((teamnumber) ? "redflag_touch" : "blueflag_touch"); }
927 if(!flag.passeffect) { flag.passeffect = ((!teamnumber) ? "red_pass" : "blue_pass"); } // invert the team number of the flag to pass as enemy team color
930 if(!flag.snd_flag_taken) { flag.snd_flag_taken = ((teamnumber) ? "ctf/red_taken.wav" : "ctf/blue_taken.wav"); }
931 if(!flag.snd_flag_returned) { flag.snd_flag_returned = ((teamnumber) ? "ctf/red_returned.wav" : "ctf/blue_returned.wav"); }
932 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
933 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.
934 if(!flag.snd_flag_dropped) { flag.snd_flag_dropped = ((teamnumber) ? "ctf/red_dropped.wav" : "ctf/blue_dropped.wav"); }
935 if(!flag.snd_flag_touch) { flag.snd_flag_touch = "ctf/touch.wav"; } // again has no team-based sound
936 if(!flag.snd_flag_pass) { flag.snd_flag_pass = "ctf/pass.wav"; } // same story here
939 precache_sound(flag.snd_flag_taken);
940 precache_sound(flag.snd_flag_returned);
941 precache_sound(flag.snd_flag_capture);
942 precache_sound(flag.snd_flag_respawn);
943 precache_sound(flag.snd_flag_dropped);
944 precache_sound(flag.snd_flag_touch);
945 precache_sound(flag.snd_flag_pass);
946 precache_model(flag.model);
947 precache_model("models/ctf/shield.md3");
948 precache_model("models/ctf/shockwavetransring.md3");
951 setmodel(flag, flag.model); // precision set below
952 setsize(flag, FLAG_MIN, FLAG_MAX);
953 setorigin(flag, (flag.origin + FLAG_SPAWN_OFFSET));
955 if(autocvar_g_ctf_flag_glowtrails)
957 flag.glow_color = ((teamnumber) ? 251 : 210); // 251: red - 210: blue
962 flag.effects |= EF_LOWPRECISION;
963 if(autocvar_g_ctf_fullbrightflags) { flag.effects |= EF_FULLBRIGHT; }
964 if(autocvar_g_ctf_dynamiclights) { flag.effects |= ((teamnumber) ? EF_RED : EF_BLUE); }
967 if((flag.spawnflags & 1) || flag.noalign) // don't drop to floor, just stay at fixed location
969 flag.dropped_origin = flag.origin;
971 flag.movetype = MOVETYPE_NONE;
973 else // drop to floor, automatically find a platform and set that as spawn origin
975 flag.noalign = FALSE;
978 flag.movetype = MOVETYPE_TOSS;
981 InitializeEntity(flag, ctf_DelayedFlagSetup, INITPRIO_SETLOCATION);
989 MUTATOR_HOOKFUNCTION(ctf_PlayerPreThink)
993 // initially clear items so they can be set as necessary later.
994 self.items &~= (IT_RED_FLAG_CARRYING | IT_RED_FLAG_TAKEN | IT_RED_FLAG_LOST
995 | IT_BLUE_FLAG_CARRYING | IT_BLUE_FLAG_TAKEN | IT_BLUE_FLAG_LOST | IT_CTF_SHIELDED);
997 // scan through all the flags and notify the client about them
998 for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
1000 switch(flag.ctf_status)
1005 if((flag.owner == self) || (flag.pass_sender == self))
1006 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_CARRYING : IT_BLUE_FLAG_CARRYING); // carrying: self is currently carrying the flag
1008 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_TAKEN : IT_BLUE_FLAG_TAKEN); // taken: someone on self's team is carrying the flag
1013 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_LOST : IT_BLUE_FLAG_LOST); // lost: the flag is dropped somewhere on the map
1019 // item for stopping players from capturing the flag too often
1020 if(self.ctf_captureshielded)
1021 self.items |= IT_CTF_SHIELDED;
1023 // update the health of the flag carrier waypointsprite
1024 if(self.wps_flagcarrier)
1025 WaypointSprite_UpdateHealth(self.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(self.health, self.armorvalue, autocvar_g_balance_armor_blockpercent));
1030 MUTATOR_HOOKFUNCTION(ctf_PlayerDamage) // for changing damage and force values that are applied to players in g_damage.qc
1032 if(frag_attacker.flagcarried) // if the attacker is a flagcarrier
1034 if(frag_target == frag_attacker) // damage done to yourself
1036 frag_damage *= autocvar_g_ctf_flagcarrier_selfdamagefactor;
1037 frag_force *= autocvar_g_ctf_flagcarrier_selfforcefactor;
1039 else // damage done to everyone else
1041 frag_damage *= autocvar_g_ctf_flagcarrier_damagefactor;
1042 frag_force *= autocvar_g_ctf_flagcarrier_forcefactor;
1045 else if(frag_target.flagcarried && (frag_target.deadflag == DEAD_NO) && IsDifferentTeam(frag_target, frag_attacker)) // if the target is a flagcarrier
1047 if(autocvar_g_ctf_flagcarrier_auto_helpme_when_damaged > ('1 0 0' * healtharmor_maxdamage(frag_target.health, frag_target.armorvalue, autocvar_g_balance_armor_blockpercent)))
1048 WaypointSprite_HelpMePing(frag_target.wps_flagcarrier); // TODO: only do this if there is a significant loss of health?
1053 MUTATOR_HOOKFUNCTION(ctf_PlayerDies)
1055 if((frag_attacker != frag_target) && (frag_attacker.classname == "player") && (frag_target.flagcarried))
1057 PlayerTeamScore_AddScore(frag_attacker, autocvar_g_ctf_score_kill);
1058 PlayerScore_Add(frag_attacker, SP_CTF_FCKILLS, 1);
1061 if(frag_target.flagcarried)
1062 { ctf_Handle_Throw(frag_target, world, DROP_NORMAL); }
1067 MUTATOR_HOOKFUNCTION(ctf_GiveFragsForKill)
1070 return (autocvar_g_ctf_ignore_frags); // no frags counted in ctf if this is true
1073 MUTATOR_HOOKFUNCTION(ctf_RemovePlayer)
1075 if(self.flagcarried)
1076 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
1081 MUTATOR_HOOKFUNCTION(ctf_PortalTeleport)
1083 if(self.flagcarried)
1084 if(!autocvar_g_ctf_portalteleport)
1085 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
1090 MUTATOR_HOOKFUNCTION(ctf_PlayerUseKey)
1092 entity player = self;
1094 if((time > player.throw_antispam) && (player.deadflag == DEAD_NO) && !player.speedrunning && (!player.vehicle || autocvar_g_ctf_allow_vehicle_touch))
1096 // pass the flag to a team mate
1097 if(autocvar_g_ctf_pass)
1099 entity head, closest_target;
1100 head = WarpZone_FindRadius(player.origin, autocvar_g_ctf_pass_radius, TRUE);
1102 while(head) // find the closest acceptable target to pass to
1104 if(head.classname == "player" && head.deadflag == DEAD_NO)
1105 if(head != player && !IsDifferentTeam(head, player))
1106 if(!head.speedrunning && (!head.vehicle || autocvar_g_ctf_allow_vehicle_touch))
1108 if(autocvar_g_ctf_pass_request && !player.flagcarried && head.flagcarried)
1110 if(clienttype(head) == CLIENTTYPE_BOT)
1112 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
1113 ctf_Handle_Throw(head, player, DROP_PASS);
1117 centerprint(head, strcat(player.netname, " requests you to pass the ", head.flagcarried.netname));
1118 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
1120 player.throw_antispam = time + autocvar_g_ctf_pass_wait;
1123 else if(player.flagcarried)
1127 if(vlen(player.origin - WarpZone_UnTransformOrigin(head, head.origin)) < vlen(player.origin - WarpZone_UnTransformOrigin(closest_target, closest_target.origin)))
1128 { closest_target = head; }
1130 else { closest_target = head; }
1136 if(closest_target) { ctf_Handle_Throw(player, closest_target, DROP_PASS); return 0; }
1139 // throw the flag in front of you
1140 if(autocvar_g_ctf_drop && player.flagcarried)
1141 { ctf_Handle_Throw(player, world, DROP_THROW); }
1147 MUTATOR_HOOKFUNCTION(ctf_HelpMePing)
1149 if(self.wps_flagcarrier) // update the flagcarrier waypointsprite with "NEEDING HELP" notification
1151 WaypointSprite_HelpMePing(self.wps_flagcarrier);
1153 else // create a normal help me waypointsprite
1155 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');
1156 WaypointSprite_Ping(self.wps_helpme);
1162 MUTATOR_HOOKFUNCTION(ctf_VehicleEnter)
1164 if(vh_player.flagcarried)
1166 if(!autocvar_g_ctf_flagcarrier_allow_vehicle_carry)
1168 ctf_Handle_Throw(vh_player, world, DROP_NORMAL);
1172 setattachment(vh_player.flagcarried, vh_vehicle, "");
1173 setorigin(vh_player.flagcarried, VEHICLE_FLAG_OFFSET);
1174 vh_player.flagcarried.scale = VEHICLE_FLAG_SCALE;
1175 //vh_player.flagcarried.angles = '0 0 0';
1182 MUTATOR_HOOKFUNCTION(ctf_VehicleExit)
1184 if(vh_player.flagcarried)
1186 setattachment(vh_player.flagcarried, vh_player, "");
1187 setorigin(vh_player.flagcarried, FLAG_CARRY_OFFSET);
1188 vh_player.flagcarried.scale = FLAG_SCALE;
1189 vh_player.flagcarried.angles = '0 0 0';
1195 MUTATOR_HOOKFUNCTION(ctf_AbortSpeedrun)
1197 if(self.flagcarried)
1199 bprint("The ", self.flagcarried.netname, " was returned to base by its carrier\n");
1200 ctf_RespawnFlag(self);
1206 MUTATOR_HOOKFUNCTION(ctf_MatchEnd)
1208 entity flag; // temporary entity for the search method
1210 for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
1212 switch(flag.ctf_status)
1217 // lock the flag, game is over
1218 flag.movetype = MOVETYPE_NONE;
1219 flag.takedamage = DAMAGE_NO;
1220 flag.solid = SOLID_NOT;
1221 flag.nextthink = 0; // stop thinking
1223 print("stopping the ", flag.netname, " from moving.\n");
1231 // do nothing for these flags
1245 /*QUAKED spawnfunc_info_player_team1 (1 0 0) (-16 -16 -24) (16 16 24)
1246 CTF Starting point for a player in team one (Red).
1247 Keys: "angle" viewing angle when spawning. */
1248 void spawnfunc_info_player_team1()
1250 if(g_assault) { remove(self); return; }
1252 self.team = COLOR_TEAM1; // red
1253 spawnfunc_info_player_deathmatch();
1257 /*QUAKED spawnfunc_info_player_team2 (1 0 0) (-16 -16 -24) (16 16 24)
1258 CTF Starting point for a player in team two (Blue).
1259 Keys: "angle" viewing angle when spawning. */
1260 void spawnfunc_info_player_team2()
1262 if(g_assault) { remove(self); return; }
1264 self.team = COLOR_TEAM2; // blue
1265 spawnfunc_info_player_deathmatch();
1268 /*QUAKED spawnfunc_info_player_team3 (1 0 0) (-16 -16 -24) (16 16 24)
1269 CTF Starting point for a player in team three (Yellow).
1270 Keys: "angle" viewing angle when spawning. */
1271 void spawnfunc_info_player_team3()
1273 if(g_assault) { remove(self); return; }
1275 self.team = COLOR_TEAM3; // yellow
1276 spawnfunc_info_player_deathmatch();
1280 /*QUAKED spawnfunc_info_player_team4 (1 0 0) (-16 -16 -24) (16 16 24)
1281 CTF Starting point for a player in team four (Purple).
1282 Keys: "angle" viewing angle when spawning. */
1283 void spawnfunc_info_player_team4()
1285 if(g_assault) { remove(self); return; }
1287 self.team = COLOR_TEAM4; // purple
1288 spawnfunc_info_player_deathmatch();
1291 /*QUAKED spawnfunc_item_flag_team1 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1292 CTF flag for team one (Red).
1294 "angle" Angle the flag will point (minus 90 degrees)...
1295 "model" model to use, note this needs red and blue as skins 0 and 1...
1296 "noise" sound played when flag is picked up...
1297 "noise1" sound played when flag is returned by a teammate...
1298 "noise2" sound played when flag is captured...
1299 "noise3" sound played when flag is lost in the field and respawns itself...
1300 "noise4" sound played when flag is dropped by a player...
1301 "noise5" sound played when flag touches the ground... */
1302 void spawnfunc_item_flag_team1()
1304 if(!g_ctf) { remove(self); return; }
1306 ctf_FlagSetup(1, self); // 1 = red
1309 /*QUAKED spawnfunc_item_flag_team2 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1310 CTF flag for team two (Blue).
1312 "angle" Angle the flag will point (minus 90 degrees)...
1313 "model" model to use, note this needs red and blue as skins 0 and 1...
1314 "noise" sound played when flag is picked up...
1315 "noise1" sound played when flag is returned by a teammate...
1316 "noise2" sound played when flag is captured...
1317 "noise3" sound played when flag is lost in the field and respawns itself...
1318 "noise4" sound played when flag is dropped by a player...
1319 "noise5" sound played when flag touches the ground... */
1320 void spawnfunc_item_flag_team2()
1322 if(!g_ctf) { remove(self); return; }
1324 ctf_FlagSetup(0, self); // the 0 is misleading, but -- 0 = blue.
1327 /*QUAKED spawnfunc_ctf_team (0 .5 .8) (-16 -16 -24) (16 16 32)
1328 Team declaration for CTF gameplay, this allows you to decide what team names and control point models are used in your map.
1329 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.
1331 "netname" Name of the team (for example Red, Blue, Green, Yellow, Life, Death, Offense, Defense, etc)...
1332 "cnt" Scoreboard color of the team (for example 4 is red and 13 is blue)... */
1333 void spawnfunc_ctf_team()
1335 if(!g_ctf) { remove(self); return; }
1337 self.classname = "ctf_team";
1338 self.team = self.cnt + 1;
1346 // code from here on is just to support maps that don't have flag and team entities
1347 void ctf_SpawnTeam (string teamname, float teamcolor)
1352 self.classname = "ctf_team";
1353 self.netname = teamname;
1354 self.cnt = teamcolor;
1356 spawnfunc_ctf_team();
1361 void ctf_DelayedInit() // Do this check with a delay so we can wait for teams to be set up.
1363 // if no teams are found, spawn defaults
1364 if(find(world, classname, "ctf_team") == world)
1366 print("No ""ctf_team"" entities found on this map, creating them anyway.\n");
1367 ctf_SpawnTeam("Red", COLOR_TEAM1 - 1);
1368 ctf_SpawnTeam("Blue", COLOR_TEAM2 - 1);
1374 void ctf_Initialize()
1376 ctf_captimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));
1378 ctf_captureshield_min_negscore = autocvar_g_ctf_shield_min_negscore;
1379 ctf_captureshield_max_ratio = autocvar_g_ctf_shield_max_ratio;
1380 ctf_captureshield_force = autocvar_g_ctf_shield_force;
1382 InitializeEntity(world, ctf_DelayedInit, INITPRIO_GAMETYPE);
1386 MUTATOR_DEFINITION(gamemode_ctf)
1388 MUTATOR_HOOK(MakePlayerObserver, ctf_RemovePlayer, CBC_ORDER_ANY);
1389 MUTATOR_HOOK(ClientDisconnect, ctf_RemovePlayer, CBC_ORDER_ANY);
1390 MUTATOR_HOOK(PlayerDies, ctf_PlayerDies, CBC_ORDER_ANY);
1391 MUTATOR_HOOK(MatchEnd, ctf_MatchEnd, CBC_ORDER_ANY);
1392 MUTATOR_HOOK(PortalTeleport, ctf_PortalTeleport, CBC_ORDER_ANY);
1393 MUTATOR_HOOK(GiveFragsForKill, ctf_GiveFragsForKill, CBC_ORDER_ANY);
1394 MUTATOR_HOOK(PlayerPreThink, ctf_PlayerPreThink, CBC_ORDER_ANY);
1395 MUTATOR_HOOK(PlayerDamage_Calculate, ctf_PlayerDamage, CBC_ORDER_ANY);
1396 MUTATOR_HOOK(PlayerUseKey, ctf_PlayerUseKey, CBC_ORDER_ANY);
1397 MUTATOR_HOOK(HelpMePing, ctf_HelpMePing, CBC_ORDER_ANY);
1398 MUTATOR_HOOK(VehicleEnter, ctf_VehicleEnter, CBC_ORDER_ANY);
1399 MUTATOR_HOOK(VehicleExit, ctf_VehicleExit, CBC_ORDER_ANY);
1400 MUTATOR_HOOK(AbortSpeedrun, ctf_AbortSpeedrun, CBC_ORDER_ANY);
1404 if(time > 1) // game loads at time 1
1405 error("This is a game type and it cannot be added at runtime.");
1413 error("This is a game type and it cannot be removed at runtime.");