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;
257 if(!flag) { return; }
258 if((droptype == DROP_PASS) && !reciever) { return; }
260 if(flag.speedrunning) { ctf_RespawnFlag(flag); return; }
263 setattachment(flag, world, "");
264 setorigin(flag, player.origin + FLAG_DROP_OFFSET);
265 flag.owner.flagcarried = world;
267 flag.solid = SOLID_TRIGGER;
268 flag.ctf_droptime = time;
270 flag.flags = FL_ITEM | FL_NOTARGET; // clear FL_ONGROUND for MOVETYPE_TOSS
276 targ_origin = WarpZone_UnTransformOrigin(reciever, (0.5 * (reciever.absmin + reciever.absmax)));
277 flag.velocity = (normalize(targ_origin - player.origin) * autocvar_g_ctf_pass_velocity);
283 makevectors((player.v_angle_y * '0 1 0') + (player.v_angle_x * '0.5 0 0'));
284 flag.velocity = W_CalculateProjectileVelocity(player.velocity, ('0 0 200' + (v_forward * autocvar_g_ctf_drop_velocity)), FALSE);
290 flag.velocity = '0 0 0'; // do nothing
297 flag.velocity = W_CalculateProjectileVelocity(player.velocity, ('0 0 200' + ('0 100 0' * crandom()) + ('100 0 0' * crandom())), FALSE);
307 flag.movetype = MOVETYPE_FLY;
308 flag.takedamage = DAMAGE_NO;
309 flag.pass_sender = player;
310 flag.pass_target = reciever;
311 flag.ctf_status = FLAG_PASSING;
314 sound(player, CH_TRIGGER, flag.snd_flag_touch, VOL_BASE, ATTN_NORM);
315 WarpZone_TrailParticles(world, particleeffectnum(flag.passeffect), targ_origin, player.origin);
316 ctf_EventLog("pass", flag.team, player);
330 ctf_Handle_Drop(flag, player, droptype);
335 // kill old waypointsprite
336 WaypointSprite_Ping(player.wps_flagcarrier);
337 WaypointSprite_Kill(player.wps_flagcarrier);
339 if(player.wps_enemyflagcarrier)
340 WaypointSprite_Kill(player.wps_enemyflagcarrier);
343 ctf_CaptureShield_Update(player, 0); // shield player from picking up flag
351 void ctf_Handle_Capture(entity flag, entity toucher, float capturetype)
353 entity enemy_flag = ((capturetype == CAPTURE_NORMAL) ? toucher.flagcarried : toucher);
354 entity player = ((capturetype == CAPTURE_NORMAL) ? toucher : enemy_flag.ctf_dropper);
356 if not(player) { return; } // without someone to give the reward to, we can't possibly cap
358 // messages and sounds
359 Send_KillNotification(player.netname, enemy_flag.netname, ctf_CaptureRecord(enemy_flag, player), INFO_CAPTUREFLAG, MSG_INFO);
360 sound(player, CH_TRIGGER, flag.snd_flag_capture, VOL_BASE, ATTN_NONE);
364 case CAPTURE_NORMAL: ctf_EventLog("capture", enemy_flag.team, player); break;
365 case CAPTURE_DROPPED: ctf_EventLog("droppedcapture", enemy_flag.team, player); break;
370 PlayerTeamScore_AddScore(player, ctf_ReadScore("score_capture"));
371 PlayerTeamScore_Add(player, SP_CTF_CAPS, ST_CTF_CAPS, 1);
374 if(autocvar_g_ctf_flag_capture_effects)
376 pointparticles(particleeffectnum((player.team == COLOR_TEAM1) ? "red_ground_quake" : "blue_ground_quake"), flag.origin, '0 0 0', 1);
377 shockwave_spawn("models/ctf/shockwavetransring.md3", flag.origin - '0 0 15', -0.8, 0, 1);
381 if(capturetype == CAPTURE_NORMAL)
383 WaypointSprite_Kill(player.wps_flagcarrier);
384 if(flag.speedrunning) { ctf_FakeTimeLimit(player, -1); }
388 player.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
389 ctf_RespawnFlag(enemy_flag);
392 void ctf_Handle_Return(entity flag, entity player)
394 // messages and sounds
395 //centerprint(player, strcat("You returned the ", flag.netname));
396 Send_KillNotification(player.netname, flag.netname, "", INFO_RETURNFLAG, MSG_INFO);
397 sound(player, CH_TRIGGER, flag.snd_flag_returned, VOL_BASE, ATTN_NONE);
398 ctf_EventLog("return", flag.team, player);
401 PlayerTeamScore_AddScore(player, ctf_ReadScore("score_return")); // reward for return
402 PlayerScore_Add(player, SP_CTF_RETURNS, 1); // add to count of returns
404 TeamScore_AddToTeam(flag.team, ST_SCORE, -ctf_ReadScore("penalty_returned")); // punish the team who was last carrying it
408 PlayerScore_Add(flag.ctf_dropper, SP_SCORE, -ctf_ReadScore("penalty_returned")); // punish the player who dropped the flag
409 ctf_CaptureShield_Update(flag.ctf_dropper, 0); // shield player from picking up flag
410 flag.ctf_dropper.next_take_time = time + autocvar_g_ctf_flag_collect_delay; // set next take time
414 ctf_RespawnFlag(flag);
417 void ctf_Handle_Pickup(entity flag, entity player, float pickuptype)
420 entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
421 string verbosename; // holds the name of the player OR no name at all for printing in the centerprints
422 float pickup_dropped_score; // used to calculate dropped pickup score
424 // attach the flag to the player
426 player.flagcarried = flag;
427 setattachment(flag, player, "");
428 setorigin(flag, FLAG_CARRY_OFFSET);
431 flag.movetype = MOVETYPE_NONE;
432 flag.takedamage = DAMAGE_NO;
433 flag.solid = SOLID_NOT;
434 flag.angles = '0 0 0';
435 flag.ctf_carrier = player;
436 flag.ctf_status = FLAG_CARRY;
440 case PICKUP_BASE: flag.ctf_pickuptime = time; break; // used for timing runs
441 case PICKUP_DROPPED: flag.health = flag.max_flag_health; break; // reset health/return timelimit
445 // messages and sounds
446 Send_KillNotification (player.netname, flag.netname, "", INFO_GOTFLAG, MSG_INFO);
447 sound(player, CH_TRIGGER, flag.snd_flag_taken, VOL_BASE, ATTN_NONE);
448 verbosename = ((autocvar_g_ctf_flag_pickup_verbosename) ? strcat(Team_ColorCode(player.team), "(^7", player.netname, Team_ColorCode(player.team), ") ") : "");
450 FOR_EACH_REALPLAYER(tmp_player)
452 if(tmp_player == player)
453 centerprint(tmp_player, strcat("You got the ", flag.netname, "!"));
454 else if(!IsDifferentTeam(tmp_player, player))
455 centerprint(tmp_player, strcat("Your ", Team_ColorCode(player.team), "team mate ", verbosename, "^7got the flag! Protect them!"));
456 else if(!IsDifferentTeam(tmp_player, flag))
457 centerprint(tmp_player, strcat("The ", Team_ColorCode(player.team), "enemy ", verbosename, "^7got your flag! Retrieve it!"));
462 case PICKUP_BASE: ctf_EventLog("steal", flag.team, player); break;
463 case PICKUP_DROPPED: ctf_EventLog("pickup", flag.team, player); break;
468 PlayerScore_Add(player, SP_CTF_PICKUPS, 1);
473 PlayerTeamScore_AddScore(player, ctf_ReadScore("score_pickup_base"));
479 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);
480 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);
481 print("pickup_dropped_score is ", ftos(pickup_dropped_score), "\n");
482 PlayerTeamScore_AddScore(player, pickup_dropped_score);
490 if(pickuptype == PICKUP_BASE)
492 flag.speedrunning = player.speedrunning; // if speedrunning, flag will flag-return and teleport the owner back after the record
493 if((player.speedrunning) && (ctf_captimerecord))
494 ctf_FakeTimeLimit(player, time + ctf_captimerecord);
498 if(autocvar_g_ctf_flag_pickup_effects)
499 pointparticles(particleeffectnum("smoke_ring"), 0.5 * (flag.absmin + flag.absmax), '0 0 0', 1);
502 if(pickuptype == PICKUP_DROPPED) { WaypointSprite_Kill(flag.wps_flagdropped); }
503 ctf_FlagcarrierWaypoints(player);
504 WaypointSprite_Ping(player.wps_flagcarrier);
508 // ===================
509 // Main Flag Functions
510 // ===================
512 void ctf_CheckFlagReturn(entity flag, float returntype)
514 if(flag.wps_flagdropped) { WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health); }
516 if((flag.health <= 0) || (time >= flag.ctf_droptime + autocvar_g_ctf_flag_return_time))
520 case RETURN_DROPPED: bprint("The ", flag.netname, " was dropped in the base and returned itself\n"); break;
521 case RETURN_DAMAGE: bprint("The ", flag.netname, " was destroyed and returned to base\n"); break;
522 case RETURN_SPEEDRUN: bprint("The ", flag.netname, " became impatient after ", ftos_decimals(ctf_captimerecord, 2), " seconds and returned itself\n"); break;
523 case RETURN_NEEDKILL: bprint("The ", flag.netname, " fell somewhere it couldn't be reached and returned to base\n"); break;
527 { bprint("The ", flag.netname, " has returned to base\n"); break; }
529 sound(flag, CH_TRIGGER, flag.snd_flag_respawn, VOL_BASE, ATTN_NONE);
530 ctf_EventLog("returned", flag.team, world);
531 ctf_RespawnFlag(flag);
535 void ctf_CheckStalemate(void)
538 float stale_red_flags, stale_blue_flags;
541 entity ctf_staleflaglist; // reset the list, we need to build the list each time this function runs
543 // build list of stale flags
544 for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
546 if(autocvar_g_ctf_flagcarrier_waypointforenemy_stalemate)
547 if(tmp_entity.ctf_status != FLAG_BASE)
548 if(time >= tmp_entity.ctf_pickuptime + autocvar_g_ctf_flagcarrier_waypointforenemy_stalemate)
550 tmp_entity.ctf_staleflagnext = ctf_staleflaglist; // link flag into staleflaglist
551 ctf_staleflaglist = tmp_entity;
553 switch(tmp_entity.team)
555 case COLOR_TEAM1: ++stale_red_flags; break;
556 case COLOR_TEAM2: ++stale_blue_flags; break;
561 if(stale_red_flags && stale_blue_flags)
562 ctf_stalemate = TRUE;
563 else if(!stale_red_flags && !stale_blue_flags)
564 ctf_stalemate = FALSE;
566 // if sufficient stalemate, then set up the waypointsprite and announce the stalemate if necessary
569 for(tmp_entity = ctf_staleflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_staleflagnext)
571 if((tmp_entity.owner) && (!tmp_entity.owner.wps_enemyflagcarrier))
572 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));
575 if not(wpforenemy_announced)
577 FOR_EACH_REALPLAYER(tmp_entity)
578 if(tmp_entity.flagcarried)
579 centerprint(tmp_entity, "Stalemate! Enemies can now see you on radar!");
581 centerprint(tmp_entity, "Stalemate! Flag carriers can now be seen by enemies on radar!");
583 wpforenemy_announced = TRUE;
588 void ctf_FlagDamage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
590 if(ITEM_DAMAGE_NEEDKILL(deathtype))
592 // automatically kill the flag and return it
594 ctf_CheckFlagReturn(self, RETURN_NEEDKILL);
597 if(autocvar_g_ctf_flag_return_damage)
599 // reduce health and check if it should be returned
600 self.health = self.health - damage;
601 ctf_CheckFlagReturn(self, RETURN_DAMAGE);
611 self.nextthink = time + FLAG_THINKRATE; // only 5 fps, more is unnecessary.
614 if(self == ctf_worldflaglist) // only for the first flag
615 FOR_EACH_CLIENT(tmp_entity)
616 ctf_CaptureShield_Update(tmp_entity, 1); // release shield only
619 if(self.mins != FLAG_MIN || self.maxs != FLAG_MAX) { // reset the flag boundaries in case it got squished
620 dprint("wtf the flag got squashed?\n");
621 tracebox(self.origin, FLAG_MIN, FLAG_MAX, self.origin, MOVE_NOMONSTERS, self);
622 if(!trace_startsolid) // can we resize it without getting stuck?
623 setsize(self, FLAG_MIN, FLAG_MAX); }
625 switch(self.ctf_status) // reset flag angles in case warpzones adjust it
630 self.angles = '0 0 0';
638 switch(self.ctf_status)
642 if(autocvar_g_ctf_dropped_capture_radius)
644 for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
645 if(tmp_entity.ctf_status == FLAG_DROPPED)
646 if(vlen(self.origin - tmp_entity.origin) < autocvar_g_ctf_dropped_capture_radius)
647 ctf_Handle_Capture(self, tmp_entity, CAPTURE_DROPPED);
654 if(autocvar_g_ctf_flag_dropped_floatinwater)
656 vector midpoint = ((self.absmin + self.absmax) * 0.5);
657 if(pointcontents(midpoint) == CONTENT_WATER)
659 self.velocity = self.velocity * 0.5;
661 if(pointcontents(midpoint + FLAG_FLOAT_OFFSET) == CONTENT_WATER)
662 { self.velocity_z = autocvar_g_ctf_flag_dropped_floatinwater; }
664 { self.movetype = MOVETYPE_FLY; }
666 else if(self.movetype == MOVETYPE_FLY) { self.movetype = MOVETYPE_TOSS; }
668 if(autocvar_g_ctf_flag_return_dropped)
670 if((vlen(self.origin - self.ctf_spawnorigin) <= autocvar_g_ctf_flag_return_dropped) || (autocvar_g_ctf_flag_return_dropped == -1))
673 ctf_CheckFlagReturn(self, RETURN_DROPPED);
677 if(autocvar_g_ctf_flag_return_time)
679 self.health -= ((self.max_flag_health / autocvar_g_ctf_flag_return_time) * FLAG_THINKRATE);
680 ctf_CheckFlagReturn(self, RETURN_TIMEOUT);
688 if(self.speedrunning && ctf_captimerecord && (time >= self.ctf_pickuptime + ctf_captimerecord))
691 ctf_CheckFlagReturn(self, RETURN_SPEEDRUN);
695 self.impulse = CHIMPULSE_SPEEDRUN; // move the player back to the waypoint they set
699 if(autocvar_g_ctf_flagcarrier_waypointforenemy_stalemate)
701 if(time >= wpforenemy_nextthink)
703 ctf_CheckStalemate();
704 wpforenemy_nextthink = time + WPFE_THINKRATE; // waypoint for enemy think rate (to reduce unnecessary spam of this check)
710 case FLAG_PASSING: // todo make work with warpzones
712 vector targ_origin = ((self.pass_target.absmin + self.pass_target.absmax) * 0.5);
713 vector old_targ_origin = targ_origin;
714 targ_origin = WarpZone_UnTransformOrigin(self.pass_target, targ_origin);
715 WarpZone_TraceLine(self.origin, targ_origin, MOVE_NOMONSTERS, self);
717 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");
719 if((self.pass_target.deadflag != DEAD_NO)
720 || (vlen(self.origin - targ_origin) > autocvar_g_ctf_pass_radius)
721 || ((trace_fraction < 1) && (trace_ent != self.pass_target))
722 || (time > self.ctf_droptime + autocvar_g_ctf_pass_timelimit))
724 ctf_Handle_Drop(self, world, DROP_PASS);
726 else // still a viable target, go for it
728 vector desired_direction = normalize(targ_origin - self.origin);
729 vector current_direction = normalize(self.velocity);
731 // self.velocity = (normalize(current_direction + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_pass_velocity);
732 self.velocity = (normalize(current_direction + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_pass_velocity);
737 default: // this should never happen
739 dprint("ctf_FlagThink(): Flag exists with no status?\n");
747 if(gameover) { return; }
749 entity toucher = other;
751 // automatically kill the flag and return it if it touched lava/slime/nodrop surfaces
752 if(ITEM_TOUCH_NEEDKILL())
755 ctf_CheckFlagReturn(self, RETURN_NEEDKILL);
759 // special touch behaviors
760 if(toucher.vehicle_flags & VHF_ISVEHICLE)
762 if(autocvar_g_ctf_allow_vehicle_touch)
763 toucher = toucher.owner; // the player is actually the vehicle owner, not other
765 return; // do nothing
767 else if(toucher.classname != "player") // The flag just touched an object, most likely the world
769 if(time > self.wait) // if we haven't in a while, play a sound/effect
771 pointparticles(particleeffectnum(self.toucheffect), self.origin, '0 0 0', 1);
772 sound(self, CH_TRIGGER, self.snd_flag_touch, VOL_BASE, ATTN_NORM);
773 self.wait = time + FLAG_TOUCHRATE;
777 else if(toucher.deadflag != DEAD_NO) { return; }
779 switch(self.ctf_status)
783 if(!IsDifferentTeam(toucher, self) && (toucher.flagcarried) && IsDifferentTeam(toucher.flagcarried, self))
784 ctf_Handle_Capture(self, toucher, CAPTURE_NORMAL); // toucher just captured the enemies flag to his base
785 else if(IsDifferentTeam(toucher, self) && (!toucher.flagcarried) && (!toucher.ctf_captureshielded) && (time > toucher.next_take_time))
786 ctf_Handle_Pickup(self, toucher, PICKUP_BASE); // toucher just stole the enemies flag
792 if(!IsDifferentTeam(toucher, self))
793 ctf_Handle_Return(self, toucher); // toucher just returned his own flag
794 else if((!toucher.flagcarried) && ((toucher != self.ctf_dropper) || (time > self.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
795 ctf_Handle_Pickup(self, toucher, PICKUP_DROPPED); // toucher just picked up a dropped enemy flag
801 dprint("Someone touched a flag even though it was being carried?\n");
807 if((toucher.classname == "player") && (toucher.deadflag == DEAD_NO) && (toucher != self.pass_sender))
809 if(IsDifferentTeam(toucher, self.pass_sender))
810 ctf_Handle_Return(self, toucher);
812 ctf_Handle_Retrieve(self, toucher);
819 void ctf_RespawnFlag(entity flag)
821 // reset the player (if there is one)
822 if((flag.owner) && (flag.owner.flagcarried == flag))
824 if(flag.owner.wps_enemyflagcarrier)
825 WaypointSprite_Kill(flag.owner.wps_enemyflagcarrier);
827 WaypointSprite_Kill(flag.wps_flagcarrier);
829 flag.owner.flagcarried = world;
831 if(flag.speedrunning)
832 ctf_FakeTimeLimit(flag.owner, -1);
835 if((flag.ctf_status == FLAG_DROPPED) && (flag.wps_flagdropped))
836 { WaypointSprite_Kill(flag.wps_flagdropped); }
839 setattachment(flag, world, "");
840 setorigin(flag, flag.ctf_spawnorigin);
842 flag.movetype = ((flag.noalign) ? MOVETYPE_NONE : MOVETYPE_TOSS);
843 flag.takedamage = DAMAGE_NO;
844 flag.health = flag.max_flag_health;
845 flag.solid = SOLID_TRIGGER;
846 flag.velocity = '0 0 0';
847 flag.angles = flag.mangle;
848 flag.flags = FL_ITEM | FL_NOTARGET;
850 flag.ctf_status = FLAG_BASE;
852 flag.pass_sender = world;
853 flag.pass_target = world;
854 flag.ctf_carrier = world;
855 flag.ctf_dropper = world;
856 flag.ctf_pickuptime = 0;
857 flag.ctf_droptime = 0;
859 wpforenemy_announced = FALSE;
865 if(self.owner.classname == "player")
866 ctf_Handle_Throw(self.owner, world, DROP_RESET);
868 ctf_RespawnFlag(self);
871 void ctf_DelayedFlagSetup(void) // called after a flag is placed on a map by ctf_FlagSetup()
874 waypoint_spawnforitem_force(self, self.origin);
875 self.nearestwaypointtimeout = 0; // activate waypointing again
876 self.bot_basewaypoint = self.nearestwaypoint;
879 WaypointSprite_SpawnFixed(((self.team == COLOR_TEAM1) ? "redbase" : "bluebase"), self.origin + FLAG_WAYPOINT_OFFSET, self, wps_flagbase, RADARICON_FLAG, colormapPaletteColor(self.team - 1, FALSE));
880 WaypointSprite_UpdateTeamRadar(self.wps_flagbase, RADARICON_FLAG, colormapPaletteColor(self.team - 1, FALSE));
882 // captureshield setup
883 ctf_CaptureShield_Spawn(self);
886 void ctf_FlagSetup(float teamnumber, entity flag) // called when spawning a flag entity on the map as a spawnfunc
889 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.
890 self = flag; // for later usage with droptofloor()
893 flag.ctf_worldflagnext = ctf_worldflaglist; // link flag into ctf_worldflaglist
894 ctf_worldflaglist = flag;
896 setattachment(flag, world, "");
898 flag.netname = ((teamnumber) ? "^1RED^7 flag" : "^4BLUE^7 flag");
899 flag.team = ((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2); // COLOR_TEAM1: color 4 team (red) - COLOR_TEAM2: color 13 team (blue)
900 flag.items = ((teamnumber) ? IT_KEY2 : IT_KEY1); // IT_KEY2: gold key (redish enough) - IT_KEY1: silver key (bluish enough)
901 flag.classname = "item_flag_team";
902 flag.target = "###item###"; // wut?
903 flag.flags = FL_ITEM | FL_NOTARGET;
904 flag.solid = SOLID_TRIGGER;
905 flag.takedamage = DAMAGE_NO;
906 flag.damageforcescale = autocvar_g_ctf_flag_damageforcescale;
907 flag.max_flag_health = ((autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health) ? autocvar_g_ctf_flag_health : 100);
908 flag.health = flag.max_flag_health;
909 flag.event_damage = ctf_FlagDamage;
910 flag.pushable = TRUE;
911 flag.teleportable = TELEPORT_NORMAL;
912 flag.damagedbytriggers = autocvar_g_ctf_flag_return_when_unreachable;
913 flag.damagedbycontents = autocvar_g_ctf_flag_return_when_unreachable;
914 flag.velocity = '0 0 0';
915 flag.mangle = flag.angles;
916 flag.reset = ctf_Reset;
917 flag.touch = ctf_FlagTouch;
918 flag.think = ctf_FlagThink;
919 flag.nextthink = time + FLAG_THINKRATE;
920 flag.ctf_status = FLAG_BASE;
922 if(!flag.model) { flag.model = ((teamnumber) ? autocvar_g_ctf_flag_red_model : autocvar_g_ctf_flag_blue_model); }
923 if(!flag.scale) { flag.scale = FLAG_SCALE; }
924 if(!flag.skin) { flag.skin = ((teamnumber) ? autocvar_g_ctf_flag_red_skin : autocvar_g_ctf_flag_blue_skin); }
925 if(!flag.toucheffect) { flag.toucheffect = ((teamnumber) ? "redflag_touch" : "blueflag_touch"); }
926 if(!flag.passeffect) { flag.passeffect = ((!teamnumber) ? "red_pass" : "blue_pass"); } // invert the team number of the flag to pass as enemy team color
929 if(!flag.snd_flag_taken) { flag.snd_flag_taken = ((teamnumber) ? "ctf/red_taken.wav" : "ctf/blue_taken.wav"); }
930 if(!flag.snd_flag_returned) { flag.snd_flag_returned = ((teamnumber) ? "ctf/red_returned.wav" : "ctf/blue_returned.wav"); }
931 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
932 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.
933 if(!flag.snd_flag_dropped) { flag.snd_flag_dropped = ((teamnumber) ? "ctf/red_dropped.wav" : "ctf/blue_dropped.wav"); }
934 if(!flag.snd_flag_touch) { flag.snd_flag_touch = "ctf/touch.wav"; } // again has no team-based sound
935 if(!flag.snd_flag_pass) { flag.snd_flag_pass = "ctf/pass.wav"; } // same story here
938 precache_sound(flag.snd_flag_taken);
939 precache_sound(flag.snd_flag_returned);
940 precache_sound(flag.snd_flag_capture);
941 precache_sound(flag.snd_flag_respawn);
942 precache_sound(flag.snd_flag_dropped);
943 precache_sound(flag.snd_flag_touch);
944 precache_sound(flag.snd_flag_pass);
945 precache_model(flag.model);
946 precache_model("models/ctf/shield.md3");
947 precache_model("models/ctf/shockwavetransring.md3");
950 setmodel(flag, flag.model); // precision set below
951 setsize(flag, FLAG_MIN, FLAG_MAX);
952 setorigin(flag, (flag.origin + FLAG_SPAWN_OFFSET));
954 if(autocvar_g_ctf_flag_glowtrails)
956 flag.glow_color = ((teamnumber) ? 251 : 210); // 251: red - 210: blue
961 flag.effects |= EF_LOWPRECISION;
962 if(autocvar_g_ctf_fullbrightflags) { flag.effects |= EF_FULLBRIGHT; }
963 if(autocvar_g_ctf_dynamiclights) { flag.effects |= ((teamnumber) ? EF_RED : EF_BLUE); }
966 if((flag.spawnflags & 1) || flag.noalign) // don't drop to floor, just stay at fixed location
968 flag.dropped_origin = flag.origin;
970 flag.movetype = MOVETYPE_NONE;
972 else // drop to floor, automatically find a platform and set that as spawn origin
974 flag.noalign = FALSE;
977 flag.movetype = MOVETYPE_TOSS;
980 InitializeEntity(flag, ctf_DelayedFlagSetup, INITPRIO_SETLOCATION);
988 MUTATOR_HOOKFUNCTION(ctf_PlayerPreThink)
992 // initially clear items so they can be set as necessary later.
993 self.items &~= (IT_RED_FLAG_CARRYING | IT_RED_FLAG_TAKEN | IT_RED_FLAG_LOST
994 | IT_BLUE_FLAG_CARRYING | IT_BLUE_FLAG_TAKEN | IT_BLUE_FLAG_LOST | IT_CTF_SHIELDED);
996 // scan through all the flags and notify the client about them
997 for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
999 switch(flag.ctf_status)
1003 if(flag.owner == self)
1004 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_CARRYING : IT_BLUE_FLAG_CARRYING); // carrying: self is currently carrying the flag
1006 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_TAKEN : IT_BLUE_FLAG_TAKEN); // taken: someone on self's team is carrying the flag
1011 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_LOST : IT_BLUE_FLAG_LOST); // lost: the flag is dropped somewhere on the map
1017 // item for stopping players from capturing the flag too often
1018 if(self.ctf_captureshielded)
1019 self.items |= IT_CTF_SHIELDED;
1021 // update the health of the flag carrier waypointsprite
1022 if(self.wps_flagcarrier)
1023 WaypointSprite_UpdateHealth(self.wps_flagcarrier, self.health);
1028 MUTATOR_HOOKFUNCTION(ctf_PlayerDamage) // for changing damage and force values that are applied to players in g_damage.qc
1030 if(frag_attacker.flagcarried) // if the attacker is a flagcarrier
1032 if(frag_target == frag_attacker) // damage done to yourself
1034 frag_damage *= autocvar_g_ctf_flagcarrier_selfdamagefactor;
1035 frag_force *= autocvar_g_ctf_flagcarrier_selfforcefactor;
1037 else // damage done to everyone else
1039 frag_damage *= autocvar_g_ctf_flagcarrier_damagefactor;
1040 frag_force *= autocvar_g_ctf_flagcarrier_forcefactor;
1043 else if(frag_target.flagcarried && (frag_target.deadflag == DEAD_NO) && IsDifferentTeam(frag_target, frag_attacker)) // if the target is a flagcarrier
1045 if(autocvar_g_ctf_flagcarrier_auto_helpme_when_damaged > frag_target.health)
1046 WaypointSprite_HelpMePing(frag_target.wps_flagcarrier); // TODO: only do this if there is a significant loss of health?
1051 MUTATOR_HOOKFUNCTION(ctf_PlayerDies)
1053 if((frag_attacker != frag_target) && (frag_attacker.classname == "player") && (frag_target.flagcarried))
1055 PlayerTeamScore_AddScore(frag_attacker, ctf_ReadScore("score_kill"));
1056 PlayerScore_Add(frag_attacker, SP_CTF_FCKILLS, 1);
1059 if(frag_target.flagcarried)
1060 { ctf_Handle_Throw(frag_target, world, DROP_NORMAL); }
1065 MUTATOR_HOOKFUNCTION(ctf_GiveFragsForKill)
1068 return (autocvar_g_ctf_ignore_frags); // no frags counted in ctf if this is true
1071 MUTATOR_HOOKFUNCTION(ctf_RemovePlayer)
1073 if(self.flagcarried)
1074 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
1079 MUTATOR_HOOKFUNCTION(ctf_PortalTeleport)
1081 if(self.flagcarried)
1082 if(!autocvar_g_ctf_portalteleport)
1083 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
1088 MUTATOR_HOOKFUNCTION(ctf_PlayerUseKey)
1090 entity player = self;
1092 if((time > player.throw_antispam) && (player.deadflag == DEAD_NO) && !player.speedrunning && (!player.vehicle || autocvar_g_ctf_allow_vehicle_touch))
1094 // pass the flag to a team mate
1095 if(autocvar_g_ctf_pass)
1097 entity head, closest_target;
1098 head = WarpZone_FindRadius(player.origin, autocvar_g_ctf_pass_radius, TRUE);
1100 while(head) // find the closest acceptable target to pass to
1102 if(head.classname == "player" && head.deadflag == DEAD_NO)
1103 if(head != player && !IsDifferentTeam(head, player))
1104 if(!head.speedrunning && (!head.vehicle || autocvar_g_ctf_allow_vehicle_touch))
1106 if(autocvar_g_ctf_pass_request && !player.flagcarried && head.flagcarried)
1108 if(clienttype(head) == CLIENTTYPE_BOT)
1110 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
1111 ctf_Handle_Throw(head, player, DROP_PASS);
1115 centerprint(head, strcat(player.netname, " requests you to pass the ", head.flagcarried.netname));
1116 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
1118 player.throw_antispam = time + autocvar_g_ctf_pass_wait;
1121 else if(player.flagcarried)
1125 if(vlen(player.origin - WarpZone_UnTransformOrigin(head, head.origin)) < vlen(player.origin - WarpZone_UnTransformOrigin(closest_target, closest_target.origin)))
1126 { closest_target = head; }
1128 else { closest_target = head; }
1134 if(closest_target) { ctf_Handle_Throw(player, closest_target, DROP_PASS); return 0; }
1137 // throw the flag in front of you
1138 if(autocvar_g_ctf_drop && player.flagcarried)
1139 { ctf_Handle_Throw(player, world, DROP_THROW); }
1145 MUTATOR_HOOKFUNCTION(ctf_HelpMePing)
1147 if(self.wps_flagcarrier) // update the flagcarrier waypointsprite with "NEEDING HELP" notification
1149 WaypointSprite_HelpMePing(self.wps_flagcarrier);
1151 else // create a normal help me waypointsprite
1153 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');
1154 WaypointSprite_Ping(self.wps_helpme);
1160 MUTATOR_HOOKFUNCTION(ctf_VehicleEnter)
1162 if(vh_player.flagcarried)
1164 if(!autocvar_g_ctf_flagcarrier_allow_vehicle_carry)
1166 ctf_Handle_Throw(vh_player, world, DROP_NORMAL);
1170 setattachment(vh_player.flagcarried, vh_vehicle, "");
1171 setorigin(vh_player.flagcarried, VEHICLE_FLAG_OFFSET);
1172 vh_player.flagcarried.scale = VEHICLE_FLAG_SCALE;
1173 //vh_player.flagcarried.angles = '0 0 0';
1180 MUTATOR_HOOKFUNCTION(ctf_VehicleExit)
1182 if(vh_player.flagcarried)
1184 setattachment(vh_player.flagcarried, vh_player, "");
1185 setorigin(vh_player.flagcarried, FLAG_CARRY_OFFSET);
1186 vh_player.flagcarried.scale = FLAG_SCALE;
1187 vh_player.flagcarried.angles = '0 0 0';
1193 MUTATOR_HOOKFUNCTION(ctf_AbortSpeedrun)
1195 if(self.flagcarried)
1197 bprint("The ", self.flagcarried.netname, " was returned to base by its carrier\n");
1198 ctf_RespawnFlag(self);
1204 MUTATOR_HOOKFUNCTION(ctf_MatchEnd)
1206 entity flag; // temporary entity for the search method
1208 for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
1210 switch(flag.ctf_status)
1215 // lock the flag, game is over
1216 flag.movetype = MOVETYPE_NONE;
1217 flag.takedamage = DAMAGE_NO;
1218 flag.solid = SOLID_NOT;
1219 flag.nextthink = 0; // stop thinking
1221 print("stopping the ", flag.netname, " from moving.\n");
1229 // do nothing for these flags
1243 /*QUAKED spawnfunc_info_player_team1 (1 0 0) (-16 -16 -24) (16 16 24)
1244 CTF Starting point for a player in team one (Red).
1245 Keys: "angle" viewing angle when spawning. */
1246 void spawnfunc_info_player_team1()
1248 if(g_assault) { remove(self); return; }
1250 self.team = COLOR_TEAM1; // red
1251 spawnfunc_info_player_deathmatch();
1255 /*QUAKED spawnfunc_info_player_team2 (1 0 0) (-16 -16 -24) (16 16 24)
1256 CTF Starting point for a player in team two (Blue).
1257 Keys: "angle" viewing angle when spawning. */
1258 void spawnfunc_info_player_team2()
1260 if(g_assault) { remove(self); return; }
1262 self.team = COLOR_TEAM2; // blue
1263 spawnfunc_info_player_deathmatch();
1266 /*QUAKED spawnfunc_info_player_team3 (1 0 0) (-16 -16 -24) (16 16 24)
1267 CTF Starting point for a player in team three (Yellow).
1268 Keys: "angle" viewing angle when spawning. */
1269 void spawnfunc_info_player_team3()
1271 if(g_assault) { remove(self); return; }
1273 self.team = COLOR_TEAM3; // yellow
1274 spawnfunc_info_player_deathmatch();
1278 /*QUAKED spawnfunc_info_player_team4 (1 0 0) (-16 -16 -24) (16 16 24)
1279 CTF Starting point for a player in team four (Purple).
1280 Keys: "angle" viewing angle when spawning. */
1281 void spawnfunc_info_player_team4()
1283 if(g_assault) { remove(self); return; }
1285 self.team = COLOR_TEAM4; // purple
1286 spawnfunc_info_player_deathmatch();
1289 /*QUAKED spawnfunc_item_flag_team1 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1290 CTF flag for team one (Red).
1292 "angle" Angle the flag will point (minus 90 degrees)...
1293 "model" model to use, note this needs red and blue as skins 0 and 1...
1294 "noise" sound played when flag is picked up...
1295 "noise1" sound played when flag is returned by a teammate...
1296 "noise2" sound played when flag is captured...
1297 "noise3" sound played when flag is lost in the field and respawns itself...
1298 "noise4" sound played when flag is dropped by a player...
1299 "noise5" sound played when flag touches the ground... */
1300 void spawnfunc_item_flag_team1()
1302 if(!g_ctf) { remove(self); return; }
1304 ctf_FlagSetup(1, self); // 1 = red
1307 /*QUAKED spawnfunc_item_flag_team2 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1308 CTF flag for team two (Blue).
1310 "angle" Angle the flag will point (minus 90 degrees)...
1311 "model" model to use, note this needs red and blue as skins 0 and 1...
1312 "noise" sound played when flag is picked up...
1313 "noise1" sound played when flag is returned by a teammate...
1314 "noise2" sound played when flag is captured...
1315 "noise3" sound played when flag is lost in the field and respawns itself...
1316 "noise4" sound played when flag is dropped by a player...
1317 "noise5" sound played when flag touches the ground... */
1318 void spawnfunc_item_flag_team2()
1320 if(!g_ctf) { remove(self); return; }
1322 ctf_FlagSetup(0, self); // the 0 is misleading, but -- 0 = blue.
1325 /*QUAKED spawnfunc_ctf_team (0 .5 .8) (-16 -16 -24) (16 16 32)
1326 Team declaration for CTF gameplay, this allows you to decide what team names and control point models are used in your map.
1327 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.
1329 "netname" Name of the team (for example Red, Blue, Green, Yellow, Life, Death, Offense, Defense, etc)...
1330 "cnt" Scoreboard color of the team (for example 4 is red and 13 is blue)... */
1331 void spawnfunc_ctf_team()
1333 if(!g_ctf) { remove(self); return; }
1335 self.classname = "ctf_team";
1336 self.team = self.cnt + 1;
1344 // code from here on is just to support maps that don't have flag and team entities
1345 void ctf_SpawnTeam (string teamname, float teamcolor)
1350 self.classname = "ctf_team";
1351 self.netname = teamname;
1352 self.cnt = teamcolor;
1354 spawnfunc_ctf_team();
1359 void ctf_DelayedInit() // Do this check with a delay so we can wait for teams to be set up.
1361 // if no teams are found, spawn defaults
1362 if(find(world, classname, "ctf_team") == world)
1364 print("No ""ctf_team"" entities found on this map, creating them anyway.\n");
1365 ctf_SpawnTeam("Red", COLOR_TEAM1 - 1);
1366 ctf_SpawnTeam("Blue", COLOR_TEAM2 - 1);
1372 void ctf_Initialize()
1374 ctf_captimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));
1376 ctf_captureshield_min_negscore = autocvar_g_ctf_shield_min_negscore;
1377 ctf_captureshield_max_ratio = autocvar_g_ctf_shield_max_ratio;
1378 ctf_captureshield_force = autocvar_g_ctf_shield_force;
1380 InitializeEntity(world, ctf_DelayedInit, INITPRIO_GAMETYPE);
1384 MUTATOR_DEFINITION(gamemode_ctf)
1386 MUTATOR_HOOK(MakePlayerObserver, ctf_RemovePlayer, CBC_ORDER_ANY);
1387 MUTATOR_HOOK(ClientDisconnect, ctf_RemovePlayer, CBC_ORDER_ANY);
1388 MUTATOR_HOOK(PlayerDies, ctf_PlayerDies, CBC_ORDER_ANY);
1389 MUTATOR_HOOK(MatchEnd, ctf_MatchEnd, CBC_ORDER_ANY);
1390 MUTATOR_HOOK(PortalTeleport, ctf_PortalTeleport, CBC_ORDER_ANY);
1391 MUTATOR_HOOK(GiveFragsForKill, ctf_GiveFragsForKill, CBC_ORDER_ANY);
1392 MUTATOR_HOOK(PlayerPreThink, ctf_PlayerPreThink, CBC_ORDER_ANY);
1393 MUTATOR_HOOK(PlayerDamage_Calculate, ctf_PlayerDamage, CBC_ORDER_ANY);
1394 MUTATOR_HOOK(PlayerUseKey, ctf_PlayerUseKey, CBC_ORDER_ANY);
1395 MUTATOR_HOOK(HelpMePing, ctf_HelpMePing, CBC_ORDER_ANY);
1396 MUTATOR_HOOK(VehicleEnter, ctf_VehicleEnter, CBC_ORDER_ANY);
1397 MUTATOR_HOOK(VehicleExit, ctf_VehicleExit, CBC_ORDER_ANY);
1398 MUTATOR_HOOK(AbortSpeedrun, ctf_AbortSpeedrun, CBC_ORDER_ANY);
1402 if(time > 1) // game loads at time 1
1403 error("This is a game type and it cannot be added at runtime.");
1411 error("This is a game type and it cannot be removed at runtime.");