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