qcsrc/server/mutators/gamemode_ctf.qc

   1 // ================================================================
   2 //  Official capture the flag game mode coding, reworked by Samual
   3 //  Last updated: March 30th, 2012
   4 // ================================================================
   5
   6 float ctf_ReadScore(string parameter) // make this obsolete
   7 {
   8         //if(g_ctf_win_mode != 2)
   9                 return cvar(strcat("g_ctf_personal", parameter));
  10         //else
  11         //      return cvar(strcat("g_ctf_flag", parameter));
  12 }
  13
  14 void ctf_FakeTimeLimit(entity e, float t)
  15 {
  16         msg_entity = e;
  17         WriteByte(MSG_ONE, 3); // svc_updatestat
  18         WriteByte(MSG_ONE, 236); // STAT_TIMELIMIT
  19         if(t < 0)
  20                 WriteCoord(MSG_ONE, autocvar_timelimit);
  21         else
  22                 WriteCoord(MSG_ONE, (t + 1) / 60);
  23 }
  24
  25 void ctf_EventLog(string mode, float flagteam, entity actor) // use an alias for easy changing and quick editing later
  26 {
  27         if(autocvar_sv_eventlog)
  28                 GameLogEcho(strcat(":ctf:", mode, ":", ftos(flagteam), ((actor != world) ? (strcat(":", ftos(actor.playerid))) : "")));
  29 }
  30
  31 string ctf_CaptureRecord(entity flag, entity player)
  32 {
  33         float cap_time, cap_record, success;
  34         string cap_message, refername;
  35
  36         if((autocvar_g_ctf_captimerecord_always) || (player_count - currentbots))
  37         {
  38                 cap_record = ctf_captimerecord;
  39                 cap_time = (time - flag.ctf_pickuptime);
  40
  41                 refername = db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"));
  42                 refername = ((refername == player.netname) ? "their" : strcat(refername, "^7's"));
  43
  44                 if(!ctf_captimerecord)
  45                         { cap_message = strcat(" in ", ftos_decimals(cap_time, 2), " seconds"); success = TRUE; }
  46                 else if(cap_time < cap_record)
  47                         { cap_message = strcat(" in ", ftos_decimals(cap_time, 2), " seconds, breaking ", refername, " previous record of ", ftos_decimals(cap_record, 2), " seconds"); success = TRUE; }
  48                 else
  49                         { cap_message = strcat(" in ", ftos_decimals(cap_time, 2), " seconds, failing to break ", refername, " record of ", ftos_decimals(cap_record, 2), " seconds"); success = FALSE; }
  50
  51                 if(success)
  52                 {
  53                         ctf_captimerecord = cap_time;
  54                         db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time"), ftos(cap_time));
  55                         db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"), player.netname);
  56                         write_recordmarker(player, (time - cap_time), cap_time);
  57                 }
  58         }
  59
  60         return cap_message;
  61 }
  62
  63 void ctf_FlagcarrierWaypoints(entity player)
  64 {
  65         WaypointSprite_Spawn("flagcarrier", 0, 0, player, '0 0 64', world, player.team, player, wps_flagcarrier, FALSE, RADARICON_FLAG, '1 1 0');
  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, '1 1 0');
  69 }
  70
  71
  72 // =======================
  73 // CaptureShield Functions
  74 // =======================
  75
  76 float ctf_CaptureShield_CheckStatus(entity p)
  77 {
  78         float s, se;
  79         entity e;
  80         float players_worseeq, players_total;
  81
  82         if(ctf_captureshield_max_ratio <= 0)
  83                 return FALSE;
  84
  85         s = PlayerScore_Add(p, SP_SCORE, 0);
  86         if(s >= -ctf_captureshield_min_negscore)
  87                 return FALSE;
  88
  89         players_total = players_worseeq = 0;
  90         FOR_EACH_PLAYER(e)
  91         {
  92                 if(e.team != p.team)
  93                         continue;
  94                 se = PlayerScore_Add(e, SP_SCORE, 0);
  95                 if(se <= s)
  96                         ++players_worseeq;
  97                 ++players_total;
  98         }
  99
 100         // player is in the worse half, if >= half the players are better than him, or consequently, if < half of the players are worse
 101         // use this rule here
 102
 103         if(players_worseeq >= players_total * ctf_captureshield_max_ratio)
 104                 return FALSE;
 105
 106         return TRUE;
 107 }
 108
 109 void ctf_CaptureShield_Update(entity player, float wanted_status)
 110 {
 111         float updated_status = ctf_CaptureShield_CheckStatus(player);
 112         if((wanted_status == player.ctf_captureshielded) && (updated_status != wanted_status)) // 0: shield only, 1: unshield only
 113         {
 114                 if(updated_status) // TODO csqc notifier for this // Samual: How?
 115                         Send_CSQC_Centerprint_Generic(player, CPID_CTF_CAPTURESHIELD, "^3You are now ^4shielded^3 from the flag\n^3for ^1too many unsuccessful attempts^3 to capture.\n\n^3Make some defensive scores before trying again.", 5, 0);
 116                 else
 117                         Send_CSQC_Centerprint_Generic(player, CPID_CTF_CAPTURESHIELD, "^3You are now free.\n\n^3Feel free to ^1try to capture^3 the flag again\n^3if you think you will succeed.", 5, 0);
 118
 119                 player.ctf_captureshielded = updated_status;
 120         }
 121 }
 122
 123 float ctf_CaptureShield_Customize()
 124 {
 125         if not(other.ctf_captureshielded) { return FALSE; }
 126         if(self.team == other.team) { return FALSE; }
 127
 128         return TRUE;
 129 }
 130
 131 void ctf_CaptureShield_Touch()
 132 {
 133         if not(other.ctf_captureshielded) { return; }
 134         if(self.team == other.team) { return; }
 135
 136         vector mymid = (self.absmin + self.absmax) * 0.5;
 137         vector othermid = (other.absmin + other.absmax) * 0.5;
 138
 139         Damage(other, self, self, 0, DEATH_HURTTRIGGER, mymid, normalize(othermid - mymid) * ctf_captureshield_force);
 140         Send_CSQC_Centerprint_Generic(other, CPID_CTF_CAPTURESHIELD, "^3You are ^4shielded^3 from the flag\n^3for ^1too many unsuccessful attempts^3 to capture.\n\n^3Get some defensive scores before trying again.", 5, 0);
 141 }
 142
 143 void ctf_CaptureShield_Spawn(entity flag)
 144 {
 145         entity shield = spawn();
 146
 147         shield.enemy = self;
 148         shield.team = self.team;
 149         shield.touch = ctf_CaptureShield_Touch;
 150         shield.customizeentityforclient = ctf_CaptureShield_Customize;
 151         shield.classname = "ctf_captureshield";
 152         shield.effects = EF_ADDITIVE;
 153         shield.movetype = MOVETYPE_NOCLIP;
 154         shield.solid = SOLID_TRIGGER;
 155         shield.avelocity = '7 0 11';
 156         shield.scale = 0.5;
 157
 158         setorigin(shield, self.origin);
 159         setmodel(shield, "models/ctf/shield.md3");
 160         setsize(shield, shield.scale * shield.mins, shield.scale * shield.maxs);
 161 }
 162
 163
 164 // ====================
 165 // Drop/Pass/Throw Code
 166 // ====================
 167
 168 void ctf_Handle_Failed_Pass(entity flag)
 169 {
 170         entity sender = flag.pass_sender;
 171
 172         flag.movetype = MOVETYPE_TOSS;
 173         flag.takedamage = DAMAGE_YES;
 174         flag.health = flag.max_flag_health;
 175         flag.ctf_droptime = time;
 176         flag.ctf_dropper = sender;
 177         flag.ctf_status = FLAG_DROPPED;
 178
 179         // messages and sounds
 180         Send_KillNotification(sender.netname, flag.netname, "", INFO_LOSTFLAG, MSG_INFO);
 181         sound(flag, CH_TRIGGER, flag.snd_flag_dropped, VOL_BASE, ATTN_NONE);
 182         ctf_EventLog("dropped", sender.team, sender);
 183
 184         // scoring
 185         PlayerTeamScore_AddScore(sender, -ctf_ReadScore("penalty_drop"));
 186         PlayerScore_Add(sender, SP_CTF_DROPS, 1);
 187
 188         // waypoints
 189         if(autocvar_g_ctf_flag_dropped_waypoint)
 190                 WaypointSprite_Spawn("flagdropped", 0, 0, flag, '0 0 64', world, ((autocvar_g_ctf_flag_dropped_waypoint == 2) ? 0 : sender.team), flag, wps_flagdropped, FALSE, RADARICON_FLAG, '0 0.5 0' + ((flag.team == COLOR_TEAM1) ? '0.75 0 0' : '0 0 0.75'));
 191
 192         if(autocvar_g_ctf_flag_returntime || (autocvar_g_ctf_flag_take_damage && autocvar_g_ctf_flag_health))
 193         {
 194                 WaypointSprite_UpdateMaxHealth(flag.wps_flagdropped, flag.max_flag_health);
 195                 WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health);
 196         }
 197
 198         sender.throw_antispam = time + autocvar_g_ctf_pass_wait;
 199
 200         flag.pass_sender = world;
 201         flag.pass_target = world;
 202 }
 203
 204 void ctf_Handle_Retrieve(entity flag, entity player)
 205 {
 206         entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
 207         entity sender = flag.pass_sender;
 208
 209         // transfer flag to player
 210         flag.ctf_carrier = player;
 211         flag.owner = player;
 212         flag.owner.flagcarried = flag;
 213
 214         // reset flag
 215         setattachment(flag, player, "");
 216         setorigin(flag, FLAG_CARRY_OFFSET);
 217         flag.movetype = MOVETYPE_NONE;
 218         flag.takedamage = DAMAGE_NO;
 219         flag.solid = SOLID_NOT;
 220         flag.ctf_carrier = player;
 221         flag.ctf_status = FLAG_CARRY;
 222
 223         // messages and sounds
 224         sound(player, CH_TRIGGER, "keepaway/respawn.wav", VOL_BASE, ATTN_NORM);
 225         ctf_EventLog("recieve", flag.team, player);
 226         FOR_EACH_PLAYER(tmp_player)
 227                 if(tmp_player == sender)
 228                         centerprint(tmp_player, strcat("You passed the ", flag.netname, " to ", player.netname));
 229                 else if(tmp_player == player)
 230                         centerprint(tmp_player, strcat("You recieved the ", flag.netname, " from ", sender.netname));
 231                 else if(tmp_player.team == sender.team)
 232                         centerprint(tmp_player, strcat(sender.netname, " passed the ", flag.netname, " to ", player.netname));
 233
 234         // create new waypoint
 235         ctf_FlagcarrierWaypoints(player);
 236
 237         sender.throw_antispam = time + autocvar_g_ctf_pass_wait;
 238         player.throw_antispam = sender.throw_antispam;
 239
 240         flag.pass_sender = world;
 241         flag.pass_target = world;
 242 }
 243
 244 void ctf_Handle_Throw(entity player, entity reciever, float droptype)
 245 {
 246         entity flag = player.flagcarried;
 247
 248         if(!flag) { return; }
 249         if((droptype == DROP_PASS) && !reciever) { return; }
 250
 251         //if(flag.speedrunning) { ctf_RespawnFlag(flag); return; }
 252
 253         // reset the flag
 254         setattachment(flag, world, "");
 255         setorigin(flag, player.origin + FLAG_DROP_OFFSET);
 256         flag.owner.flagcarried = world;
 257         flag.owner = world;
 258         flag.solid = SOLID_TRIGGER;
 259         flag.ctf_droptime = time;
 260
 261         switch(droptype)
 262         {
 263                 case DROP_PASS:
 264                 {
 265                         vector targ_origin = (0.5 * (reciever.absmin + reciever.absmax));
 266                         flag.velocity = (normalize(targ_origin - player.origin) * autocvar_g_ctf_throw_velocity);
 267                         break;
 268                 }
 269
 270                 case DROP_THROW:
 271                 {
 272                         makevectors((player.v_angle_y * '0 1 0') + (player.v_angle_x * '0.5 0 0'));
 273                         flag.velocity = W_CalculateProjectileVelocity(player.velocity, ('0 0 200' + (v_forward * autocvar_g_ctf_throw_velocity)), FALSE);
 274                         break;
 275                 }
 276
 277                 default:
 278                 case DROP_NORMAL:
 279                 {
 280                         flag.velocity = ('0 0 200' + ('0 100 0' * crandom()) + ('100 0 0' * crandom()));
 281                         break;
 282                 }
 283         }
 284
 285         print("flag.velocity = ", vtos(flag.velocity), ".\n");
 286
 287         switch(droptype)
 288         {
 289                 case DROP_PASS:
 290                 {
 291                         // main
 292                         flag.movetype = MOVETYPE_FLY;
 293                         flag.takedamage = DAMAGE_NO;
 294                         flag.pass_sender = player;
 295                         flag.pass_target = reciever;
 296                         flag.ctf_status = FLAG_PASSING;
 297
 298                         // other
 299                         sound(player, CH_TRIGGER, flag.snd_flag_touch, VOL_BASE, ATTN_NORM);
 300                         ctf_EventLog("pass", flag.team, player);
 301                         te_lightning2(world, reciever.origin, player.origin);
 302                         break;
 303                 }
 304
 305                 default:
 306                 case DROP_THROW:
 307                 case DROP_NORMAL:
 308                 {
 309                         // main
 310                         flag.movetype = MOVETYPE_TOSS;
 311                         flag.takedamage = DAMAGE_YES;
 312                         flag.health = flag.max_flag_health;
 313                         flag.ctf_dropper = player;
 314                         flag.ctf_status = FLAG_DROPPED;
 315
 316                         // messages and sounds
 317                         Send_KillNotification(player.netname, flag.netname, "", INFO_LOSTFLAG, MSG_INFO);
 318                         sound(flag, CH_TRIGGER, flag.snd_flag_dropped, VOL_BASE, ATTN_NONE);
 319                         ctf_EventLog("dropped", player.team, player);
 320
 321                         // scoring
 322                         PlayerTeamScore_AddScore(player, -ctf_ReadScore("penalty_drop"));
 323                         PlayerScore_Add(player, SP_CTF_DROPS, 1);
 324
 325                         // waypoints
 326                         if(autocvar_g_ctf_flag_dropped_waypoint)
 327                                 WaypointSprite_Spawn("flagdropped", 0, 0, flag, '0 0 64', world, ((autocvar_g_ctf_flag_dropped_waypoint == 2) ? 0 : player.team), flag, wps_flagdropped, FALSE, RADARICON_FLAG, '0 0.5 0' + ((flag.team == COLOR_TEAM1) ? '0.75 0 0' : '0 0 0.75')); // (COLOR_TEAM1 + COLOR_TEAM2 - flag.team)
 328
 329                         if(autocvar_g_ctf_flag_returntime || (autocvar_g_ctf_flag_take_damage && autocvar_g_ctf_flag_health))
 330                         {
 331                                 WaypointSprite_UpdateMaxHealth(flag.wps_flagdropped, flag.max_flag_health);
 332                                 WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health);
 333                         }
 334                         break;
 335                 }
 336         }
 337
 338         // kill old waypointsprite
 339         WaypointSprite_Ping(player.wps_flagcarrier);
 340         WaypointSprite_Kill(player.wps_flagcarrier);
 341
 342         // captureshield
 343         //ctf_CaptureShield_Update(player, 0); // shield only
 344 }
 345
 346
 347 // ==============
 348 // Event Handlers
 349 // ==============
 350
 351 void ctf_Handle_Capture(entity flag, entity toucher, float capturetype)
 352 {
 353         entity enemy_flag = ((capturetype == CAPTURE_NORMAL) ? toucher.flagcarried : toucher);
 354         entity player = ((capturetype == CAPTURE_NORMAL) ? toucher : enemy_flag.ctf_dropper);
 355
 356         if not(player) { return; } // without someone to give the reward to, we can't possibly cap
 357
 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);
 361
 362         switch(capturetype)
 363         {
 364                 case CAPTURE_NORMAL: ctf_EventLog("capture", enemy_flag.team, player); break;
 365                 case CAPTURE_DROPPED: ctf_EventLog("droppedcapture", enemy_flag.team, player); break;
 366                 default: break;
 367         }
 368
 369         // scoring
 370         PlayerTeamScore_AddScore(player, ctf_ReadScore("score_capture"));
 371         PlayerTeamScore_Add(player, SP_CTF_CAPS, ST_CTF_CAPS, 1);
 372
 373         // effects
 374         if(autocvar_g_ctf_flag_capture_effects)
 375         {
 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);
 378         }
 379
 380         // other
 381         if(capturetype == CAPTURE_NORMAL)
 382         {
 383                 WaypointSprite_Kill(player.wps_flagcarrier);
 384                 if(flag.speedrunning) { ctf_FakeTimeLimit(player, -1); }
 385         }
 386
 387         // reset the flag
 388         player.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
 389         ctf_RespawnFlag(player.flagcarried);
 390 }
 391
 392 void ctf_Handle_Return(entity flag, entity player)
 393 {
 394         // messages and sounds
 395         //centerprint(player, strcat("You returned ", 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);
 399
 400         // scoring
 401         PlayerTeamScore_AddScore(player, ctf_ReadScore("score_return")); // reward for return
 402         PlayerScore_Add(player, SP_CTF_RETURNS, 1); // add to count of returns
 403
 404         TeamScore_AddToTeam(((flag.team == COLOR_TEAM1) ? COLOR_TEAM2 : COLOR_TEAM1), ST_SCORE, -ctf_ReadScore("penalty_returned")); // punish the team who was last carrying it
 405         FOR_EACH_PLAYER(player) if(player == flag.ctf_dropper) // punish the player who dropped the flag
 406         {
 407                 PlayerScore_Add(player, SP_SCORE, -ctf_ReadScore("penalty_returned"));
 408                 ctf_CaptureShield_Update(player, 0); // shield only
 409         }
 410
 411         // reset the flag
 412         ctf_RespawnFlag(flag);
 413 }
 414
 415 void ctf_Handle_Pickup(entity flag, entity player, float pickuptype)
 416 {
 417         // declarations
 418         entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
 419         string verbosename; // holds the name of the player OR no name at all for printing in the centerprints
 420         float pickup_dropped_score; // used to calculate dropped pickup score
 421
 422         // attach the flag to the player
 423         flag.owner = player;
 424         player.flagcarried = flag;
 425         setattachment(flag, player, "");
 426         setorigin(flag, FLAG_CARRY_OFFSET);
 427
 428         // flag setup
 429         flag.movetype = MOVETYPE_NONE;
 430         flag.takedamage = DAMAGE_NO;
 431         flag.solid = SOLID_NOT;
 432         flag.angles = '0 0 0';
 433         flag.ctf_carrier = player;
 434         flag.ctf_status = FLAG_CARRY;
 435
 436         switch(pickuptype)
 437         {
 438                 case PICKUP_BASE: flag.ctf_pickuptime = time; break; // used for timing runs
 439                 case PICKUP_DROPPED: flag.health = flag.max_flag_health; break; // reset health/return timelimit
 440                 default: break;
 441         }
 442
 443         // messages and sounds
 444         Send_KillNotification (player.netname, flag.netname, "", INFO_GOTFLAG, MSG_INFO);
 445         sound(player, CH_TRIGGER, flag.snd_flag_taken, VOL_BASE, ATTN_NONE);
 446         verbosename = ((autocvar_g_ctf_flag_pickup_verbosename) ? strcat(Team_ColorCode(player.team), "(^7", player.netname, Team_ColorCode(player.team), ") ") : "");
 447
 448         FOR_EACH_PLAYER(tmp_player)
 449                 if(tmp_player == player)
 450                         centerprint(tmp_player, strcat("You got the ", flag.netname, "!"));
 451                 else if(tmp_player.team == player.team)
 452                         centerprint(tmp_player, strcat("Your ", Team_ColorCode(player.team), "team mate ", verbosename, "^7got the flag! Protect them!"));
 453                 else if(tmp_player.team == flag.team)
 454                         centerprint(tmp_player, strcat("The ", Team_ColorCode(player.team), "enemy ", verbosename, "^7got your flag! Retrieve it!"));
 455
 456         switch(pickuptype)
 457         {
 458                 case PICKUP_BASE: ctf_EventLog("steal", flag.team, player); break;
 459                 case PICKUP_DROPPED: ctf_EventLog("pickup", flag.team, player); break;
 460                 default: break;
 461         }
 462
 463         // scoring
 464         PlayerScore_Add(player, SP_CTF_PICKUPS, 1);
 465         switch(pickuptype)
 466         {
 467                 case PICKUP_BASE:
 468                 {
 469                         PlayerTeamScore_AddScore(player, ctf_ReadScore("score_pickup_base"));
 470                         break;
 471                 }
 472
 473                 case PICKUP_DROPPED:
 474                 {
 475                         pickup_dropped_score = (autocvar_g_ctf_flag_returntime ? bound(0, ((flag.ctf_droptime + autocvar_g_ctf_flag_returntime) - time) / autocvar_g_ctf_flag_returntime, 1) : 1);
 476                         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);
 477                         print("pickup_dropped_score is ", ftos(pickup_dropped_score), "\n");
 478                         PlayerTeamScore_AddScore(player, pickup_dropped_score);
 479                         break;
 480                 }
 481
 482                 default: break;
 483         }
 484
 485         // speedrunning
 486         if(pickuptype == PICKUP_BASE)
 487         {
 488                 flag.speedrunning = player.speedrunning; // if speedrunning, flag will flag-return and teleport the owner back after the record
 489                 if((player.speedrunning) && (ctf_captimerecord))
 490                         ctf_FakeTimeLimit(player, time + ctf_captimerecord);
 491         }
 492
 493         // effects
 494         if(autocvar_g_ctf_flag_pickup_effects)
 495                 pointparticles(particleeffectnum("smoke_ring"), 0.5 * (flag.absmin + flag.absmax), '0 0 0', 1);
 496
 497         // waypoints
 498         if(pickuptype == PICKUP_DROPPED) { WaypointSprite_Kill(flag.wps_flagdropped); }
 499         ctf_FlagcarrierWaypoints(player);
 500         WaypointSprite_Ping(player.wps_flagcarrier);
 501 }
 502
 503
 504 // ===================
 505 // Main Flag Functions
 506 // ===================
 507
 508 void ctf_CheckFlagReturn(entity flag)
 509 {
 510         if(flag.wps_flagdropped) { WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health); }
 511
 512         if((flag.health <= 0) || (time > flag.ctf_droptime + autocvar_g_ctf_flag_returntime))
 513         {
 514                 bprint("The ", flag.netname, " has returned to base\n");
 515                 sound(flag, CH_TRIGGER, flag.snd_flag_respawn, VOL_BASE, ATTN_NONE);
 516                 ctf_EventLog("returned", flag.team, world);
 517                 ctf_RespawnFlag(flag);
 518         }
 519 }
 520
 521 void ctf_FlagDamage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
 522 {
 523         if(ITEM_DAMAGE_NEEDKILL(deathtype))
 524         {
 525                 // automatically kill the flag and return it
 526                 self.health = 0;
 527                 ctf_CheckFlagReturn(self);
 528         }
 529
 530         if(autocvar_g_ctf_flag_take_damage)
 531         {
 532                 self.health = self.health - damage;
 533                 ctf_CheckFlagReturn(self);
 534         }
 535 }
 536
 537 void ctf_FlagThink()
 538 {
 539         // declarations
 540         entity tmp_entity;
 541
 542         self.nextthink = time + FLAG_THINKRATE; // only 5 fps, more is unnecessary.
 543
 544         // captureshield
 545         if(self == ctf_worldflaglist) // only for the first flag
 546                 FOR_EACH_CLIENT(tmp_entity)
 547                         ctf_CaptureShield_Update(tmp_entity, 1); // release shield only
 548
 549         // sanity checks
 550         if(self.mins != FLAG_MIN || self.maxs != FLAG_MAX) { // reset the flag boundaries in case it got squished
 551                 dprint("wtf the flag got squashed?\n");
 552                 tracebox(self.origin, FLAG_MIN, FLAG_MAX, self.origin, MOVE_NOMONSTERS, self);
 553                 if(!trace_startsolid) // can we resize it without getting stuck?
 554                         setsize(self, FLAG_MIN, FLAG_MAX); }
 555
 556         // main think method
 557         switch(self.ctf_status)
 558         {
 559                 case FLAG_BASE:
 560                 {
 561                         if(autocvar_g_ctf_dropped_capture_radius)
 562                         {
 563                                 for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
 564                                         if(tmp_entity.ctf_status == FLAG_DROPPED)
 565                                                 if(vlen(self.origin - tmp_entity.origin) < autocvar_g_ctf_dropped_capture_radius)
 566                                                         ctf_Handle_Capture(self, tmp_entity, CAPTURE_DROPPED);
 567                         }
 568                         return;
 569                 }
 570
 571                 case FLAG_DROPPED:
 572                 {
 573                         if(autocvar_g_ctf_flag_returntime)
 574                         {
 575                                 self.health -= ((self.max_flag_health / autocvar_g_ctf_flag_returntime) * FLAG_THINKRATE);
 576                                 ctf_CheckFlagReturn(self);
 577                         }
 578                         return;
 579                 }
 580
 581                 case FLAG_CARRY:
 582                 {
 583                         if((self.owner) && (self.speedrunning) && (ctf_captimerecord) && (time >= self.ctf_pickuptime + ctf_captimerecord))
 584                         {
 585                                 bprint("The ", self.netname, " became impatient after ", ftos_decimals(ctf_captimerecord, 2), " seconds and returned itself\n");
 586                                 sound(self, CH_TRIGGER, self.snd_flag_respawn, VOL_BASE, ATTN_NONE);
 587                                 ctf_EventLog("returned", self.team, world);
 588                                 ctf_RespawnFlag(tmp_entity);
 589
 590                                 tmp_entity = self;
 591                                 self = self.owner;
 592                                 self.impulse = CHIMPULSE_SPEEDRUN; // move the player back to the waypoint they set
 593                                 ImpulseCommands();
 594                                 self = tmp_entity;
 595                         }
 596                         return;
 597                 }
 598
 599                 case FLAG_PASSING:
 600                 {
 601                         vector targ_origin = (0.5 * (self.pass_target.absmin + self.pass_target.absmax));
 602
 603                         traceline(self.origin, targ_origin, MOVE_NOMONSTERS, self);
 604
 605                         if((self.pass_target.deadflag != DEAD_NO)
 606                                 || (vlen(self.origin - targ_origin) > autocvar_g_ctf_pass_radius)
 607                                 || ((trace_fraction < 1) && (trace_ent != self.pass_target))
 608                                 || (time > self.ctf_droptime + autocvar_g_ctf_pass_timelimit))
 609                         {
 610                                 ctf_Handle_Failed_Pass(self);
 611                         }
 612                         else // still a viable target, go for it
 613                         {
 614                                 vector desired_direction = normalize(targ_origin - self.origin);
 615                                 vector current_direction = normalize(self.velocity);
 616
 617                                 self.velocity = (normalize(current_direction + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_throw_velocity);
 618                         }
 619                         return;
 620                 }
 621
 622                 default: // this should never happen
 623                 {
 624                         dprint("ctf_FlagThink(): Flag exists with no status?\n");
 625                         return;
 626                 }
 627         }
 628 }
 629
 630 void ctf_FlagTouch()
 631 {
 632         if(gameover) { return; }
 633         if(!self) { return; }
 634         if(other.deadflag != DEAD_NO) { return; }
 635         if(ITEM_TOUCH_NEEDKILL())
 636         {
 637                 // automatically kill the flag and return it
 638                 self.health = 0;
 639                 ctf_CheckFlagReturn(self);
 640                 return;
 641         }
 642         if(other.classname != "player") // The flag just touched an object, most likely the world
 643         {
 644                 if(time > self.wait) // if we haven't in a while, play a sound/effect
 645                 {
 646                         pointparticles(particleeffectnum("kaball_sparks"), self.origin, '0 0 0', 1);
 647                         sound(self, CH_TRIGGER, self.snd_flag_touch, VOL_BASE, ATTN_NORM);
 648                         self.wait = time + FLAG_TOUCHRATE;
 649                 }
 650                 return;
 651         }
 652
 653         switch(self.ctf_status)
 654         {
 655                 case FLAG_BASE:
 656                 {
 657                         if((other.team == self.team) && (other.flagcarried) && (other.flagcarried.team != self.team))
 658                                 ctf_Handle_Capture(self, other, CAPTURE_NORMAL); // other just captured the enemies flag to his base
 659                         else if((other.team != self.team) && (!other.flagcarried) && (!other.ctf_captureshielded) && (time > other.next_take_time))
 660                                 ctf_Handle_Pickup(self, other, PICKUP_BASE); // other just stole the enemies flag
 661                         break;
 662                 }
 663
 664                 case FLAG_DROPPED:
 665                 {
 666                         if(other.team == self.team)
 667                                 ctf_Handle_Return(self, other); // other just returned his own flag
 668                         else if((!other.flagcarried) && ((other != self.ctf_dropper) || (time > self.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
 669                                 ctf_Handle_Pickup(self, other, PICKUP_DROPPED); // other just picked up a dropped enemy flag
 670                         break;
 671                 }
 672
 673                 case FLAG_CARRY:
 674                 {
 675                         dprint("Someone touched a flag even though it was being carried?\n");
 676                         break;
 677                 }
 678
 679                 case FLAG_PASSING:
 680                 {
 681                         if((other.classname == "player") && (other.deadflag == DEAD_NO) && (other != self.pass_sender))
 682                         {
 683                                 if(IsDifferentTeam(other, self.pass_sender))
 684                                         ctf_Handle_Return(self, other);
 685                                 else
 686                                         ctf_Handle_Retrieve(self, other);
 687                         }
 688                         break;
 689                 }
 690
 691                 default: // this should never happen
 692                 {
 693                         dprint("Touch: Flag exists with no status?\n");
 694                         break;
 695                 }
 696         }
 697 }
 698
 699 void ctf_RespawnFlag(entity flag)
 700 {
 701         // reset the player (if there is one)
 702         if((flag.owner) && (flag.owner.flagcarried == flag))
 703         {
 704                 WaypointSprite_Kill(flag.wps_flagcarrier);
 705                 flag.owner.flagcarried = world;
 706
 707                 if(flag.speedrunning)
 708                         ctf_FakeTimeLimit(flag.owner, -1);
 709         }
 710
 711         if((flag.ctf_status == FLAG_DROPPED) && (flag.wps_flagdropped))
 712                 { WaypointSprite_Kill(flag.wps_flagdropped); }
 713
 714         // reset the flag
 715         setattachment(flag, world, "");
 716         setorigin(flag, flag.ctf_spawnorigin);
 717
 718         flag.movetype = ((flag.noalign) ? MOVETYPE_NONE : MOVETYPE_TOSS);
 719         flag.takedamage = DAMAGE_NO;
 720         flag.health = flag.max_flag_health;
 721         flag.solid = SOLID_TRIGGER;
 722         flag.velocity = '0 0 0';
 723         flag.angles = flag.mangle;
 724         flag.flags = FL_ITEM | FL_NOTARGET;
 725
 726         flag.ctf_status = FLAG_BASE;
 727         flag.owner = world;
 728         flag.pass_sender = world;
 729         flag.pass_target = world;
 730         flag.ctf_carrier = world;
 731         flag.ctf_dropper = world;
 732         flag.ctf_pickuptime = 0;
 733         flag.ctf_droptime = 0;
 734 }
 735
 736 void ctf_Reset()
 737 {
 738         if(self.owner)
 739                 if(self.owner.classname == "player")
 740                         ctf_Handle_Throw(self.owner, world, DROP_NORMAL);
 741
 742         ctf_RespawnFlag(self);
 743 }
 744
 745 void ctf_DelayedFlagSetup(void) // called after a flag is placed on a map by ctf_FlagSetup()
 746 {
 747         // declarations
 748         float teamnumber = ((self.team == COLOR_TEAM1) ? TRUE : FALSE); // if we were originally 1, this will become 0. If we were originally 0, this will become 1.
 749
 750         // bot waypoints
 751         waypoint_spawnforitem_force(self, self.origin);
 752         self.nearestwaypointtimeout = 0; // activate waypointing again
 753         self.bot_basewaypoint = self.nearestwaypoint;
 754
 755         // waypointsprites
 756         WaypointSprite_SpawnFixed(((teamnumber) ? "redbase" : "bluebase"), self.origin + '0 0 64', self, wps_flagbase, RADARICON_FLAG, colormapPaletteColor(((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2) - 1, FALSE));
 757         WaypointSprite_UpdateTeamRadar(self.wps_flagbase, RADARICON_FLAG, colormapPaletteColor(((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2) - 1, FALSE));
 758
 759         // captureshield setup
 760         ctf_CaptureShield_Spawn(self);
 761 }
 762
 763 void ctf_FlagSetup(float teamnumber, entity flag) // called when spawning a flag entity on the map as a spawnfunc
 764 {
 765         // declarations
 766         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.
 767         self = flag; // for later usage with droptofloor()
 768
 769         // main setup
 770         flag.ctf_worldflagnext = ctf_worldflaglist; // link flag into ctf_worldflaglist
 771         ctf_worldflaglist = flag;
 772
 773         setattachment(flag, world, "");
 774
 775         flag.netname = ((teamnumber) ? "^1RED^7 flag" : "^4BLUE^7 flag");
 776         flag.team = ((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2); // COLOR_TEAM1: color 4 team (red) - COLOR_TEAM2: color 13 team (blue)
 777         flag.items = ((teamnumber) ? IT_KEY2 : IT_KEY1); // IT_KEY2: gold key (redish enough) - IT_KEY1: silver key (bluish enough)
 778         flag.classname = "item_flag_team";
 779         flag.target = "###item###"; // wut?
 780         flag.flags = FL_ITEM | FL_NOTARGET;
 781         flag.solid = SOLID_TRIGGER;
 782         flag.takedamage = DAMAGE_NO;
 783         flag.damageforcescale = autocvar_g_ctf_flag_damageforcescale;
 784         flag.max_flag_health = ((autocvar_g_ctf_flag_take_damage && autocvar_g_ctf_flag_health) ? autocvar_g_ctf_flag_health : 100);
 785         flag.health = flag.max_flag_health;
 786         flag.event_damage = ctf_FlagDamage;
 787         flag.pushable = TRUE;
 788         flag.damagedbytriggers = autocvar_g_ctf_flag_return_when_unreachable;
 789         flag.damagedbycontents = autocvar_g_ctf_flag_return_when_unreachable;
 790         flag.velocity = '0 0 0';
 791         flag.mangle = flag.angles;
 792         flag.reset = ctf_Reset;
 793         flag.touch = ctf_FlagTouch;
 794         flag.think = ctf_FlagThink;
 795         flag.nextthink = time + FLAG_THINKRATE;
 796         flag.ctf_status = FLAG_BASE;
 797
 798         if(!flag.model) { flag.model = ((teamnumber) ? autocvar_g_ctf_flag_red_model : autocvar_g_ctf_flag_blue_model); }
 799         if(!flag.scale) { flag.scale = FLAG_SCALE; }
 800         if(!flag.skin) { flag.skin = ((teamnumber) ? autocvar_g_ctf_flag_red_skin : autocvar_g_ctf_flag_blue_skin); }
 801
 802         // sound
 803         if(!flag.snd_flag_taken) { flag.snd_flag_taken  = ((teamnumber) ? "ctf/red_taken.wav" : "ctf/blue_taken.wav"); }
 804         if(!flag.snd_flag_returned) { flag.snd_flag_returned = ((teamnumber) ? "ctf/red_returned.wav" : "ctf/blue_returned.wav"); }
 805         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
 806         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.
 807         if(!flag.snd_flag_dropped) { flag.snd_flag_dropped = ((teamnumber) ? "ctf/red_dropped.wav" : "ctf/blue_dropped.wav"); }
 808         if(!flag.snd_flag_touch) { flag.snd_flag_touch = "keepaway/touch.wav"; } // again has no team-based sound // FIXME
 809
 810         // precache
 811         precache_sound(flag.snd_flag_taken);
 812         precache_sound(flag.snd_flag_returned);
 813         precache_sound(flag.snd_flag_capture);
 814         precache_sound(flag.snd_flag_respawn);
 815         precache_sound(flag.snd_flag_dropped);
 816         precache_sound(flag.snd_flag_touch);
 817         precache_model(flag.model);
 818         precache_model("models/ctf/shield.md3");
 819         precache_model("models/ctf/shockwavetransring.md3");
 820
 821         // appearence
 822         setmodel(flag, flag.model); // precision set below
 823         setsize(flag, FLAG_MIN, FLAG_MAX);
 824         setorigin(flag, (flag.origin + FLAG_SPAWN_OFFSET));
 825
 826         if(autocvar_g_ctf_flag_glowtrails)
 827         {
 828                 flag.glow_color = ((teamnumber) ? 251 : 210); // 251: red - 210: blue
 829                 flag.glow_size = 25;
 830                 flag.glow_trail = 1;
 831         }
 832
 833         flag.effects |= EF_LOWPRECISION;
 834         if(autocvar_g_ctf_fullbrightflags) { flag.effects |= EF_FULLBRIGHT; }
 835         if(autocvar_g_ctf_dynamiclights)   { flag.effects |= ((teamnumber) ? EF_RED : EF_BLUE); }
 836
 837         // flag placement
 838         if((flag.spawnflags & 1) || flag.noalign) // don't drop to floor, just stay at fixed location
 839         {
 840                 flag.dropped_origin = flag.origin;
 841                 flag.noalign = TRUE;
 842                 flag.movetype = MOVETYPE_NONE;
 843         }
 844         else // drop to floor, automatically find a platform and set that as spawn origin
 845         {
 846                 flag.noalign = FALSE;
 847                 self = flag;
 848                 droptofloor();
 849                 flag.movetype = MOVETYPE_TOSS;
 850         }
 851
 852         InitializeEntity(flag, ctf_DelayedFlagSetup, INITPRIO_SETLOCATION);
 853 }
 854
 855
 856 // ==============
 857 // Hook Functions
 858 // ==============
 859
 860 MUTATOR_HOOKFUNCTION(ctf_HookedDrop)
 861 {
 862         if(self.flagcarried) { ctf_Handle_Throw(self, world, DROP_NORMAL); }
 863         return 0;
 864 }
 865
 866 MUTATOR_HOOKFUNCTION(ctf_PlayerPreThink)
 867 {
 868         entity flag;
 869
 870         // initially clear items so they can be set as necessary later.
 871         self.items &~= (IT_RED_FLAG_CARRYING | IT_RED_FLAG_TAKEN | IT_RED_FLAG_LOST
 872                 | IT_BLUE_FLAG_CARRYING | IT_BLUE_FLAG_TAKEN | IT_BLUE_FLAG_LOST | IT_CTF_SHIELDED);
 873
 874         // scan through all the flags and notify the client about them
 875         for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
 876         {
 877                 if(flag.ctf_status == FLAG_CARRY)
 878                         if(flag.owner == self)
 879                                 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_CARRYING : IT_BLUE_FLAG_CARRYING); // carrying: self is currently carrying the flag
 880                         else
 881                                 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_TAKEN : IT_BLUE_FLAG_TAKEN); // taken: someone on self's team is carrying the flag
 882                 else if(flag.ctf_status == FLAG_DROPPED)
 883                         self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_LOST : IT_BLUE_FLAG_LOST); // lost: the flag is dropped somewhere on the map
 884         }
 885
 886         // item for stopping players from capturing the flag too often
 887         if(self.ctf_captureshielded)
 888                 self.items |= IT_CTF_SHIELDED;
 889
 890         // update the health of the flag carrier waypointsprite
 891         if(self.wps_flagcarrier)
 892                 WaypointSprite_UpdateHealth(self.wps_flagcarrier, self.health);
 893
 894         return 0;
 895 }
 896
 897 MUTATOR_HOOKFUNCTION(ctf_PlayerDamage) // for changing damage and force values that are applied to players in g_damage.qc
 898 {
 899         if(frag_attacker.flagcarried) // if the attacker is a flagcarrier
 900         {
 901                 if(frag_target == frag_attacker) // damage done to yourself
 902                 {
 903                         frag_damage *= autocvar_g_ctf_flagcarrier_selfdamagefactor;
 904                         frag_force *= autocvar_g_ctf_flagcarrier_selfforcefactor;
 905                 }
 906                 else // damage done everyone else
 907                 {
 908                         frag_damage *= autocvar_g_ctf_flagcarrier_damagefactor;
 909                         frag_force *= autocvar_g_ctf_flagcarrier_forcefactor;
 910                 }
 911         }
 912         return 0;
 913 }
 914
 915 MUTATOR_HOOKFUNCTION(ctf_GiveFragsForKill)
 916 {
 917         frag_score = 0;
 918         return (autocvar_g_ctf_ignore_frags); // no frags counted in ctf if this is true
 919 }
 920
 921 MUTATOR_HOOKFUNCTION(ctf_PlayerUseKey)
 922 {
 923         entity player = self;
 924
 925         if(time > player.throw_antispam)
 926         {
 927                 // pass the flag to a team mate
 928                 if(autocvar_g_ctf_allow_pass)
 929                 {
 930                         entity head, closest_target;
 931                         head = findradius(player.origin, autocvar_g_ctf_pass_radius);
 932
 933                         while(head) // find the closest acceptable target to pass to
 934                         {
 935                                 if(head.classname == "player" && head.deadflag == DEAD_NO)
 936                                 if(head != player && !IsDifferentTeam(head, player))
 937                                 if(!player.speedrunning && !head.speedrunning)
 938                                 {
 939                                         traceline(player.origin, head.origin, MOVE_NOMONSTERS, player);
 940                                         if not((trace_fraction < 1) && (trace_ent != head))
 941                                         {
 942                                                 if(autocvar_g_ctf_pass_request && !player.flagcarried && head.flagcarried)
 943                                                 {
 944                                                         if(clienttype(head) == CLIENTTYPE_BOT)
 945                                                         {
 946                                                                 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
 947                                                                 ctf_Handle_Throw(head, player, DROP_PASS);
 948                                                         }
 949                                                         else
 950                                                         {
 951                                                                 centerprint(head, strcat(player.netname, " requests you to pass the ", head.flagcarried.netname));
 952                                                                 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
 953                                                         }
 954                                                         player.throw_antispam = time + autocvar_g_ctf_pass_wait;
 955                                                         return 0;
 956                                                 }
 957                                                 else if(player.flagcarried)
 958                                                 {
 959                                                         if(closest_target) { if(vlen(player.origin - head.origin) < vlen(player.origin - closest_target.origin)) { closest_target = head; } }
 960                                                         else { closest_target = head; }
 961                                                 }
 962                                         }
 963                                 }
 964                                 head = head.chain;
 965                         }
 966
 967                         if(closest_target) { ctf_Handle_Throw(player, closest_target, DROP_PASS); return 0; }
 968                 }
 969
 970                 // throw the flag in front of you
 971                 if(autocvar_g_ctf_allow_drop && player.flagcarried && !player.speedrunning)
 972                         { ctf_Handle_Throw(player, world, DROP_THROW); }
 973         }
 974
 975         return 0;
 976 }
 977
 978 // ==========
 979 // Spawnfuncs
 980 // ==========
 981
 982 /*QUAKED spawnfunc_info_player_team1 (1 0 0) (-16 -16 -24) (16 16 24)
 983 CTF Starting point for a player in team one (Red).
 984 Keys: "angle" viewing angle when spawning. */
 985 void spawnfunc_info_player_team1()
 986 {
 987         if(g_assault) { remove(self); return; }
 988
 989         self.team = COLOR_TEAM1; // red
 990         spawnfunc_info_player_deathmatch();
 991 }
 992
 993
 994 /*QUAKED spawnfunc_info_player_team2 (1 0 0) (-16 -16 -24) (16 16 24)
 995 CTF Starting point for a player in team two (Blue).
 996 Keys: "angle" viewing angle when spawning. */
 997 void spawnfunc_info_player_team2()
 998 {
 999         if(g_assault) { remove(self); return; }
1000
1001         self.team = COLOR_TEAM2; // blue
1002         spawnfunc_info_player_deathmatch();
1003 }
1004
1005 /*QUAKED spawnfunc_info_player_team3 (1 0 0) (-16 -16 -24) (16 16 24)
1006 CTF Starting point for a player in team three (Yellow).
1007 Keys: "angle" viewing angle when spawning. */
1008 void spawnfunc_info_player_team3()
1009 {
1010         if(g_assault) { remove(self); return; }
1011
1012         self.team = COLOR_TEAM3; // yellow
1013         spawnfunc_info_player_deathmatch();
1014 }
1015
1016
1017 /*QUAKED spawnfunc_info_player_team4 (1 0 0) (-16 -16 -24) (16 16 24)
1018 CTF Starting point for a player in team four (Purple).
1019 Keys: "angle" viewing angle when spawning. */
1020 void spawnfunc_info_player_team4()
1021 {
1022         if(g_assault) { remove(self); return; }
1023
1024         self.team = COLOR_TEAM4; // purple
1025         spawnfunc_info_player_deathmatch();
1026 }
1027
1028 /*QUAKED spawnfunc_item_flag_team1 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1029 CTF flag for team one (Red).
1030 Keys:
1031 "angle" Angle the flag will point (minus 90 degrees)...
1032 "model" model to use, note this needs red and blue as skins 0 and 1...
1033 "noise" sound played when flag is picked up...
1034 "noise1" sound played when flag is returned by a teammate...
1035 "noise2" sound played when flag is captured...
1036 "noise3" sound played when flag is lost in the field and respawns itself...
1037 "noise4" sound played when flag is dropped by a player...
1038 "noise5" sound played when flag touches the ground... */
1039 void spawnfunc_item_flag_team1()
1040 {
1041         if(!g_ctf) { remove(self); return; }
1042
1043         ctf_FlagSetup(1, self); // 1 = red
1044 }
1045
1046 /*QUAKED spawnfunc_item_flag_team2 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1047 CTF flag for team two (Blue).
1048 Keys:
1049 "angle" Angle the flag will point (minus 90 degrees)...
1050 "model" model to use, note this needs red and blue as skins 0 and 1...
1051 "noise" sound played when flag is picked up...
1052 "noise1" sound played when flag is returned by a teammate...
1053 "noise2" sound played when flag is captured...
1054 "noise3" sound played when flag is lost in the field and respawns itself...
1055 "noise4" sound played when flag is dropped by a player...
1056 "noise5" sound played when flag touches the ground... */
1057 void spawnfunc_item_flag_team2()
1058 {
1059         if(!g_ctf) { remove(self); return; }
1060
1061         ctf_FlagSetup(0, self); // the 0 is misleading, but -- 0 = blue.
1062 }
1063
1064 /*QUAKED spawnfunc_ctf_team (0 .5 .8) (-16 -16 -24) (16 16 32)
1065 Team declaration for CTF gameplay, this allows you to decide what team names and control point models are used in your map.
1066 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.
1067 Keys:
1068 "netname" Name of the team (for example Red, Blue, Green, Yellow, Life, Death, Offense, Defense, etc)...
1069 "cnt" Scoreboard color of the team (for example 4 is red and 13 is blue)... */
1070 void spawnfunc_ctf_team()
1071 {
1072         if(!g_ctf) { remove(self); return; }
1073
1074         self.classname = "ctf_team";
1075         self.team = self.cnt + 1;
1076 }
1077
1078
1079 // ==============
1080 // Initialization
1081 // ==============
1082
1083 // code from here on is just to support maps that don't have flag and team entities
1084 void ctf_SpawnTeam (string teamname, float teamcolor)
1085 {
1086         entity oldself;
1087         oldself = self;
1088         self = spawn();
1089         self.classname = "ctf_team";
1090         self.netname = teamname;
1091         self.cnt = teamcolor;
1092
1093         spawnfunc_ctf_team();
1094
1095         self = oldself;
1096 }
1097
1098 void ctf_DelayedInit() // Do this check with a delay so we can wait for teams to be set up.
1099 {
1100         // if no teams are found, spawn defaults
1101         if(find(world, classname, "ctf_team") == world)
1102         {
1103                 print("No ""ctf_team"" entities found on this map, creating them anyway.\n");
1104                 ctf_SpawnTeam("Red", COLOR_TEAM1 - 1);
1105                 ctf_SpawnTeam("Blue", COLOR_TEAM2 - 1);
1106         }
1107
1108         ScoreRules_ctf();
1109 }
1110
1111 void ctf_Initialize()
1112 {
1113         ctf_captimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));
1114
1115         ctf_captureshield_min_negscore = autocvar_g_ctf_shield_min_negscore;
1116         ctf_captureshield_max_ratio = autocvar_g_ctf_shield_max_ratio;
1117         ctf_captureshield_force = autocvar_g_ctf_shield_force;
1118
1119         InitializeEntity(world, ctf_DelayedInit, INITPRIO_GAMETYPE);
1120 }
1121
1122
1123 MUTATOR_DEFINITION(gamemode_ctf)
1124 {
1125         MUTATOR_HOOK(MakePlayerObserver, ctf_HookedDrop, CBC_ORDER_ANY);
1126         MUTATOR_HOOK(ClientDisconnect, ctf_HookedDrop, CBC_ORDER_ANY);
1127         MUTATOR_HOOK(PlayerDies, ctf_HookedDrop, CBC_ORDER_ANY);
1128         MUTATOR_HOOK(PortalTeleport, ctf_HookedDrop, CBC_ORDER_ANY);
1129         MUTATOR_HOOK(GiveFragsForKill, ctf_GiveFragsForKill, CBC_ORDER_ANY);
1130         MUTATOR_HOOK(PlayerPreThink, ctf_PlayerPreThink, CBC_ORDER_ANY);
1131         MUTATOR_HOOK(PlayerDamage_Calculate, ctf_PlayerDamage, CBC_ORDER_ANY);
1132         MUTATOR_HOOK(PlayerUseKey, ctf_PlayerUseKey, CBC_ORDER_ANY);
1133
1134         MUTATOR_ONADD
1135         {
1136                 if(time > 1) // game loads at time 1
1137                         error("This is a game type and it cannot be added at runtime.");
1138                 g_ctf = 1;
1139                 ctf_Initialize();
1140         }
1141
1142         MUTATOR_ONREMOVE
1143         {
1144                 g_ctf = 0;
1145                 error("This is a game type and it cannot be removed at runtime.");
1146         }
1147
1148         return 0;
1149 }