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