qcsrc/server/mutators/gamemode_ctf.qc

   1 // ================================================================
   2 //  Official capture the flag game mode coding, reworked by Samual
   3 //  Last updated: March 30th, 2012
   4 // ================================================================
   5
   6 float ctf_ReadScore(string parameter) // make this obsolete
   7 {
   8         //if(g_ctf_win_mode != 2)
   9                 return cvar(strcat("g_ctf_personal", parameter));
  10         //else
  11         //      return cvar(strcat("g_ctf_flag", parameter));
  12 }
  13
  14 void ctf_FakeTimeLimit(entity e, float t)
  15 {
  16         msg_entity = e;
  17         WriteByte(MSG_ONE, 3); // svc_updatestat
  18         WriteByte(MSG_ONE, 236); // STAT_TIMELIMIT
  19         if(t < 0)
  20                 WriteCoord(MSG_ONE, autocvar_timelimit);
  21         else
  22                 WriteCoord(MSG_ONE, (t + 1) / 60);
  23 }
  24
  25 void ctf_EventLog(string mode, float flagteam, entity actor) // use an alias for easy changing and quick editing later
  26 {
  27         if(autocvar_sv_eventlog)
  28                 GameLogEcho(strcat(":ctf:", mode, ":", ftos(flagteam), ((actor != world) ? (strcat(":", ftos(actor.playerid))) : "")));
  29 }
  30
  31 string ctf_CaptureRecord(entity flag, entity player)
  32 {
  33         float cap_time, cap_record, success;
  34         string cap_message, refername;
  35
  36         if((autocvar_g_ctf_captimerecord_always) || (player_count - currentbots))
  37         {
  38                 cap_record = ctf_captimerecord;
  39                 cap_time = (time - flag.ctf_pickuptime);
  40
  41                 refername = db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"));
  42                 refername = ((refername == player.netname) ? "their" : strcat(refername, "^7's"));
  43
  44                 if(!ctf_captimerecord)
  45                         { cap_message = strcat(" in ", ftos_decimals(cap_time, 2), " seconds"); success = TRUE; }
  46                 else if(cap_time < cap_record)
  47                         { cap_message = strcat(" in ", ftos_decimals(cap_time, 2), " seconds, breaking ", refername, " previous record of ", ftos_decimals(cap_record, 2), " seconds"); success = TRUE; }
  48                 else
  49                         { cap_message = strcat(" in ", ftos_decimals(cap_time, 2), " seconds, failing to break ", refername, " record of ", ftos_decimals(cap_record, 2), " seconds"); success = FALSE; }
  50
  51                 if(success)
  52                 {
  53                         ctf_captimerecord = cap_time;
  54                         db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time"), ftos(cap_time));
  55                         db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"), player.netname);
  56                         write_recordmarker(player, (time - cap_time), cap_time);
  57                 }
  58         }
  59
  60         return cap_message;
  61 }
  62
  63 void ctf_FlagcarrierWaypoints(entity player)
  64 {
  65         WaypointSprite_Spawn("flagcarrier", 0, 0, player, FLAG_WAYPOINT_OFFSET, world, player.team, player, wps_flagcarrier, TRUE, RADARICON_FLAG, WPCOLOR_FLAGCARRIER(player.team));
  66         WaypointSprite_UpdateMaxHealth(player.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(start_health, start_armorvalue, autocvar_g_balance_armor_blockpercent) * 2);
  67         WaypointSprite_UpdateHealth(player.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(player.health, player.armorvalue, autocvar_g_balance_armor_blockpercent));
  68         WaypointSprite_UpdateTeamRadar(player.wps_flagcarrier, RADARICON_FLAGCARRIER, WPCOLOR_FLAGCARRIER(player.team));
  69 }
  70
  71
  72 // =======================
  73 // CaptureShield Functions
  74 // =======================
  75
  76 float ctf_CaptureShield_CheckStatus(entity p)
  77 {
  78         float s, se;
  79         entity e;
  80         float players_worseeq, players_total;
  81
  82         if(ctf_captureshield_max_ratio <= 0)
  83                 return FALSE;
  84
  85         s = PlayerScore_Add(p, SP_SCORE, 0);
  86         if(s >= -ctf_captureshield_min_negscore)
  87                 return FALSE;
  88
  89         players_total = players_worseeq = 0;
  90         FOR_EACH_PLAYER(e)
  91         {
  92                 if(IsDifferentTeam(e, p))
  93                         continue;
  94                 se = PlayerScore_Add(e, SP_SCORE, 0);
  95                 if(se <= s)
  96                         ++players_worseeq;
  97                 ++players_total;
  98         }
  99
 100         // player is in the worse half, if >= half the players are better than him, or consequently, if < half of the players are worse
 101         // use this rule here
 102
 103         if(players_worseeq >= players_total * ctf_captureshield_max_ratio)
 104                 return FALSE;
 105
 106         return TRUE;
 107 }
 108
 109 void ctf_CaptureShield_Update(entity player, float wanted_status)
 110 {
 111         float updated_status = ctf_CaptureShield_CheckStatus(player);
 112         if((wanted_status == player.ctf_captureshielded) && (updated_status != wanted_status)) // 0: shield only, 1: unshield only
 113         {
 114                 if(updated_status) // TODO csqc notifier for this // Samual: How?
 115                         Send_CSQC_Centerprint_Generic(player, CPID_CTF_CAPTURESHIELD, "^3You are now ^4shielded^3 from the flag\n^3for ^1too many unsuccessful attempts^3 to capture.\n\n^3Make some defensive scores before trying again.", 5, 0);
 116                 else
 117                         Send_CSQC_Centerprint_Generic(player, CPID_CTF_CAPTURESHIELD, "^3You are now free.\n\n^3Feel free to ^1try to capture^3 the flag again\n^3if you think you will succeed.", 5, 0);
 118
 119                 player.ctf_captureshielded = updated_status;
 120         }
 121 }
 122
 123 float ctf_CaptureShield_Customize()
 124 {
 125         if(!other.ctf_captureshielded) { return FALSE; }
 126         if(!IsDifferentTeam(self, other)) { return FALSE; }
 127
 128         return TRUE;
 129 }
 130
 131 void ctf_CaptureShield_Touch()
 132 {
 133         if(!other.ctf_captureshielded) { return; }
 134         if(!IsDifferentTeam(self, other)) { return; }
 135
 136         vector mymid = (self.absmin + self.absmax) * 0.5;
 137         vector othermid = (other.absmin + other.absmax) * 0.5;
 138
 139         Damage(other, self, self, 0, DEATH_HURTTRIGGER, mymid, normalize(othermid - mymid) * ctf_captureshield_force);
 140         Send_CSQC_Centerprint_Generic(other, CPID_CTF_CAPTURESHIELD, "^3You are ^4shielded^3 from the flag\n^3for ^1too many unsuccessful attempts^3 to capture.\n\n^3Get some defensive scores before trying again.", 5, 0);
 141 }
 142
 143 void ctf_CaptureShield_Spawn(entity flag)
 144 {
 145         entity shield = spawn();
 146
 147         shield.enemy = self;
 148         shield.team = self.team;
 149         shield.touch = ctf_CaptureShield_Touch;
 150         shield.customizeentityforclient = ctf_CaptureShield_Customize;
 151         shield.classname = "ctf_captureshield";
 152         shield.effects = EF_ADDITIVE;
 153         shield.movetype = MOVETYPE_NOCLIP;
 154         shield.solid = SOLID_TRIGGER;
 155         shield.avelocity = '7 0 11';
 156         shield.scale = 0.5;
 157
 158         setorigin(shield, self.origin);
 159         setmodel(shield, "models/ctf/shield.md3");
 160         setsize(shield, shield.scale * shield.mins, shield.scale * shield.maxs);
 161 }
 162
 163
 164 // ====================
 165 // Drop/Pass/Throw Code
 166 // ====================
 167
 168 void ctf_Handle_Drop(entity flag, entity player, float droptype)
 169 {
 170         // declarations
 171         player = (player ? player : flag.pass_sender);
 172
 173         // main
 174         flag.movetype = MOVETYPE_TOSS;
 175         flag.takedamage = DAMAGE_YES;
 176         flag.health = flag.max_flag_health;
 177         flag.ctf_droptime = time;
 178         flag.ctf_dropper = player;
 179         flag.ctf_status = FLAG_DROPPED;
 180
 181         // messages and sounds
 182         Send_KillNotification(player.netname, flag.netname, "", INFO_LOSTFLAG, MSG_INFO);
 183         sound(flag, CH_TRIGGER, flag.snd_flag_dropped, VOL_BASE, ATTN_NONE);
 184         ctf_EventLog("dropped", player.team, player);
 185
 186         // scoring
 187         PlayerTeamScore_AddScore(player, -ctf_ReadScore("penalty_drop"));
 188         PlayerScore_Add(player, SP_CTF_DROPS, 1);
 189
 190         // waypoints
 191         if(autocvar_g_ctf_flag_dropped_waypoint)
 192                 WaypointSprite_Spawn("flagdropped", 0, 0, flag, FLAG_WAYPOINT_OFFSET, world, ((autocvar_g_ctf_flag_dropped_waypoint == 2) ? 0 : player.team), flag, wps_flagdropped, TRUE, RADARICON_FLAG, WPCOLOR_DROPPEDFLAG(flag.team));
 193
 194         if(autocvar_g_ctf_flag_return_time || (autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health))
 195         {
 196                 WaypointSprite_UpdateMaxHealth(flag.wps_flagdropped, flag.max_flag_health);
 197                 WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health);
 198         }
 199
 200         player.throw_antispam = time + autocvar_g_ctf_pass_wait;
 201
 202         if(droptype == DROP_PASS)
 203         {
 204                 flag.pass_sender = world;
 205                 flag.pass_target = world;
 206         }
 207 }
 208
 209 void ctf_Handle_Retrieve(entity flag, entity player)
 210 {
 211         entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
 212         entity sender = flag.pass_sender;
 213
 214         // transfer flag to player
 215         flag.ctf_carrier = player;
 216         flag.owner = player;
 217         flag.owner.flagcarried = flag;
 218
 219         // reset flag
 220         setattachment(flag, player, "");
 221         setorigin(flag, FLAG_CARRY_OFFSET);
 222         flag.movetype = MOVETYPE_NONE;
 223         flag.takedamage = DAMAGE_NO;
 224         flag.solid = SOLID_NOT;
 225         flag.ctf_carrier = player;
 226         flag.ctf_status = FLAG_CARRY;
 227
 228         // messages and sounds
 229         sound(player, CH_TRIGGER, "keepaway/respawn.wav", VOL_BASE, ATTN_NORM); // FIXCTF
 230         ctf_EventLog("recieve", flag.team, player);
 231         FOR_EACH_REALPLAYER(tmp_player)
 232                 if(tmp_player == sender)
 233                         centerprint(tmp_player, strcat("You passed the ", flag.netname, " to ", player.netname));
 234                 else if(tmp_player == player)
 235                         centerprint(tmp_player, strcat("You recieved the ", flag.netname, " from ", sender.netname));
 236                 else if(!IsDifferentTeam(tmp_player, sender))
 237                         centerprint(tmp_player, strcat(sender.netname, " passed the ", flag.netname, " to ", player.netname));
 238
 239         // create new waypoint
 240         ctf_FlagcarrierWaypoints(player);
 241
 242         sender.throw_antispam = time + autocvar_g_ctf_pass_wait;
 243         player.throw_antispam = sender.throw_antispam;
 244
 245         flag.pass_sender = world;
 246         flag.pass_target = world;
 247 }
 248
 249 void ctf_Handle_Throw(entity player, entity reciever, float droptype)
 250 {
 251         entity flag = player.flagcarried;
 252
 253         if(!flag) { return; }
 254         if((droptype == DROP_PASS) && !reciever) { return; }
 255
 256         if(flag.speedrunning) { ctf_RespawnFlag(flag); return; }
 257
 258         // reset the flag
 259         setattachment(flag, world, "");
 260         setorigin(flag, player.origin + FLAG_DROP_OFFSET);
 261         flag.owner.flagcarried = world;
 262         flag.owner = world;
 263         flag.solid = SOLID_TRIGGER;
 264         flag.ctf_droptime = time;
 265
 266         flag.flags = FL_ITEM | FL_NOTARGET; // clear FL_ONGROUND for MOVETYPE_TOSS
 267
 268         switch(droptype)
 269         {
 270                 case DROP_PASS:
 271                 {
 272                         vector targ_origin = (0.5 * (reciever.absmin + reciever.absmax));
 273                         flag.velocity = (normalize(targ_origin - player.origin) * autocvar_g_ctf_pass_velocity);
 274                         break;
 275                 }
 276
 277                 case DROP_THROW:
 278                 {
 279                         makevectors((player.v_angle_y * '0 1 0') + (player.v_angle_x * '0.5 0 0'));
 280                         flag.velocity = W_CalculateProjectileVelocity(player.velocity, ('0 0 200' + (v_forward * autocvar_g_ctf_drop_velocity)), FALSE);
 281                         break;
 282                 }
 283
 284                 case DROP_RESET:
 285                 {
 286                         flag.velocity = '0 0 0'; // do nothing
 287                         break;
 288                 }
 289
 290                 default:
 291                 case DROP_NORMAL:
 292                 {
 293                         flag.velocity = W_CalculateProjectileVelocity(player.velocity, ('0 0 200' + ('0 100 0' * crandom()) + ('100 0 0' * crandom())), FALSE);
 294                         break;
 295                 }
 296         }
 297
 298         switch(droptype)
 299         {
 300                 case DROP_PASS:
 301                 {
 302                         // main
 303                         flag.movetype = MOVETYPE_FLY;
 304                         flag.takedamage = DAMAGE_NO;
 305                         flag.pass_sender = player;
 306                         flag.pass_target = reciever;
 307                         flag.ctf_status = FLAG_PASSING;
 308
 309                         // other
 310                         sound(player, CH_TRIGGER, flag.snd_flag_touch, VOL_BASE, ATTN_NORM);
 311                         ctf_EventLog("pass", flag.team, player);
 312                         te_lightning2(world, reciever.origin, player.origin);
 313                         break;
 314                 }
 315
 316                 case DROP_RESET:
 317                 {
 318                         // do nothing
 319                         break;
 320                 }
 321
 322                 default:
 323                 case DROP_THROW:
 324                 case DROP_NORMAL:
 325                 {
 326                         ctf_Handle_Drop(flag, player, droptype);
 327                         break;
 328                 }
 329         }
 330
 331         // kill old waypointsprite
 332         WaypointSprite_Ping(player.wps_flagcarrier);
 333         WaypointSprite_Kill(player.wps_flagcarrier);
 334
 335         if(player.wps_enemyflagcarrier)
 336                         WaypointSprite_Kill(player.wps_enemyflagcarrier);
 337
 338         // captureshield
 339         ctf_CaptureShield_Update(player, 0); // shield player from picking up flag
 340 }
 341
 342
 343 // ==============
 344 // Event Handlers
 345 // ==============
 346
 347 void ctf_Handle_Capture(entity flag, entity toucher, float capturetype)
 348 {
 349         entity enemy_flag = ((capturetype == CAPTURE_NORMAL) ? toucher.flagcarried : toucher);
 350         entity player = ((capturetype == CAPTURE_NORMAL) ? toucher : enemy_flag.ctf_dropper);
 351
 352         if not(player) { return; } // without someone to give the reward to, we can't possibly cap
 353
 354         // messages and sounds
 355         Send_KillNotification(player.netname, enemy_flag.netname, ctf_CaptureRecord(enemy_flag, player), INFO_CAPTUREFLAG, MSG_INFO);
 356         sound(player, CH_TRIGGER, flag.snd_flag_capture, VOL_BASE, ATTN_NONE);
 357
 358         switch(capturetype)
 359         {
 360                 case CAPTURE_NORMAL: ctf_EventLog("capture", enemy_flag.team, player); break;
 361                 case CAPTURE_DROPPED: ctf_EventLog("droppedcapture", enemy_flag.team, player); break;
 362                 default: break;
 363         }
 364
 365         // scoring
 366         PlayerTeamScore_AddScore(player, ctf_ReadScore("score_capture"));
 367         PlayerTeamScore_Add(player, SP_CTF_CAPS, ST_CTF_CAPS, 1);
 368
 369         // effects
 370         if(autocvar_g_ctf_flag_capture_effects)
 371         {
 372                 pointparticles(particleeffectnum((player.team == COLOR_TEAM1) ? "red_ground_quake" : "blue_ground_quake"), flag.origin, '0 0 0', 1);
 373                 shockwave_spawn("models/ctf/shockwavetransring.md3", flag.origin - '0 0 15', -0.8, 0, 1);
 374         }
 375
 376         // other
 377         if(capturetype == CAPTURE_NORMAL)
 378         {
 379                 WaypointSprite_Kill(player.wps_flagcarrier);
 380                 if(flag.speedrunning) { ctf_FakeTimeLimit(player, -1); }
 381         }
 382
 383         // reset the flag
 384         player.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
 385         ctf_RespawnFlag(enemy_flag);
 386 }
 387
 388 void ctf_Handle_Return(entity flag, entity player)
 389 {
 390         // messages and sounds
 391         //centerprint(player, strcat("You returned the ", flag.netname));
 392         Send_KillNotification (player.netname, flag.netname, "", INFO_RETURNFLAG, MSG_INFO);
 393         sound(player, CH_TRIGGER, flag.snd_flag_returned, VOL_BASE, ATTN_NONE);
 394         ctf_EventLog("return", flag.team, player);
 395
 396         // scoring
 397         PlayerTeamScore_AddScore(player, ctf_ReadScore("score_return")); // reward for return
 398         PlayerScore_Add(player, SP_CTF_RETURNS, 1); // add to count of returns
 399
 400         TeamScore_AddToTeam(flag.team, ST_SCORE, -ctf_ReadScore("penalty_returned")); // punish the team who was last carrying it
 401
 402         if(flag.ctf_dropper)
 403         {
 404                 // punish the player who dropped the flag
 405                 PlayerScore_Add(flag.ctf_dropper, SP_SCORE, -ctf_ReadScore("penalty_returned"));
 406
 407                 // captureshield
 408                 ctf_CaptureShield_Update(flag.ctf_dropper, 0); // shield player from picking up flag
 409
 410                 // set next take time
 411                 flag.ctf_dropper.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
 412         }
 413
 414         // reset the flag
 415         ctf_RespawnFlag(flag);
 416 }
 417
 418 void ctf_Handle_Pickup(entity flag, entity player, float pickuptype)
 419 {
 420         // declarations
 421         entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
 422         string verbosename; // holds the name of the player OR no name at all for printing in the centerprints
 423         float pickup_dropped_score; // used to calculate dropped pickup score
 424
 425         // attach the flag to the player
 426         flag.owner = player;
 427         player.flagcarried = flag;
 428         setattachment(flag, player, "");
 429         setorigin(flag, FLAG_CARRY_OFFSET);
 430
 431         // flag setup
 432         flag.movetype = MOVETYPE_NONE;
 433         flag.takedamage = DAMAGE_NO;
 434         flag.solid = SOLID_NOT;
 435         flag.angles = '0 0 0';
 436         flag.ctf_carrier = player;
 437         flag.ctf_status = FLAG_CARRY;
 438
 439         switch(pickuptype)
 440         {
 441                 case PICKUP_BASE: flag.ctf_pickuptime = time; break; // used for timing runs
 442                 case PICKUP_DROPPED: flag.health = flag.max_flag_health; break; // reset health/return timelimit
 443                 default: break;
 444         }
 445
 446         // messages and sounds
 447         Send_KillNotification (player.netname, flag.netname, "", INFO_GOTFLAG, MSG_INFO);
 448         sound(player, CH_TRIGGER, flag.snd_flag_taken, VOL_BASE, ATTN_NONE);
 449         verbosename = ((autocvar_g_ctf_flag_pickup_verbosename) ? strcat(Team_ColorCode(player.team), "(^7", player.netname, Team_ColorCode(player.team), ") ") : "");
 450
 451         FOR_EACH_REALPLAYER(tmp_player)
 452                 if(tmp_player == player)
 453                         centerprint(tmp_player, strcat("You got the ", flag.netname, "!"));
 454                 else if(!IsDifferentTeam(tmp_player, player))
 455                         centerprint(tmp_player, strcat("Your ", Team_ColorCode(player.team), "team mate ", verbosename, "^7got the flag! Protect them!"));
 456                 else if(!IsDifferentTeam(tmp_player, flag))
 457                         centerprint(tmp_player, strcat("The ", Team_ColorCode(player.team), "enemy ", verbosename, "^7got your flag! Retrieve it!"));
 458
 459         switch(pickuptype)
 460         {
 461                 case PICKUP_BASE: ctf_EventLog("steal", flag.team, player); break;
 462                 case PICKUP_DROPPED: ctf_EventLog("pickup", flag.team, player); break;
 463                 default: break;
 464         }
 465
 466         // scoring
 467         PlayerScore_Add(player, SP_CTF_PICKUPS, 1);
 468         switch(pickuptype)
 469         {
 470                 case PICKUP_BASE:
 471                 {
 472                         PlayerTeamScore_AddScore(player, ctf_ReadScore("score_pickup_base"));
 473                         break;
 474                 }
 475
 476                 case PICKUP_DROPPED:
 477                 {
 478                         pickup_dropped_score = (autocvar_g_ctf_flag_return_time ? bound(0, ((flag.ctf_droptime + autocvar_g_ctf_flag_return_time) - time) / autocvar_g_ctf_flag_return_time, 1) : 1);
 479                         pickup_dropped_score = floor((ctf_ReadScore("score_pickup_dropped_late") * (1 - pickup_dropped_score) + ctf_ReadScore("score_pickup_dropped_early") * pickup_dropped_score) + 0.5);
 480                         print("pickup_dropped_score is ", ftos(pickup_dropped_score), "\n");
 481                         PlayerTeamScore_AddScore(player, pickup_dropped_score);
 482                         break;
 483                 }
 484
 485                 default: break;
 486         }
 487
 488         // speedrunning
 489         if(pickuptype == PICKUP_BASE)
 490         {
 491                 flag.speedrunning = player.speedrunning; // if speedrunning, flag will flag-return and teleport the owner back after the record
 492                 if((player.speedrunning) && (ctf_captimerecord))
 493                         ctf_FakeTimeLimit(player, time + ctf_captimerecord);
 494         }
 495
 496         // effects
 497         if(autocvar_g_ctf_flag_pickup_effects)
 498                 pointparticles(particleeffectnum("smoke_ring"), 0.5 * (flag.absmin + flag.absmax), '0 0 0', 1);
 499
 500         // waypoints
 501         if(pickuptype == PICKUP_DROPPED) { WaypointSprite_Kill(flag.wps_flagdropped); }
 502         ctf_FlagcarrierWaypoints(player);
 503         WaypointSprite_Ping(player.wps_flagcarrier);
 504 }
 505
 506
 507 // ===================
 508 // Main Flag Functions
 509 // ===================
 510
 511 void ctf_CheckFlagReturn(entity flag)
 512 {
 513         if(flag.wps_flagdropped) { WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health); }
 514
 515         if((flag.health <= 0) || (time >= flag.ctf_droptime + autocvar_g_ctf_flag_return_time))
 516         {
 517                 bprint("The ", flag.netname, " has returned to base\n");
 518                 sound(flag, CH_TRIGGER, flag.snd_flag_respawn, VOL_BASE, ATTN_NONE);
 519                 ctf_EventLog("returned", flag.team, world);
 520                 ctf_RespawnFlag(flag);
 521         }
 522 }
 523
 524 void ctf_FlagDamage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
 525 {
 526         if(ITEM_DAMAGE_NEEDKILL(deathtype))
 527         {
 528                 // automatically kill the flag and return it
 529                 self.health = 0;
 530                 ctf_CheckFlagReturn(self);
 531                 return;
 532         }
 533
 534         if(autocvar_g_ctf_flag_return_damage)
 535         {
 536                 // reduce health and check if it should be returned
 537                 self.health = self.health - damage;
 538                 ctf_CheckFlagReturn(self);
 539                 return;
 540         }
 541 }
 542
 543 void ctf_FlagThink()
 544 {
 545         // declarations
 546         entity tmp_entity;
 547
 548         self.nextthink = time + FLAG_THINKRATE; // only 5 fps, more is unnecessary.
 549
 550         // captureshield
 551         if(self == ctf_worldflaglist) // only for the first flag
 552                 FOR_EACH_CLIENT(tmp_entity)
 553                         ctf_CaptureShield_Update(tmp_entity, 1); // release shield only
 554
 555         // sanity checks
 556         if(self.mins != FLAG_MIN || self.maxs != FLAG_MAX) { // reset the flag boundaries in case it got squished
 557                 dprint("wtf the flag got squashed?\n");
 558                 tracebox(self.origin, FLAG_MIN, FLAG_MAX, self.origin, MOVE_NOMONSTERS, self);
 559                 if(!trace_startsolid) // can we resize it without getting stuck?
 560                         setsize(self, FLAG_MIN, FLAG_MAX); }
 561
 562         // main think method
 563         switch(self.ctf_status)
 564         {
 565                 case FLAG_BASE:
 566                 {
 567                         if(autocvar_g_ctf_dropped_capture_radius)
 568                         {
 569                                 for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
 570                                         if(tmp_entity.ctf_status == FLAG_DROPPED)
 571                                                 if(vlen(self.origin - tmp_entity.origin) < autocvar_g_ctf_dropped_capture_radius)
 572                                                         ctf_Handle_Capture(self, tmp_entity, CAPTURE_DROPPED);
 573                         }
 574                         return;
 575                 }
 576
 577                 case FLAG_DROPPED:
 578                 {
 579                         if(autocvar_g_ctf_flag_return_dropped)
 580                         {
 581                                 if((vlen(self.origin - self.ctf_spawnorigin) <= autocvar_g_ctf_flag_return_dropped) || (autocvar_g_ctf_flag_return_dropped == -1))
 582                                 {
 583                                         self.health = 0;
 584                                         ctf_CheckFlagReturn(self);
 585                                         return;
 586                                 }
 587                         }
 588                         if(autocvar_g_ctf_flag_return_time)
 589                         {
 590                                 self.health -= ((self.max_flag_health / autocvar_g_ctf_flag_return_time) * FLAG_THINKRATE);
 591                                 ctf_CheckFlagReturn(self);
 592                                 return;
 593                         }
 594                         return;
 595                 }
 596
 597                 case FLAG_CARRY:
 598                 {
 599                         if(self.speedrunning && ctf_captimerecord && (time >= self.ctf_pickuptime + ctf_captimerecord))
 600                         {
 601                                 bprint("The ", self.netname, " became impatient after ", ftos_decimals(ctf_captimerecord, 2), " seconds and returned itself\n");
 602                                 sound(self, CH_TRIGGER, self.snd_flag_respawn, VOL_BASE, ATTN_NONE);
 603                                 ctf_EventLog("returned", self.team, world);
 604                                 ctf_RespawnFlag(tmp_entity);
 605
 606                                 tmp_entity = self;
 607                                 self = self.owner;
 608                                 self.impulse = CHIMPULSE_SPEEDRUN; // move the player back to the waypoint they set
 609                                 ImpulseCommands();
 610                                 self = tmp_entity;
 611                         }
 612
 613                         if(autocvar_g_ctf_flagcarrier_waypointforenemy_time)
 614                         if((time >= self.ctf_pickuptime + autocvar_g_ctf_flagcarrier_waypointforenemy_time) && !self.owner.wps_enemyflagcarrier)
 615                         {
 616                                 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));
 617
 618                                 if(!self.wpforenemy_announced)
 619                                 {
 620                                         FOR_EACH_REALPLAYER(tmp_entity)
 621                                         {
 622                                                 if(tmp_entity == self.owner)
 623                                                         centerprint(tmp_entity, strcat("Enemies can now see you on radar! (held ", self.netname, " for ", ftos(autocvar_g_ctf_flagcarrier_waypointforenemy_time), " seconds)"));
 624                                                 else if(IsDifferentTeam(tmp_entity, self.owner))
 625                                                         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)"));
 626                                                 else
 627                                                         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)"));
 628                                         }
 629
 630                                         self.wpforenemy_announced = TRUE;
 631                                 }
 632                         }
 633                         return;
 634                 }
 635
 636                 case FLAG_PASSING: // todo make work with warpzones
 637                 {
 638                         vector targ_origin = ((self.pass_target.absmin + self.pass_target.absmax) * 0.5);
 639                         traceline(self.origin, targ_origin, MOVE_NOMONSTERS, self);
 640
 641                         if((self.pass_target.deadflag != DEAD_NO)
 642                                 || (vlen(self.origin - targ_origin) > autocvar_g_ctf_pass_radius)
 643                                 || ((trace_fraction < 1) && (trace_ent != self.pass_target))
 644                                 || (time > self.ctf_droptime + autocvar_g_ctf_pass_timelimit))
 645                         {
 646                                 ctf_Handle_Drop(self, world, DROP_PASS);
 647                         }
 648                         else // still a viable target, go for it
 649                         {
 650                                 vector desired_direction = normalize(targ_origin - self.origin);
 651                                 vector current_direction = normalize(self.velocity);
 652
 653                                 self.velocity = (normalize(current_direction + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_pass_velocity);
 654                         }
 655                         return;
 656                 }
 657
 658                 default: // this should never happen
 659                 {
 660                         dprint("ctf_FlagThink(): Flag exists with no status?\n");
 661                         return;
 662                 }
 663         }
 664 }
 665
 666 void ctf_FlagTouch()
 667 {
 668         if(gameover) { return; }
 669
 670         entity toucher = other;
 671
 672         // automatically kill the flag and return it if it touched lava/slime/nodrop surfaces
 673         if(ITEM_TOUCH_NEEDKILL())
 674         {
 675                 self.health = 0;
 676                 ctf_CheckFlagReturn(self);
 677                 return;
 678         }
 679
 680         // special touch behaviors
 681         if(toucher.vehicle_flags & VHF_ISVEHICLE)
 682         {
 683                 if(autocvar_g_ctf_allow_vehicle_touch)
 684                         toucher = toucher.owner; // the player is actually the vehicle owner, not other
 685                 else
 686                         return; // do nothing
 687         }
 688         else if(toucher.classname != "player") // The flag just touched an object, most likely the world
 689         {
 690                 if(time > self.wait) // if we haven't in a while, play a sound/effect
 691                 {
 692                         pointparticles(particleeffectnum("kaball_sparks"), self.origin, '0 0 0', 1);
 693                         sound(self, CH_TRIGGER, self.snd_flag_touch, VOL_BASE, ATTN_NORM);
 694                         self.wait = time + FLAG_TOUCHRATE;
 695                 }
 696                 return;
 697         }
 698         else if(toucher.deadflag != DEAD_NO) { return; }
 699
 700         switch(self.ctf_status)
 701         {
 702                 case FLAG_BASE:
 703                 {
 704                         if(!IsDifferentTeam(toucher, self) && (toucher.flagcarried) && IsDifferentTeam(toucher.flagcarried, self))
 705                                 ctf_Handle_Capture(self, toucher, CAPTURE_NORMAL); // toucher just captured the enemies flag to his base
 706                         else if(IsDifferentTeam(toucher, self) && (!toucher.flagcarried) && (!toucher.ctf_captureshielded) && (time > toucher.next_take_time))
 707                                 ctf_Handle_Pickup(self, toucher, PICKUP_BASE); // toucher just stole the enemies flag
 708                         break;
 709                 }
 710
 711                 case FLAG_DROPPED:
 712                 {
 713                         if(!IsDifferentTeam(toucher, self))
 714                                 ctf_Handle_Return(self, toucher); // toucher just returned his own flag
 715                         else if((!toucher.flagcarried) && ((toucher != self.ctf_dropper) || (time > self.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
 716                                 ctf_Handle_Pickup(self, toucher, PICKUP_DROPPED); // toucher just picked up a dropped enemy flag
 717                         break;
 718                 }
 719
 720                 case FLAG_CARRY:
 721                 {
 722                         dprint("Someone touched a flag even though it was being carried?\n");
 723                         break;
 724                 }
 725
 726                 case FLAG_PASSING:
 727                 {
 728                         if((toucher.classname == "player") && (toucher.deadflag == DEAD_NO) && (toucher != self.pass_sender))
 729                         {
 730                                 if(IsDifferentTeam(toucher, self.pass_sender))
 731                                         ctf_Handle_Return(self, toucher);
 732                                 else
 733                                         ctf_Handle_Retrieve(self, toucher);
 734                         }
 735                         break;
 736                 }
 737
 738                 default: // this should never happen
 739                 {
 740                         dprint("Touch: Flag exists with no status?\n");
 741                         break;
 742                 }
 743         }
 744 }
 745
 746 void ctf_RespawnFlag(entity flag)
 747 {
 748         // reset the player (if there is one)
 749         if((flag.owner) && (flag.owner.flagcarried == flag))
 750         {
 751                 if(flag.owner.wps_enemyflagcarrier)
 752                         WaypointSprite_Kill(flag.owner.wps_enemyflagcarrier);
 753
 754                 WaypointSprite_Kill(flag.wps_flagcarrier);
 755
 756                 flag.owner.flagcarried = world;
 757
 758                 if(flag.speedrunning)
 759                         ctf_FakeTimeLimit(flag.owner, -1);
 760         }
 761
 762         if((flag.ctf_status == FLAG_DROPPED) && (flag.wps_flagdropped))
 763                 { WaypointSprite_Kill(flag.wps_flagdropped); }
 764
 765         // reset the flag
 766         setattachment(flag, world, "");
 767         setorigin(flag, flag.ctf_spawnorigin);
 768
 769         flag.movetype = ((flag.noalign) ? MOVETYPE_NONE : MOVETYPE_TOSS);
 770         flag.takedamage = DAMAGE_NO;
 771         flag.health = flag.max_flag_health;
 772         flag.solid = SOLID_TRIGGER;
 773         flag.velocity = '0 0 0';
 774         flag.angles = flag.mangle;
 775         flag.flags = FL_ITEM | FL_NOTARGET;
 776
 777         flag.ctf_status = FLAG_BASE;
 778         flag.owner = world;
 779         flag.pass_sender = world;
 780         flag.pass_target = world;
 781         flag.ctf_carrier = world;
 782         flag.ctf_dropper = world;
 783         flag.ctf_pickuptime = 0;
 784         flag.ctf_droptime = 0;
 785         flag.wpforenemy_announced = FALSE;
 786 }
 787
 788 void ctf_Reset()
 789 {
 790         if(self.owner)
 791                 if(self.owner.classname == "player")
 792                         ctf_Handle_Throw(self.owner, world, DROP_RESET);
 793
 794         ctf_RespawnFlag(self);
 795 }
 796
 797 void ctf_DelayedFlagSetup(void) // called after a flag is placed on a map by ctf_FlagSetup()
 798 {
 799         // bot waypoints
 800         waypoint_spawnforitem_force(self, self.origin);
 801         self.nearestwaypointtimeout = 0; // activate waypointing again
 802         self.bot_basewaypoint = self.nearestwaypoint;
 803
 804         // waypointsprites
 805         WaypointSprite_SpawnFixed(((self.team == COLOR_TEAM1) ? "redbase" : "bluebase"), self.origin + FLAG_WAYPOINT_OFFSET, self, wps_flagbase, RADARICON_FLAG, colormapPaletteColor(self.team - 1, FALSE));
 806         WaypointSprite_UpdateTeamRadar(self.wps_flagbase, RADARICON_FLAG, colormapPaletteColor(self.team - 1, FALSE));
 807
 808         // captureshield setup
 809         ctf_CaptureShield_Spawn(self);
 810 }
 811
 812 void ctf_FlagSetup(float teamnumber, entity flag) // called when spawning a flag entity on the map as a spawnfunc
 813 {
 814         // declarations
 815         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.
 816         self = flag; // for later usage with droptofloor()
 817
 818         // main setup
 819         flag.ctf_worldflagnext = ctf_worldflaglist; // link flag into ctf_worldflaglist
 820         ctf_worldflaglist = flag;
 821
 822         setattachment(flag, world, "");
 823
 824         flag.netname = ((teamnumber) ? "^1RED^7 flag" : "^4BLUE^7 flag");
 825         flag.team = ((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2); // COLOR_TEAM1: color 4 team (red) - COLOR_TEAM2: color 13 team (blue)
 826         flag.items = ((teamnumber) ? IT_KEY2 : IT_KEY1); // IT_KEY2: gold key (redish enough) - IT_KEY1: silver key (bluish enough)
 827         flag.classname = "item_flag_team";
 828         flag.target = "###item###"; // wut?
 829         flag.flags = FL_ITEM | FL_NOTARGET;
 830         flag.solid = SOLID_TRIGGER;
 831         flag.takedamage = DAMAGE_NO;
 832         flag.damageforcescale = autocvar_g_ctf_flag_damageforcescale;
 833         flag.max_flag_health = ((autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health) ? autocvar_g_ctf_flag_health : 100);
 834         flag.health = flag.max_flag_health;
 835         flag.event_damage = ctf_FlagDamage;
 836         flag.pushable = TRUE;
 837         flag.damagedbytriggers = autocvar_g_ctf_flag_return_when_unreachable;
 838         flag.damagedbycontents = autocvar_g_ctf_flag_return_when_unreachable;
 839         flag.velocity = '0 0 0';
 840         flag.mangle = flag.angles;
 841         flag.reset = ctf_Reset;
 842         flag.touch = ctf_FlagTouch;
 843         flag.think = ctf_FlagThink;
 844         flag.nextthink = time + FLAG_THINKRATE;
 845         flag.ctf_status = FLAG_BASE;
 846
 847         if(!flag.model) { flag.model = ((teamnumber) ? autocvar_g_ctf_flag_red_model : autocvar_g_ctf_flag_blue_model); }
 848         if(!flag.scale) { flag.scale = FLAG_SCALE; }
 849         if(!flag.skin) { flag.skin = ((teamnumber) ? autocvar_g_ctf_flag_red_skin : autocvar_g_ctf_flag_blue_skin); }
 850
 851         // sound
 852         if(!flag.snd_flag_taken) { flag.snd_flag_taken  = ((teamnumber) ? "ctf/red_taken.wav" : "ctf/blue_taken.wav"); }
 853         if(!flag.snd_flag_returned) { flag.snd_flag_returned = ((teamnumber) ? "ctf/red_returned.wav" : "ctf/blue_returned.wav"); }
 854         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
 855         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.
 856         if(!flag.snd_flag_dropped) { flag.snd_flag_dropped = ((teamnumber) ? "ctf/red_dropped.wav" : "ctf/blue_dropped.wav"); }
 857         if(!flag.snd_flag_touch) { flag.snd_flag_touch = "keepaway/touch.wav"; } // again has no team-based sound // FIXME
 858
 859         // precache
 860         precache_sound(flag.snd_flag_taken);
 861         precache_sound(flag.snd_flag_returned);
 862         precache_sound(flag.snd_flag_capture);
 863         precache_sound(flag.snd_flag_respawn);
 864         precache_sound(flag.snd_flag_dropped);
 865         precache_sound(flag.snd_flag_touch);
 866         precache_model(flag.model);
 867         precache_model("models/ctf/shield.md3");
 868         precache_model("models/ctf/shockwavetransring.md3");
 869
 870         // appearence
 871         setmodel(flag, flag.model); // precision set below
 872         setsize(flag, FLAG_MIN, FLAG_MAX);
 873         setorigin(flag, (flag.origin + FLAG_SPAWN_OFFSET));
 874
 875         if(autocvar_g_ctf_flag_glowtrails)
 876         {
 877                 flag.glow_color = ((teamnumber) ? 251 : 210); // 251: red - 210: blue
 878                 flag.glow_size = 25;
 879                 flag.glow_trail = 1;
 880         }
 881
 882         flag.effects |= EF_LOWPRECISION;
 883         if(autocvar_g_ctf_fullbrightflags) { flag.effects |= EF_FULLBRIGHT; }
 884         if(autocvar_g_ctf_dynamiclights)   { flag.effects |= ((teamnumber) ? EF_RED : EF_BLUE); }
 885
 886         // flag placement
 887         if((flag.spawnflags & 1) || flag.noalign) // don't drop to floor, just stay at fixed location
 888         {
 889                 flag.dropped_origin = flag.origin;
 890                 flag.noalign = TRUE;
 891                 flag.movetype = MOVETYPE_NONE;
 892         }
 893         else // drop to floor, automatically find a platform and set that as spawn origin
 894         {
 895                 flag.noalign = FALSE;
 896                 self = flag;
 897                 droptofloor();
 898                 flag.movetype = MOVETYPE_TOSS;
 899         }
 900
 901         InitializeEntity(flag, ctf_DelayedFlagSetup, INITPRIO_SETLOCATION);
 902 }
 903
 904
 905 // ==============
 906 // Hook Functions
 907 // ==============
 908
 909 MUTATOR_HOOKFUNCTION(ctf_PlayerPreThink)
 910 {
 911         entity flag;
 912
 913         // initially clear items so they can be set as necessary later.
 914         self.items &~= (IT_RED_FLAG_CARRYING | IT_RED_FLAG_TAKEN | IT_RED_FLAG_LOST
 915                 | IT_BLUE_FLAG_CARRYING | IT_BLUE_FLAG_TAKEN | IT_BLUE_FLAG_LOST | IT_CTF_SHIELDED);
 916
 917         // scan through all the flags and notify the client about them
 918         for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
 919         {
 920                 if(flag.ctf_status == FLAG_CARRY)
 921                         if(flag.owner == self)
 922                                 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_CARRYING : IT_BLUE_FLAG_CARRYING); // carrying: self is currently carrying the flag
 923                         else
 924                                 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_TAKEN : IT_BLUE_FLAG_TAKEN); // taken: someone on self's team is carrying the flag
 925                 else if(flag.ctf_status == FLAG_DROPPED)
 926                         self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_LOST : IT_BLUE_FLAG_LOST); // lost: the flag is dropped somewhere on the map
 927         }
 928
 929         // item for stopping players from capturing the flag too often
 930         if(self.ctf_captureshielded)
 931                 self.items |= IT_CTF_SHIELDED;
 932
 933         // update the health of the flag carrier waypointsprite
 934         if(self.wps_flagcarrier)
 935                 WaypointSprite_UpdateHealth(self.wps_flagcarrier, self.health);
 936
 937         return 0;
 938 }
 939
 940 MUTATOR_HOOKFUNCTION(ctf_PlayerDamage) // for changing damage and force values that are applied to players in g_damage.qc
 941 {
 942         if(frag_attacker.flagcarried) // if the attacker is a flagcarrier
 943         {
 944                 if(frag_target == frag_attacker) // damage done to yourself
 945                 {
 946                         frag_damage *= autocvar_g_ctf_flagcarrier_selfdamagefactor;
 947                         frag_force *= autocvar_g_ctf_flagcarrier_selfforcefactor;
 948                 }
 949                 else // damage done everyone else
 950                 {
 951                         frag_damage *= autocvar_g_ctf_flagcarrier_damagefactor;
 952                         frag_force *= autocvar_g_ctf_flagcarrier_forcefactor;
 953                 }
 954         }
 955         return 0;
 956 }
 957
 958 MUTATOR_HOOKFUNCTION(ctf_PlayerDies)
 959 {
 960         if((frag_attacker != frag_target) && (frag_attacker.classname == "player") && (frag_target.flagcarried))
 961         {
 962                 PlayerTeamScore_AddScore(frag_attacker, ctf_ReadScore("score_kill"));
 963                 PlayerScore_Add(frag_attacker, SP_CTF_FCKILLS, 1);
 964         }
 965
 966         if(frag_target.flagcarried)
 967                 { ctf_Handle_Throw(frag_target, world, DROP_NORMAL); }
 968
 969         return 0;
 970 }
 971
 972 MUTATOR_HOOKFUNCTION(ctf_GiveFragsForKill)
 973 {
 974         frag_score = 0;
 975         return (autocvar_g_ctf_ignore_frags); // no frags counted in ctf if this is true
 976 }
 977
 978 MUTATOR_HOOKFUNCTION(ctf_RemovePlayer)
 979 {
 980         if(self.flagcarried)
 981                 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
 982
 983         return 0;
 984 }
 985
 986 MUTATOR_HOOKFUNCTION(ctf_PortalTeleport)
 987 {
 988         if(self.flagcarried)
 989         if(!autocvar_g_ctf_portalteleport)
 990                 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
 991
 992         return 0;
 993 }
 994
 995 MUTATOR_HOOKFUNCTION(ctf_PlayerUseKey)
 996 {
 997         entity player = self;
 998
 999         if((time > player.throw_antispam) && !player.speedrunning && (!player.vehicle || autocvar_g_ctf_allow_vehicle_touch))
1000         {
1001                 // pass the flag to a team mate
1002                 if(autocvar_g_ctf_pass)
1003                 {
1004                         entity head, closest_target;
1005                         head = findradius(player.origin, autocvar_g_ctf_pass_radius);
1006
1007                         while(head) // find the closest acceptable target to pass to
1008                         {
1009                                 if(head.classname == "player" && head.deadflag == DEAD_NO)
1010                                 if(head != player && !IsDifferentTeam(head, player))
1011                                 if(!head.speedrunning && (!head.vehicle || autocvar_g_ctf_allow_vehicle_touch))
1012                                 {
1013                                         traceline(player.origin, head.origin, MOVE_NOMONSTERS, player);
1014                                         if not((trace_fraction < 1) && (trace_ent != head))
1015                                         {
1016                                                 if(autocvar_g_ctf_pass_request && !player.flagcarried && head.flagcarried)
1017                                                 {
1018                                                         if(clienttype(head) == CLIENTTYPE_BOT)
1019                                                         {
1020                                                                 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
1021                                                                 ctf_Handle_Throw(head, player, DROP_PASS);
1022                                                         }
1023                                                         else
1024                                                         {
1025                                                                 centerprint(head, strcat(player.netname, " requests you to pass the ", head.flagcarried.netname));
1026                                                                 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
1027                                                         }
1028                                                         player.throw_antispam = time + autocvar_g_ctf_pass_wait;
1029                                                         return 0;
1030                                                 }
1031                                                 else if(player.flagcarried)
1032                                                 {
1033                                                         if(closest_target) { if(vlen(player.origin - head.origin) < vlen(player.origin - closest_target.origin)) { closest_target = head; } }
1034                                                         else { closest_target = head; }
1035                                                 }
1036                                         }
1037                                 }
1038                                 head = head.chain;
1039                         }
1040
1041                         if(closest_target) { ctf_Handle_Throw(player, closest_target, DROP_PASS); return 0; }
1042                 }
1043
1044                 // throw the flag in front of you
1045                 if(autocvar_g_ctf_drop && player.flagcarried)
1046                         { ctf_Handle_Throw(player, world, DROP_THROW); }
1047         }
1048
1049         return 0;
1050 }
1051
1052 MUTATOR_HOOKFUNCTION(ctf_HelpMePing)
1053 {
1054         if(self.wps_flagcarrier) // update the flagcarrier waypointsprite with "NEEDING HELP" notification
1055         {
1056                 WaypointSprite_HelpMePing(self.wps_flagcarrier);
1057         }
1058         else // create a normal help me waypointsprite
1059         {
1060                 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');
1061                 WaypointSprite_Ping(self.wps_helpme);
1062         }
1063
1064         return 1;
1065 }
1066
1067 MUTATOR_HOOKFUNCTION(ctf_VehicleEnter)
1068 {
1069         if(other.flagcarried)
1070         {
1071                 if(!autocvar_g_ctf_flagcarrier_allow_vehicle_carry)
1072                 {
1073                         ctf_Handle_Throw(self, world, DROP_NORMAL);
1074                 }
1075                 else
1076                 {
1077                         setattachment(other.flagcarried, self, "");
1078                         setorigin(other, VEHICLE_FLAG_OFFSET);
1079                         other.flagcarried.scale = VEHICLE_FLAG_SCALE;
1080                         //other.flagcarried.angles = '0 0 0';
1081                 }
1082         }
1083
1084         return 0;
1085 }
1086
1087 MUTATOR_HOOKFUNCTION(ctf_VehicleExit)
1088 {
1089         if(self.owner.flagcarried)
1090         {
1091                 setattachment(self.owner.flagcarried, self.owner, "");
1092                 setorigin(self.owner.flagcarried, FLAG_CARRY_OFFSET);
1093                 self.owner.flagcarried.scale = FLAG_SCALE;
1094                 self.owner.flagcarried.angles = '0 0 0';
1095         }
1096
1097         return 0;
1098 }
1099
1100 MUTATOR_HOOKFUNCTION(ctf_AbortSpeedrun)
1101 {
1102         if(self.flagcarried)
1103         {
1104                 bprint("The ", self.flagcarried.netname, " was returned to base by its carrier\n");
1105                 ctf_RespawnFlag(self);
1106         }
1107
1108         return 0;
1109 }
1110
1111 MUTATOR_HOOKFUNCTION(ctf_MatchEnd)
1112 {
1113         entity flag; // temporary entity for the search method
1114
1115         if(gameover) // is this necessary?
1116         {
1117                 for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
1118                 {
1119                         switch(flag.ctf_status)
1120                         {
1121                                 case FLAG_DROPPED:
1122                                 case FLAG_PASSING:
1123                                 {
1124                                         // lock the flag, game is over
1125                                         flag.movetype = MOVETYPE_NONE;
1126                                         flag.takedamage = DAMAGE_NO;
1127                                         flag.solid = SOLID_NOT;
1128                                         flag.nextthink = 0; // stop thinking
1129
1130                                         print("stopping the ", flag.netname, " from moving.\n");
1131                                         break;
1132                                 }
1133
1134                                 default:
1135                                 case FLAG_BASE:
1136                                 case FLAG_CARRY:
1137                                 {
1138                                         // do nothing for these flags
1139                                         break;
1140                                 }
1141                         }
1142                 }
1143         }
1144
1145         return 0;
1146 }
1147
1148
1149 // ==========
1150 // Spawnfuncs
1151 // ==========
1152
1153 /*QUAKED spawnfunc_info_player_team1 (1 0 0) (-16 -16 -24) (16 16 24)
1154 CTF Starting point for a player in team one (Red).
1155 Keys: "angle" viewing angle when spawning. */
1156 void spawnfunc_info_player_team1()
1157 {
1158         if(g_assault) { remove(self); return; }
1159
1160         self.team = COLOR_TEAM1; // red
1161         spawnfunc_info_player_deathmatch();
1162 }
1163
1164
1165 /*QUAKED spawnfunc_info_player_team2 (1 0 0) (-16 -16 -24) (16 16 24)
1166 CTF Starting point for a player in team two (Blue).
1167 Keys: "angle" viewing angle when spawning. */
1168 void spawnfunc_info_player_team2()
1169 {
1170         if(g_assault) { remove(self); return; }
1171
1172         self.team = COLOR_TEAM2; // blue
1173         spawnfunc_info_player_deathmatch();
1174 }
1175
1176 /*QUAKED spawnfunc_info_player_team3 (1 0 0) (-16 -16 -24) (16 16 24)
1177 CTF Starting point for a player in team three (Yellow).
1178 Keys: "angle" viewing angle when spawning. */
1179 void spawnfunc_info_player_team3()
1180 {
1181         if(g_assault) { remove(self); return; }
1182
1183         self.team = COLOR_TEAM3; // yellow
1184         spawnfunc_info_player_deathmatch();
1185 }
1186
1187
1188 /*QUAKED spawnfunc_info_player_team4 (1 0 0) (-16 -16 -24) (16 16 24)
1189 CTF Starting point for a player in team four (Purple).
1190 Keys: "angle" viewing angle when spawning. */
1191 void spawnfunc_info_player_team4()
1192 {
1193         if(g_assault) { remove(self); return; }
1194
1195         self.team = COLOR_TEAM4; // purple
1196         spawnfunc_info_player_deathmatch();
1197 }
1198
1199 /*QUAKED spawnfunc_item_flag_team1 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1200 CTF flag for team one (Red).
1201 Keys:
1202 "angle" Angle the flag will point (minus 90 degrees)...
1203 "model" model to use, note this needs red and blue as skins 0 and 1...
1204 "noise" sound played when flag is picked up...
1205 "noise1" sound played when flag is returned by a teammate...
1206 "noise2" sound played when flag is captured...
1207 "noise3" sound played when flag is lost in the field and respawns itself...
1208 "noise4" sound played when flag is dropped by a player...
1209 "noise5" sound played when flag touches the ground... */
1210 void spawnfunc_item_flag_team1()
1211 {
1212         if(!g_ctf) { remove(self); return; }
1213
1214         ctf_FlagSetup(1, self); // 1 = red
1215 }
1216
1217 /*QUAKED spawnfunc_item_flag_team2 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1218 CTF flag for team two (Blue).
1219 Keys:
1220 "angle" Angle the flag will point (minus 90 degrees)...
1221 "model" model to use, note this needs red and blue as skins 0 and 1...
1222 "noise" sound played when flag is picked up...
1223 "noise1" sound played when flag is returned by a teammate...
1224 "noise2" sound played when flag is captured...
1225 "noise3" sound played when flag is lost in the field and respawns itself...
1226 "noise4" sound played when flag is dropped by a player...
1227 "noise5" sound played when flag touches the ground... */
1228 void spawnfunc_item_flag_team2()
1229 {
1230         if(!g_ctf) { remove(self); return; }
1231
1232         ctf_FlagSetup(0, self); // the 0 is misleading, but -- 0 = blue.
1233 }
1234
1235 /*QUAKED spawnfunc_ctf_team (0 .5 .8) (-16 -16 -24) (16 16 32)
1236 Team declaration for CTF gameplay, this allows you to decide what team names and control point models are used in your map.
1237 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.
1238 Keys:
1239 "netname" Name of the team (for example Red, Blue, Green, Yellow, Life, Death, Offense, Defense, etc)...
1240 "cnt" Scoreboard color of the team (for example 4 is red and 13 is blue)... */
1241 void spawnfunc_ctf_team()
1242 {
1243         if(!g_ctf) { remove(self); return; }
1244
1245         self.classname = "ctf_team";
1246         self.team = self.cnt + 1;
1247 }
1248
1249
1250 // ==============
1251 // Initialization
1252 // ==============
1253
1254 // code from here on is just to support maps that don't have flag and team entities
1255 void ctf_SpawnTeam (string teamname, float teamcolor)
1256 {
1257         entity oldself;
1258         oldself = self;
1259         self = spawn();
1260         self.classname = "ctf_team";
1261         self.netname = teamname;
1262         self.cnt = teamcolor;
1263
1264         spawnfunc_ctf_team();
1265
1266         self = oldself;
1267 }
1268
1269 void ctf_DelayedInit() // Do this check with a delay so we can wait for teams to be set up.
1270 {
1271         // if no teams are found, spawn defaults
1272         if(find(world, classname, "ctf_team") == world)
1273         {
1274                 print("No ""ctf_team"" entities found on this map, creating them anyway.\n");
1275                 ctf_SpawnTeam("Red", COLOR_TEAM1 - 1);
1276                 ctf_SpawnTeam("Blue", COLOR_TEAM2 - 1);
1277         }
1278
1279         ScoreRules_ctf();
1280 }
1281
1282 void ctf_Initialize()
1283 {
1284         ctf_captimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));
1285
1286         ctf_captureshield_min_negscore = autocvar_g_ctf_shield_min_negscore;
1287         ctf_captureshield_max_ratio = autocvar_g_ctf_shield_max_ratio;
1288         ctf_captureshield_force = autocvar_g_ctf_shield_force;
1289
1290         InitializeEntity(world, ctf_DelayedInit, INITPRIO_GAMETYPE);
1291 }
1292
1293
1294 MUTATOR_DEFINITION(gamemode_ctf)
1295 {
1296         MUTATOR_HOOK(MakePlayerObserver, ctf_RemovePlayer, CBC_ORDER_ANY);
1297         MUTATOR_HOOK(ClientDisconnect, ctf_RemovePlayer, CBC_ORDER_ANY);
1298         MUTATOR_HOOK(PlayerDies, ctf_PlayerDies, CBC_ORDER_ANY);
1299         MUTATOR_HOOK(MatchEnd, ctf_MatchEnd, CBC_ORDER_ANY);
1300         MUTATOR_HOOK(PortalTeleport, ctf_PortalTeleport, CBC_ORDER_ANY);
1301         MUTATOR_HOOK(GiveFragsForKill, ctf_GiveFragsForKill, CBC_ORDER_ANY);
1302         MUTATOR_HOOK(PlayerPreThink, ctf_PlayerPreThink, CBC_ORDER_ANY);
1303         MUTATOR_HOOK(PlayerDamage_Calculate, ctf_PlayerDamage, CBC_ORDER_ANY);
1304         MUTATOR_HOOK(PlayerUseKey, ctf_PlayerUseKey, CBC_ORDER_ANY);
1305         MUTATOR_HOOK(HelpMePing, ctf_HelpMePing, CBC_ORDER_ANY);
1306         MUTATOR_HOOK(VehicleEnter, ctf_VehicleEnter, CBC_ORDER_ANY);
1307         MUTATOR_HOOK(VehicleExit, ctf_VehicleExit, CBC_ORDER_ANY);
1308         MUTATOR_HOOK(AbortSpeedrun, ctf_AbortSpeedrun, CBC_ORDER_ANY);
1309
1310         MUTATOR_ONADD
1311         {
1312                 if(time > 1) // game loads at time 1
1313                         error("This is a game type and it cannot be added at runtime.");
1314                 g_ctf = 1;
1315                 ctf_Initialize();
1316         }
1317
1318         MUTATOR_ONREMOVE
1319         {
1320                 g_ctf = 0;
1321                 error("This is a game type and it cannot be removed at runtime.");
1322         }
1323
1324         return 0;
1325 }