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