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