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