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