qcsrc/server/mutators/mutator/gamemode_keyhunt.qc

   1 #include "gamemode_keyhunt.qh"
   2
   3 float autocvar_g_balance_keyhunt_damageforcescale;
   4 float autocvar_g_balance_keyhunt_delay_collect;
   5 float autocvar_g_balance_keyhunt_delay_return;
   6 float autocvar_g_balance_keyhunt_delay_round;
   7 float autocvar_g_balance_keyhunt_delay_tracking;
   8 float autocvar_g_balance_keyhunt_dropvelocity;
   9 float autocvar_g_balance_keyhunt_maxdist;
  10 float autocvar_g_balance_keyhunt_protecttime;
  11
  12 int autocvar_g_balance_keyhunt_score_capture;
  13 int autocvar_g_balance_keyhunt_score_carrierfrag;
  14 int autocvar_g_balance_keyhunt_score_collect;
  15 int autocvar_g_balance_keyhunt_score_destroyed;
  16 int autocvar_g_balance_keyhunt_score_destroyed_ownfactor;
  17 int autocvar_g_balance_keyhunt_score_push;
  18 float autocvar_g_balance_keyhunt_throwvelocity;
  19
  20 int autocvar_g_keyhunt_teams;
  21 int autocvar_g_keyhunt_teams_override;
  22
  23 // #define KH_PLAYER_USE_ATTACHMENT
  24 // #define KH_PLAYER_USE_CARRIEDMODEL
  25
  26 #ifdef KH_PLAYER_USE_ATTACHMENT
  27 const vector KH_PLAYER_ATTACHMENT_DIST_ROTATED = '0 -4 0';
  28 const vector KH_PLAYER_ATTACHMENT_DIST = '4 0 0';
  29 const vector KH_PLAYER_ATTACHMENT = '0 0 0';
  30 const vector KH_PLAYER_ATTACHMENT_ANGLES = '0 0 0';
  31 const string KH_PLAYER_ATTACHMENT_BONE = "";
  32 #else
  33 const float KH_KEY_ZSHIFT = 22;
  34 const float KH_KEY_XYDIST = 24;
  35 const float KH_KEY_XYSPEED = 45;
  36 #endif
  37 const float KH_KEY_WP_ZSHIFT = 20;
  38
  39 const vector KH_KEY_MIN = '-10 -10 -46';
  40 const vector KH_KEY_MAX = '10 10 3';
  41 const float KH_KEY_BRIGHTNESS = 2;
  42
  43 bool kh_no_radar_circles;
  44
  45 // kh_state
  46 //     bits  0- 4: team of key 1, or 0 for no such key, or 30 for dropped, or 31 for self
  47 //     bits  5- 9: team of key 2, or 0 for no such key, or 30 for dropped, or 31 for self
  48 //     bits 10-14: team of key 3, or 0 for no such key, or 30 for dropped, or 31 for self
  49 //     bits 15-19: team of key 4, or 0 for no such key, or 30 for dropped, or 31 for self
  50 .float kh_state = _STAT(KH_KEYS);
  51 .float siren_time;  //  time delay the siren
  52 //.float stuff_time;  //  time delay to stuffcmd a cvar
  53
  54 float kh_keystatus[17];
  55 //kh_keystatus[0] = status of dropped keys, kh_keystatus[1 - 16] = player #
  56 //replace 17 with cvar("maxplayers") or similar !!!!!!!!!
  57 //for(i = 0; i < maxplayers; ++i)
  58 //      kh_keystatus[i] = "0";
  59
  60 float kh_Team_ByID(float t)
  61 {
  62         if(t == 0) return NUM_TEAM_1;
  63         if(t == 1) return NUM_TEAM_2;
  64         if(t == 2) return NUM_TEAM_3;
  65         if(t == 3) return NUM_TEAM_4;
  66         return 0;
  67 }
  68
  69 //entity kh_worldkeylist;
  70 .entity kh_worldkeynext;
  71 entity kh_controller;
  72 //float kh_tracking_enabled;
  73 float kh_teams;
  74 float kh_interferemsg_time, kh_interferemsg_team;
  75 .entity kh_next, kh_prev; // linked list
  76 .float kh_droptime;
  77 .float kh_dropperteam;
  78 .entity kh_previous_owner;
  79 .float kh_previous_owner_playerid;
  80 .float kh_cp_duration;
  81
  82 float kh_key_dropped, kh_key_carried;
  83
  84 int kh_Key_AllOwnedByWhichTeam();
  85
  86 const float ST_KH_CAPS = 1;
  87 void kh_ScoreRules(int teams)
  88 {
  89         ScoreRules_basics(teams, SFL_SORT_PRIO_PRIMARY, SFL_SORT_PRIO_PRIMARY, true);
  90         ScoreInfo_SetLabel_TeamScore(  ST_KH_CAPS,      "caps",      SFL_SORT_PRIO_SECONDARY);
  91         ScoreInfo_SetLabel_PlayerScore(SP_KH_CAPS,      "caps",      SFL_SORT_PRIO_SECONDARY);
  92         ScoreInfo_SetLabel_PlayerScore(SP_KH_PUSHES,    "pushes",    0);
  93         ScoreInfo_SetLabel_PlayerScore(SP_KH_DESTROYS,  "destroyed", SFL_LOWER_IS_BETTER);
  94         ScoreInfo_SetLabel_PlayerScore(SP_KH_PICKUPS,   "pickups",   0);
  95         ScoreInfo_SetLabel_PlayerScore(SP_KH_KCKILLS,   "kckills",   0);
  96         ScoreInfo_SetLabel_PlayerScore(SP_KH_LOSSES,    "losses",    SFL_LOWER_IS_BETTER);
  97         ScoreRules_basics_end();
  98 }
  99
 100 bool kh_KeyCarrier_waypointsprite_visible_for_player(entity this, entity player, entity view)  // runs all the time
 101 {
 102         if(!IS_PLAYER(view) || DIFF_TEAM(this, view))
 103                 if(!kh_tracking_enabled)
 104                         return false;
 105
 106         return true;
 107 }
 108
 109 bool kh_Key_waypointsprite_visible_for_player(entity this, entity player, entity view)
 110 {
 111         if(!kh_tracking_enabled)
 112                 return false;
 113         if(!this.owner)
 114                 return true;
 115         if(!this.owner.owner)
 116                 return true;
 117         return false;  // draw only when key is not owned
 118 }
 119
 120 void kh_update_state()
 121 {
 122         entity key;
 123         float s;
 124         float f;
 125
 126         s = 0;
 127         FOR_EACH_KH_KEY(key)
 128         {
 129                 if(key.owner)
 130                         f = key.team;
 131                 else
 132                         f = 30;
 133                 s |= pow(32, key.count) * f;
 134         }
 135
 136         FOREACH_CLIENT(true, LAMBDA(it.kh_state = s));
 137
 138         FOR_EACH_KH_KEY(key)
 139         {
 140                 if(key.owner)
 141                         key.owner.kh_state |= pow(32, key.count) * 31;
 142         }
 143         //print(ftos((nextent(NULL)).kh_state), "\n");
 144 }
 145
 146
 147
 148
 149 var kh_Think_t kh_Controller_Thinkfunc;
 150 void kh_Controller_SetThink(float t, kh_Think_t func)  // runs occasionaly
 151 {
 152         kh_Controller_Thinkfunc = func;
 153         kh_controller.cnt = ceil(t);
 154         if(t == 0)
 155                 kh_controller.nextthink = time; // force
 156 }
 157 void kh_WaitForPlayers();
 158 void kh_Controller_Think(entity this)  // called a lot
 159 {
 160         if(intermission_running)
 161                 return;
 162         if(this.cnt > 0)
 163         { if(getthink(this) != kh_WaitForPlayers) { this.cnt -= 1; } }
 164         else if(this.cnt == 0)
 165         {
 166                 this.cnt -= 1;
 167                 kh_Controller_Thinkfunc();
 168         }
 169         this.nextthink = time + 1;
 170 }
 171
 172 // frags f: take from cvar * f
 173 // frags 0: no frags
 174 void kh_Scores_Event(entity player, entity key, string what, float frags_player, float frags_owner)  // update the score when a key is captured
 175 {
 176         string s;
 177         if(intermission_running)
 178                 return;
 179
 180         if(frags_player)
 181                 UpdateFrags(player, frags_player);
 182
 183         if(key && key.owner && frags_owner)
 184                 UpdateFrags(key.owner, frags_owner);
 185
 186         if(!autocvar_sv_eventlog)  //output extra info to the console or text file
 187                 return;
 188
 189         s = strcat(":keyhunt:", what, ":", ftos(player.playerid), ":", ftos(frags_player));
 190
 191         if(key && key.owner)
 192                 s = strcat(s, ":", ftos(key.owner.playerid));
 193         else
 194                 s = strcat(s, ":0");
 195
 196         s = strcat(s, ":", ftos(frags_owner), ":");
 197
 198         if(key)
 199                 s = strcat(s, key.netname);
 200
 201         GameLogEcho(s);
 202 }
 203
 204 vector kh_AttachedOrigin(entity e)  // runs when a team captures the flag, it can run 2 or 3 times.
 205 {
 206         if(e.tag_entity)
 207         {
 208                 makevectors(e.tag_entity.angles);
 209                 return e.tag_entity.origin + e.origin.x * v_forward - e.origin.y * v_right + e.origin.z * v_up;
 210         }
 211         else
 212                 return e.origin;
 213 }
 214
 215 void kh_Key_Attach(entity key)  // runs when a player picks up a key and several times when a key is assigned to a player at the start of a round
 216 {
 217 #ifdef KH_PLAYER_USE_ATTACHMENT
 218         entity first;
 219         first = key.owner.kh_next;
 220         if(key == first)
 221         {
 222                 setattachment(key, key.owner, KH_PLAYER_ATTACHMENT_BONE);
 223                 if(key.kh_next)
 224                 {
 225                         setattachment(key.kh_next, key, "");
 226                         setorigin(key, key.kh_next.origin - 0.5 * KH_PLAYER_ATTACHMENT_DIST);
 227                         setorigin(key.kh_next, KH_PLAYER_ATTACHMENT_DIST_ROTATED);
 228                         key.kh_next.angles = '0 0 0';
 229                 }
 230                 else
 231                         setorigin(key, KH_PLAYER_ATTACHMENT);
 232                 key.angles = KH_PLAYER_ATTACHMENT_ANGLES;
 233         }
 234         else
 235         {
 236                 setattachment(key, key.kh_prev, "");
 237                 if(key.kh_next)
 238                         setattachment(key.kh_next, key, "");
 239                 setorigin(key, KH_PLAYER_ATTACHMENT_DIST_ROTATED);
 240                 setorigin(first, first.origin - 0.5 * KH_PLAYER_ATTACHMENT_DIST);
 241                 key.angles = '0 0 0';
 242         }
 243 #else
 244         setattachment(key, key.owner, "");
 245         setorigin(key, '0 0 1' * KH_KEY_ZSHIFT);  // fixing x, y in think
 246         key.angles_y -= key.owner.angles.y;
 247 #endif
 248         key.flags = 0;
 249         IL_REMOVE(g_items, key);
 250         key.solid = SOLID_NOT;
 251         set_movetype(key, MOVETYPE_NONE);
 252         key.team = key.owner.team;
 253         key.nextthink = time;
 254         key.damageforcescale = 0;
 255         key.takedamage = DAMAGE_NO;
 256         key.modelindex = kh_key_carried;
 257 }
 258
 259 void kh_Key_Detach(entity key) // runs every time a key is dropped or lost. Runs several times times when all the keys are captured
 260 {
 261 #ifdef KH_PLAYER_USE_ATTACHMENT
 262         entity first;
 263         first = key.owner.kh_next;
 264         if(key == first)
 265         {
 266                 if(key.kh_next)
 267                 {
 268                         setattachment(key.kh_next, key.owner, KH_PLAYER_ATTACHMENT_BONE);
 269                         setorigin(key.kh_next, key.origin + 0.5 * KH_PLAYER_ATTACHMENT_DIST);
 270                         key.kh_next.angles = KH_PLAYER_ATTACHMENT_ANGLES;
 271                 }
 272         }
 273         else
 274         {
 275                 if(key.kh_next)
 276                         setattachment(key.kh_next, key.kh_prev, "");
 277                 setorigin(first, first.origin + 0.5 * KH_PLAYER_ATTACHMENT_DIST);
 278         }
 279         // in any case:
 280         setattachment(key, NULL, "");
 281         setorigin(key, key.owner.origin + '0 0 1' * (STAT(PL_MIN, NULL).z - KH_KEY_MIN_z));
 282         key.angles = key.owner.angles;
 283 #else
 284         setorigin(key, key.owner.origin + key.origin.z * '0 0 1');
 285         setattachment(key, NULL, "");
 286         key.angles_y += key.owner.angles.y;
 287 #endif
 288         key.flags = FL_ITEM;
 289         IL_PUSH(g_items, key);
 290         key.solid = SOLID_TRIGGER;
 291         set_movetype(key, MOVETYPE_TOSS);
 292         key.pain_finished = time + autocvar_g_balance_keyhunt_delay_return;
 293         key.damageforcescale = autocvar_g_balance_keyhunt_damageforcescale;
 294         key.takedamage = DAMAGE_YES;
 295         // let key.team stay
 296         key.modelindex = kh_key_dropped;
 297         key.kh_previous_owner = key.owner;
 298         key.kh_previous_owner_playerid = key.owner.playerid;
 299 }
 300
 301 void kh_Key_AssignTo(entity key, entity player)  // runs every time a key is picked up or assigned. Runs prior to kh_key_attach
 302 {
 303         entity k;
 304         float ownerteam0, ownerteam;
 305         if(key.owner == player)
 306                 return;
 307
 308         ownerteam0 = kh_Key_AllOwnedByWhichTeam();
 309
 310         if(key.owner)
 311         {
 312                 kh_Key_Detach(key);
 313
 314                 // remove from linked list
 315                 if(key.kh_next)
 316                         key.kh_next.kh_prev = key.kh_prev;
 317                 key.kh_prev.kh_next = key.kh_next;
 318                 key.kh_next = NULL;
 319                 key.kh_prev = NULL;
 320
 321                 if(key.owner.kh_next == NULL)
 322                 {
 323                         // No longer a key carrier
 324                         if(!kh_no_radar_circles)
 325                                 WaypointSprite_Ping(key.owner.waypointsprite_attachedforcarrier);
 326                         WaypointSprite_DetachCarrier(key.owner);
 327                 }
 328         }
 329
 330         key.owner = player;
 331
 332         if(player)
 333         {
 334                 // insert into linked list
 335                 key.kh_next = player.kh_next;
 336                 key.kh_prev = player;
 337                 player.kh_next = key;
 338                 if(key.kh_next)
 339                         key.kh_next.kh_prev = key;
 340
 341                 float i;
 342                 i = kh_keystatus[key.owner.playerid];
 343                         if(key.netname == "^1red key")
 344                                 i += 1;
 345                         if(key.netname == "^4blue key")
 346                                 i += 2;
 347                         if(key.netname == "^3yellow key")
 348                                 i += 4;
 349                         if(key.netname == "^6pink key")
 350                                 i += 8;
 351                 kh_keystatus[key.owner.playerid] = i;
 352
 353                 kh_Key_Attach(key);
 354
 355                 if(key.kh_next == NULL)
 356                 {
 357                         // player is now a key carrier
 358                         entity wp = WaypointSprite_AttachCarrier(WP_Null, player, RADARICON_FLAGCARRIER);
 359                         wp.colormod = colormapPaletteColor(player.team - 1, 0);
 360                         player.waypointsprite_attachedforcarrier.waypointsprite_visible_for_player = kh_KeyCarrier_waypointsprite_visible_for_player;
 361                         WaypointSprite_UpdateRule(player.waypointsprite_attachedforcarrier, player.team, SPRITERULE_TEAMPLAY);
 362                         if(player.team == NUM_TEAM_1)
 363                                 WaypointSprite_UpdateSprites(player.waypointsprite_attachedforcarrier, WP_KeyCarrierRed, WP_KeyCarrierFriend, WP_KeyCarrierRed);
 364                         else if(player.team == NUM_TEAM_2)
 365                                 WaypointSprite_UpdateSprites(player.waypointsprite_attachedforcarrier, WP_KeyCarrierBlue, WP_KeyCarrierFriend, WP_KeyCarrierBlue);
 366                         else if(player.team == NUM_TEAM_3)
 367                                 WaypointSprite_UpdateSprites(player.waypointsprite_attachedforcarrier, WP_KeyCarrierYellow, WP_KeyCarrierFriend, WP_KeyCarrierYellow);
 368                         else if(player.team == NUM_TEAM_4)
 369                                 WaypointSprite_UpdateSprites(player.waypointsprite_attachedforcarrier, WP_KeyCarrierPink, WP_KeyCarrierFriend, WP_KeyCarrierPink);
 370                         if(!kh_no_radar_circles)
 371                                 WaypointSprite_Ping(player.waypointsprite_attachedforcarrier);
 372                 }
 373         }
 374
 375         // moved that here, also update if there's no player
 376         kh_update_state();
 377
 378         key.pusher = NULL;
 379
 380         ownerteam = kh_Key_AllOwnedByWhichTeam();
 381         if(ownerteam != ownerteam0)
 382         {
 383                 if(ownerteam != -1)
 384                 {
 385                         kh_interferemsg_time = time + 0.2;
 386                         kh_interferemsg_team = player.team;
 387
 388                         // audit all key carrier sprites, update them to RUN HERE
 389                         FOR_EACH_KH_KEY(k)
 390                         {
 391                                 if (!k.owner) continue;
 392                                 entity first = WP_Null;
 393                                 FOREACH(Waypoints, it.netname == k.owner.waypointsprite_attachedforcarrier.model1, LAMBDA(first = it; break));
 394                                 entity third = WP_Null;
 395                                 FOREACH(Waypoints, it.netname == k.owner.waypointsprite_attachedforcarrier.model3, LAMBDA(third = it; break));
 396                                 WaypointSprite_UpdateSprites(k.owner.waypointsprite_attachedforcarrier, first, WP_KeyCarrierFinish, third);
 397                         }
 398                 }
 399                 else
 400                 {
 401                         kh_interferemsg_time = 0;
 402
 403                         // audit all key carrier sprites, update them to RUN HERE
 404                         FOR_EACH_KH_KEY(k)
 405                         {
 406                                 if (!k.owner) continue;
 407                                 entity first = WP_Null;
 408                                 FOREACH(Waypoints, it.netname == k.owner.waypointsprite_attachedforcarrier.model1, LAMBDA(first = it; break));
 409                                 entity third = WP_Null;
 410                                 FOREACH(Waypoints, it.netname == k.owner.waypointsprite_attachedforcarrier.model3, LAMBDA(third = it; break));
 411                                 WaypointSprite_UpdateSprites(k.owner.waypointsprite_attachedforcarrier, first, WP_KeyCarrierFriend, third);
 412                         }
 413                 }
 414         }
 415 }
 416
 417 void kh_Key_Damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
 418 {
 419         if(this.owner)
 420                 return;
 421         if(ITEM_DAMAGE_NEEDKILL(deathtype))
 422         {
 423                 // touching lava, or hurt trigger
 424                 // what shall we do?
 425                 // immediately return is bad
 426                 // maybe start a shorter countdown?
 427         }
 428         if(force == '0 0 0')
 429                 return;
 430         if(time > this.pushltime)
 431                 if(IS_PLAYER(attacker))
 432                         this.team = attacker.team;
 433 }
 434
 435 void kh_Key_Collect(entity key, entity player)  //a player picks up a dropped key
 436 {
 437         sound(player, CH_TRIGGER, SND_KH_COLLECT, VOL_BASE, ATTEN_NORM);
 438
 439         if(key.kh_dropperteam != player.team)
 440         {
 441                 kh_Scores_Event(player, key, "collect", autocvar_g_balance_keyhunt_score_collect, 0);
 442                 PlayerScore_Add(player, SP_KH_PICKUPS, 1);
 443         }
 444         key.kh_dropperteam = 0;
 445         Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(key.team, INFO_KEYHUNT_PICKUP), player.netname);
 446
 447         kh_Key_AssignTo(key, player); // this also updates .kh_state
 448 }
 449
 450 void kh_Key_Touch(entity this, entity toucher)  // runs many, many times when a key has been dropped and can be picked up
 451 {
 452         if(intermission_running)
 453                 return;
 454
 455         if(this.owner) // already carried
 456                 return;
 457
 458         if(ITEM_TOUCH_NEEDKILL())
 459         {
 460                 // touching sky, or nodrop
 461                 // what shall we do?
 462                 // immediately return is bad
 463                 // maybe start a shorter countdown?
 464         }
 465
 466         if (!IS_PLAYER(toucher))
 467                 return;
 468         if(IS_DEAD(toucher))
 469                 return;
 470         if(toucher == this.enemy)
 471                 if(time < this.kh_droptime + autocvar_g_balance_keyhunt_delay_collect)
 472                         return;  // you just dropped it!
 473         kh_Key_Collect(this, toucher);
 474 }
 475
 476 void kh_Key_Remove(entity key)  // runs after when all the keys have been collected or when a key has been dropped for more than X seconds
 477 {
 478         entity o;
 479         o = key.owner;
 480         kh_Key_AssignTo(key, NULL);
 481         if(o) // it was attached
 482                 WaypointSprite_Kill(key.waypointsprite_attachedforcarrier);
 483         else // it was dropped
 484                 WaypointSprite_DetachCarrier(key);
 485
 486         // remove key from key list
 487         if (kh_worldkeylist == key)
 488                 kh_worldkeylist = kh_worldkeylist.kh_worldkeynext;
 489         else
 490         {
 491                 o = kh_worldkeylist;
 492                 while (o)
 493                 {
 494                         if (o.kh_worldkeynext == key)
 495                         {
 496                                 o.kh_worldkeynext = o.kh_worldkeynext.kh_worldkeynext;
 497                                 break;
 498                         }
 499                         o = o.kh_worldkeynext;
 500                 }
 501         }
 502
 503         delete(key);
 504
 505         kh_update_state();
 506 }
 507
 508 void kh_FinishRound()  // runs when a team captures the keys
 509 {
 510         // prepare next round
 511         kh_interferemsg_time = 0;
 512         entity key;
 513
 514         kh_no_radar_circles = true;
 515         FOR_EACH_KH_KEY(key)
 516                 kh_Key_Remove(key);
 517         kh_no_radar_circles = false;
 518
 519         Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_KEYHUNT_ROUNDSTART, autocvar_g_balance_keyhunt_delay_round);
 520         kh_Controller_SetThink(autocvar_g_balance_keyhunt_delay_round, kh_StartRound);
 521 }
 522
 523 void nades_GiveBonus(entity player, float score);
 524
 525 void kh_WinnerTeam(float teem)  // runs when a team wins // Samual: Teem?.... TEEM?!?! what the fuck is wrong with you people
 526 {
 527         // all key carriers get some points
 528         vector firstorigin, lastorigin, midpoint;
 529         float first;
 530         entity key;
 531         float score;
 532         score = (NumTeams(kh_teams) - 1) * autocvar_g_balance_keyhunt_score_capture;
 533         DistributeEvenly_Init(score, NumTeams(kh_teams));
 534         // twice the score for 3 team games, three times the score for 4 team games!
 535         // note: for a win by destroying the key, this should NOT be applied
 536         FOR_EACH_KH_KEY(key)
 537         {
 538                 float f;
 539                 f = DistributeEvenly_Get(1);
 540                 kh_Scores_Event(key.owner, key, "capture", f, 0);
 541                 PlayerTeamScore_Add(key.owner, SP_KH_CAPS, ST_KH_CAPS, 1);
 542                 nades_GiveBonus(key.owner, autocvar_g_nades_bonus_score_high);
 543         }
 544
 545         first = true;
 546         string keyowner = "";
 547         FOR_EACH_KH_KEY(key)
 548                 if(key.owner.kh_next == key)
 549                 {
 550                         if(!first)
 551                                 keyowner = strcat(keyowner, ", ");
 552                         keyowner = key.owner.netname;
 553                         first = false;
 554                 }
 555
 556         Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(teem, INFO_KEYHUNT_CAPTURE), keyowner);
 557
 558         first = true;
 559         midpoint = '0 0 0';
 560         firstorigin = '0 0 0';
 561         lastorigin = '0 0 0';
 562         FOR_EACH_KH_KEY(key)
 563         {
 564                 vector thisorigin;
 565
 566                 thisorigin = kh_AttachedOrigin(key);
 567                 //dprint("Key origin: ", vtos(thisorigin), "\n");
 568                 midpoint += thisorigin;
 569
 570                 if(!first)
 571                         te_lightning2(NULL, lastorigin, thisorigin);
 572                 lastorigin = thisorigin;
 573                 if(first)
 574                         firstorigin = thisorigin;
 575                 first = false;
 576         }
 577         if(NumTeams(kh_teams) > 2)
 578         {
 579                 te_lightning2(NULL, lastorigin, firstorigin);
 580         }
 581         midpoint = midpoint * (1 / NumTeams(kh_teams));
 582         te_customflash(midpoint, 1000, 1, Team_ColorRGB(teem) * 0.5 + '0.5 0.5 0.5');  // make the color >=0.5 in each component
 583
 584         play2all(SND(KH_CAPTURE));
 585         kh_FinishRound();
 586 }
 587
 588 void kh_LoserTeam(float teem, entity lostkey)  // runs when a player pushes a flag carrier off the map
 589 {
 590         entity key, attacker;
 591         float players;
 592         float keys;
 593         float f;
 594
 595         attacker = NULL;
 596         if(lostkey.pusher)
 597                 if(lostkey.pusher.team != teem)
 598                         if(IS_PLAYER(lostkey.pusher))
 599                                 attacker = lostkey.pusher;
 600
 601         players = keys = 0;
 602
 603         if(attacker)
 604         {
 605                 if(lostkey.kh_previous_owner)
 606                         kh_Scores_Event(lostkey.kh_previous_owner, NULL, "pushed", 0, -autocvar_g_balance_keyhunt_score_push);
 607                         // don't actually GIVE him the -nn points, just log
 608                 kh_Scores_Event(attacker, NULL, "push", autocvar_g_balance_keyhunt_score_push, 0);
 609                 PlayerScore_Add(attacker, SP_KH_PUSHES, 1);
 610                 //centerprint(attacker, "Your push is the best!"); // does this really need to exist?
 611         }
 612         else
 613         {
 614                 float of, fragsleft, i, j, thisteam;
 615                 of = autocvar_g_balance_keyhunt_score_destroyed_ownfactor;
 616
 617                 FOREACH_CLIENT(IS_PLAYER(it) && it.team != teem, LAMBDA(++players));
 618
 619                 FOR_EACH_KH_KEY(key)
 620                         if(key.owner && key.team != teem)
 621                                 ++keys;
 622
 623                 if(lostkey.kh_previous_owner)
 624                         kh_Scores_Event(lostkey.kh_previous_owner, NULL, "destroyed", 0, -autocvar_g_balance_keyhunt_score_destroyed);
 625                         // don't actually GIVE him the -nn points, just log
 626
 627                 if(lostkey.kh_previous_owner.playerid == lostkey.kh_previous_owner_playerid)
 628                         PlayerScore_Add(lostkey.kh_previous_owner, SP_KH_DESTROYS, 1);
 629
 630                 DistributeEvenly_Init(autocvar_g_balance_keyhunt_score_destroyed, keys * of + players);
 631
 632                 FOR_EACH_KH_KEY(key)
 633                         if(key.owner && key.team != teem)
 634                         {
 635                                 f = DistributeEvenly_Get(of);
 636                                 kh_Scores_Event(key.owner, NULL, "destroyed_holdingkey", f, 0);
 637                         }
 638
 639                 fragsleft = DistributeEvenly_Get(players);
 640
 641                 // Now distribute these among all other teams...
 642                 j = NumTeams(kh_teams) - 1;
 643                 for(i = 0; i < NumTeams(kh_teams); ++i)
 644                 {
 645                         thisteam = kh_Team_ByID(i);
 646                         if(thisteam == teem) // bad boy, no cookie - this WILL happen
 647                                 continue;
 648
 649                         players = 0;
 650                         FOREACH_CLIENT(IS_PLAYER(it) && it.team == thisteam, LAMBDA(++players));
 651
 652                         DistributeEvenly_Init(fragsleft, j);
 653                         fragsleft = DistributeEvenly_Get(j - 1);
 654                         DistributeEvenly_Init(DistributeEvenly_Get(1), players);
 655
 656                         FOREACH_CLIENT(IS_PLAYER(it) && it.team == thisteam, LAMBDA(
 657                                 f = DistributeEvenly_Get(1);
 658                                 kh_Scores_Event(it, NULL, "destroyed", f, 0);
 659                         ));
 660
 661                         --j;
 662                 }
 663         }
 664
 665         Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(lostkey.team, INFO_KEYHUNT_LOST), lostkey.kh_previous_owner.netname);
 666
 667         play2all(SND(KH_DESTROY));
 668         te_tarexplosion(lostkey.origin);
 669
 670         kh_FinishRound();
 671 }
 672
 673 void kh_Key_Think(entity this)  // runs all the time
 674 {
 675         if(intermission_running)
 676                 return;
 677
 678         if(this.owner)
 679         {
 680 #ifndef KH_PLAYER_USE_ATTACHMENT
 681                 makevectors('0 1 0' * (this.cnt + (time % 360) * KH_KEY_XYSPEED));
 682                 setorigin(this, v_forward * KH_KEY_XYDIST + '0 0 1' * this.origin.z);
 683 #endif
 684         }
 685
 686         // if in nodrop or time over, end the round
 687         if(!this.owner)
 688                 if(time > this.pain_finished)
 689                         kh_LoserTeam(this.team, this);
 690
 691         if(this.owner)
 692         if(kh_Key_AllOwnedByWhichTeam() != -1)
 693         {
 694                 if(this.siren_time < time)
 695                 {
 696                         sound(this.owner, CH_TRIGGER, SND_KH_ALARM, VOL_BASE, ATTEN_NORM);  // play a simple alarm
 697                         this.siren_time = time + 2.5;  // repeat every 2.5 seconds
 698                 }
 699
 700                 entity key;
 701                 vector p;
 702                 p = this.owner.origin;
 703                 FOR_EACH_KH_KEY(key)
 704                         if(vdist(key.owner.origin - p, >, autocvar_g_balance_keyhunt_maxdist))
 705                                 goto not_winning;
 706                 kh_WinnerTeam(this.team);
 707 LABEL(not_winning)
 708         }
 709
 710         if(kh_interferemsg_time && time > kh_interferemsg_time)
 711         {
 712                 kh_interferemsg_time = 0;
 713                 FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(
 714                         if(it.team == kh_interferemsg_team)
 715                                 if(it.kh_next)
 716                                         Send_Notification(NOTIF_ONE, it, MSG_CENTER, CENTER_KEYHUNT_MEET);
 717                                 else
 718                                         Send_Notification(NOTIF_ONE, it, MSG_CENTER, CENTER_KEYHUNT_HELP);
 719                         else
 720                                 Send_Notification(NOTIF_ONE, it, MSG_CENTER, APP_TEAM_NUM(kh_interferemsg_team, CENTER_KEYHUNT_INTERFERE));
 721                 ));
 722         }
 723
 724         this.nextthink = time + 0.05;
 725 }
 726
 727 void key_reset(entity this)
 728 {
 729         kh_Key_AssignTo(this, NULL);
 730         kh_Key_Remove(this);
 731 }
 732
 733 const string STR_ITEM_KH_KEY = "item_kh_key";
 734 void kh_Key_Spawn(entity initial_owner, float _angle, float i)  // runs every time a new flag is created, ie after all the keys have been collected
 735 {
 736         entity key = spawn();
 737         key.count = i;
 738         key.classname = STR_ITEM_KH_KEY;
 739         settouch(key, kh_Key_Touch);
 740         setthink(key, kh_Key_Think);
 741         key.nextthink = time;
 742         key.items = IT_KEY1 | IT_KEY2;
 743         key.cnt = _angle;
 744         key.angles = '0 360 0' * random();
 745         key.event_damage = kh_Key_Damage;
 746         key.takedamage = DAMAGE_YES;
 747         key.modelindex = kh_key_dropped;
 748         key.model = "key";
 749         key.kh_dropperteam = 0;
 750         key.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_PLAYERCLIP | DPCONTENTS_BOTCLIP;
 751         setsize(key, KH_KEY_MIN, KH_KEY_MAX);
 752         key.colormod = Team_ColorRGB(initial_owner.team) * KH_KEY_BRIGHTNESS;
 753         key.reset = key_reset;
 754
 755         switch(initial_owner.team)
 756         {
 757                 case NUM_TEAM_1:
 758                         key.netname = "^1red key";
 759                         break;
 760                 case NUM_TEAM_2:
 761                         key.netname = "^4blue key";
 762                         break;
 763                 case NUM_TEAM_3:
 764                         key.netname = "^3yellow key";
 765                         break;
 766                 case NUM_TEAM_4:
 767                         key.netname = "^6pink key";
 768                         break;
 769                 default:
 770                         key.netname = "NETGIER key";
 771                         break;
 772         }
 773
 774         // link into key list
 775         key.kh_worldkeynext = kh_worldkeylist;
 776         kh_worldkeylist = key;
 777
 778         Send_Notification(NOTIF_ONE, initial_owner, MSG_CENTER, APP_TEAM_NUM(initial_owner.team, CENTER_KEYHUNT_START));
 779
 780         WaypointSprite_Spawn(WP_KeyDropped, 0, 0, key, '0 0 1' * KH_KEY_WP_ZSHIFT, NULL, key.team, key, waypointsprite_attachedforcarrier, false, RADARICON_FLAG);
 781         key.waypointsprite_attachedforcarrier.waypointsprite_visible_for_player = kh_Key_waypointsprite_visible_for_player;
 782
 783         kh_Key_AssignTo(key, initial_owner);
 784 }
 785
 786 // -1 when no team completely owns all keys yet
 787 int kh_Key_AllOwnedByWhichTeam()  // constantly called. check to see if all the keys are owned by the same team
 788 {
 789         entity key;
 790         int teem = -1;
 791         int keys = NumTeams(kh_teams);
 792         FOR_EACH_KH_KEY(key)
 793         {
 794                 if(!key.owner)
 795                         return -1;
 796                 if(teem == -1)
 797                         teem = key.team;
 798                 else if(teem != key.team)
 799                         return -1;
 800                 --keys;
 801         }
 802         if(keys != 0)
 803                 return -1;
 804         return teem;
 805 }
 806
 807 void kh_Key_DropOne(entity key)
 808 {
 809         // prevent collecting this one for some time
 810         entity player;
 811         player = key.owner;
 812
 813         key.kh_droptime = time;
 814         key.enemy = player;
 815
 816         kh_Scores_Event(player, key, "dropkey", 0, 0);
 817         PlayerScore_Add(player, SP_KH_LOSSES, 1);
 818         Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(key.team, INFO_KEYHUNT_DROP), player.netname);
 819
 820         kh_Key_AssignTo(key, NULL);
 821         makevectors(player.v_angle);
 822         key.velocity = W_CalculateProjectileVelocity(player, player.velocity, autocvar_g_balance_keyhunt_throwvelocity * v_forward, false);
 823         key.pusher = NULL;
 824         key.pushltime = time + autocvar_g_balance_keyhunt_protecttime;
 825         key.kh_dropperteam = key.team;
 826
 827         sound(player, CH_TRIGGER, SND_KH_DROP, VOL_BASE, ATTEN_NORM);
 828 }
 829
 830 void kh_Key_DropAll(entity player, float suicide) // runs whenever a player dies
 831 {
 832         entity key;
 833         entity mypusher;
 834         if(player.kh_next)
 835         {
 836                 mypusher = NULL;
 837                 if(player.pusher)
 838                         if(time < player.pushltime)
 839                                 mypusher = player.pusher;
 840                 while((key = player.kh_next))
 841                 {
 842                         kh_Scores_Event(player, key, "losekey", 0, 0);
 843                         PlayerScore_Add(player, SP_KH_LOSSES, 1);
 844                         Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(key.team, INFO_KEYHUNT_LOST), player.netname);
 845                         kh_Key_AssignTo(key, NULL);
 846                         makevectors('-1 0 0' * (45 + 45 * random()) + '0 360 0' * random());
 847                         key.velocity = W_CalculateProjectileVelocity(player, player.velocity, autocvar_g_balance_keyhunt_dropvelocity * v_forward, false);
 848                         key.pusher = mypusher;
 849                         key.pushltime = time + autocvar_g_balance_keyhunt_protecttime;
 850                         if(suicide)
 851                                 key.kh_dropperteam = player.team;
 852                 }
 853                 sound(player, CH_TRIGGER, SND_KH_DROP, VOL_BASE, ATTEN_NORM);
 854         }
 855 }
 856
 857 int kh_GetMissingTeams()
 858 {
 859         int missing_teams = 0;
 860         for(int i = 0; i < NumTeams(kh_teams); ++i)
 861         {
 862                 int teem = kh_Team_ByID(i);
 863                 int players = 0;
 864                 FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(
 865                         if(!IS_DEAD(it) && !PHYS_INPUT_BUTTON_CHAT(it) && it.team == teem)
 866                                 ++players;
 867                 ));
 868                 if (!players)
 869                         missing_teams |= pow(2, i);
 870         }
 871         return missing_teams;
 872 }
 873
 874 void kh_WaitForPlayers()  // delay start of the round until enough players are present
 875 {
 876         if(time < game_starttime)
 877         {
 878                 kh_Controller_SetThink(game_starttime - time + 0.1, kh_WaitForPlayers);
 879                 return;
 880         }
 881
 882         static int prev_missing_teams_mask;
 883         int missing_teams_mask = kh_GetMissingTeams();
 884         if(!missing_teams_mask)
 885         {
 886                 if(prev_missing_teams_mask > 0)
 887                         Kill_Notification(NOTIF_ALL, NULL, MSG_CENTER, CPID_MISSING_TEAMS);
 888                 prev_missing_teams_mask = -1;
 889                 Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_KEYHUNT_ROUNDSTART, autocvar_g_balance_keyhunt_delay_round);
 890                 kh_Controller_SetThink(autocvar_g_balance_keyhunt_delay_round, kh_StartRound);
 891         }
 892         else
 893         {
 894                 if(player_count == 0)
 895                 {
 896                         if(prev_missing_teams_mask > 0)
 897                                 Kill_Notification(NOTIF_ALL, NULL, MSG_CENTER, CPID_MISSING_TEAMS);
 898                         prev_missing_teams_mask = -1;
 899                 }
 900                 else
 901                 {
 902                         if(prev_missing_teams_mask != missing_teams_mask)
 903                         {
 904                                 Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_MISSING_TEAMS, missing_teams_mask);
 905                                 prev_missing_teams_mask = missing_teams_mask;
 906                         }
 907                 }
 908                 kh_Controller_SetThink(1, kh_WaitForPlayers);
 909         }
 910 }
 911
 912 void kh_EnableTrackingDevice()  // runs after each round
 913 {
 914         Kill_Notification(NOTIF_ALL, NULL, MSG_CENTER, CPID_KEYHUNT);
 915         Kill_Notification(NOTIF_ALL, NULL, MSG_CENTER, CPID_KEYHUNT_OTHER);
 916
 917         kh_tracking_enabled = true;
 918 }
 919
 920 void kh_StartRound()  // runs at the start of each round
 921 {
 922         int i, players, teem;
 923
 924         if(time < game_starttime)
 925         {
 926                 kh_Controller_SetThink(game_starttime - time + 0.1, kh_WaitForPlayers);
 927                 return;
 928         }
 929
 930         if(kh_GetMissingTeams())
 931         {
 932                 kh_Controller_SetThink(1, kh_WaitForPlayers);
 933                 return;
 934         }
 935
 936         Kill_Notification(NOTIF_ALL, NULL, MSG_CENTER, CPID_KEYHUNT);
 937         Kill_Notification(NOTIF_ALL, NULL, MSG_CENTER, CPID_KEYHUNT_OTHER);
 938
 939         for(i = 0; i < NumTeams(kh_teams); ++i)
 940         {
 941                 teem = kh_Team_ByID(i);
 942                 players = 0;
 943                 entity my_player = NULL;
 944                 FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(
 945                         if(!IS_DEAD(it) && !PHYS_INPUT_BUTTON_CHAT(it) && it.team == teem)
 946                         {
 947                                 ++players;
 948                                 if(random() * players <= 1)
 949                                         my_player = it;
 950                         }
 951                 ));
 952                 kh_Key_Spawn(my_player, 360 * i / NumTeams(kh_teams), i);
 953         }
 954
 955         kh_tracking_enabled = false;
 956         Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_KEYHUNT_SCAN, autocvar_g_balance_keyhunt_delay_tracking);
 957         kh_Controller_SetThink(autocvar_g_balance_keyhunt_delay_tracking, kh_EnableTrackingDevice);
 958 }
 959
 960 float kh_HandleFrags(entity attacker, entity targ, float f)  // adds to the player score
 961 {
 962         if(attacker == targ)
 963                 return f;
 964
 965         if(targ.kh_next)
 966         {
 967                 if(attacker.team == targ.team)
 968                 {
 969                         entity k;
 970                         float nk;
 971                         nk = 0;
 972                         for(k = targ.kh_next; k != NULL; k = k.kh_next)
 973                                 ++nk;
 974                         kh_Scores_Event(attacker, targ.kh_next, "carrierfrag", -nk * autocvar_g_balance_keyhunt_score_collect, 0);
 975                 }
 976                 else
 977                 {
 978                         kh_Scores_Event(attacker, targ.kh_next, "carrierfrag", autocvar_g_balance_keyhunt_score_carrierfrag-1, 0);
 979                         PlayerScore_Add(attacker, SP_KH_KCKILLS, 1);
 980                         // the frag gets added later
 981                 }
 982         }
 983
 984         return f;
 985 }
 986
 987 void kh_Initialize()  // sets up th KH environment
 988 {
 989         // setup variables
 990         kh_teams = autocvar_g_keyhunt_teams_override;
 991         if(kh_teams < 2)
 992                 kh_teams = autocvar_g_keyhunt_teams;
 993         kh_teams = bound(2, kh_teams, 4);
 994
 995         int teams = 0;
 996         if(kh_teams >= 1) teams |= BIT(0);
 997         if(kh_teams >= 2) teams |= BIT(1);
 998         if(kh_teams >= 3) teams |= BIT(2);
 999         if(kh_teams >= 4) teams |= BIT(3);
1000
1001         kh_teams = teams; // now set it?
1002
1003         // make a KH entity for controlling the game
1004         kh_controller = spawn();
1005         setthink(kh_controller, kh_Controller_Think);
1006         kh_Controller_SetThink(0, kh_WaitForPlayers);
1007
1008         setmodel(kh_controller, MDL_KH_KEY);
1009         kh_key_dropped = kh_controller.modelindex;
1010         /*
1011         dprint(vtos(kh_controller.mins));
1012         dprint(vtos(kh_controller.maxs));
1013         dprint("\n");
1014         */
1015 #ifdef KH_PLAYER_USE_CARRIEDMODEL
1016         setmodel(kh_controller, MDL_KH_KEY_CARRIED);
1017         kh_key_carried = kh_controller.modelindex;
1018 #else
1019         kh_key_carried = kh_key_dropped;
1020 #endif
1021
1022         kh_controller.model = "";
1023         kh_controller.modelindex = 0;
1024
1025         kh_ScoreRules(kh_teams);
1026 }
1027
1028 void kh_finalize()
1029 {
1030         // to be called before intermission
1031         kh_FinishRound();
1032         delete(kh_controller);
1033         kh_controller = NULL;
1034 }
1035
1036 // legacy bot role
1037
1038 void(entity this) havocbot_role_kh_carrier;
1039 void(entity this) havocbot_role_kh_defense;
1040 void(entity this) havocbot_role_kh_offense;
1041 void(entity this) havocbot_role_kh_freelancer;
1042
1043
1044 void havocbot_goalrating_kh(entity this, float ratingscale_team, float ratingscale_dropped, float ratingscale_enemy)
1045 {
1046         entity head;
1047         for (head = kh_worldkeylist; head; head = head.kh_worldkeynext)
1048         {
1049                 if(head.owner == this)
1050                         continue;
1051                 if(!kh_tracking_enabled)
1052                 {
1053                         // if it's carried by our team we know about it
1054                         // otherwise we have to see it to know about it
1055                         if(!head.owner || head.team != this.team)
1056                         {
1057                                 traceline(this.origin + this.view_ofs, head.origin, MOVE_NOMONSTERS, this);
1058                                 if (trace_fraction < 1 && trace_ent != head)
1059                                         continue; // skip what I can't see
1060                         }
1061                 }
1062                 if(!head.owner)
1063                         navigation_routerating(this, head, ratingscale_dropped * BOT_PICKUP_RATING_HIGH, 100000);
1064                 else if(head.team == this.team)
1065                         navigation_routerating(this, head.owner, ratingscale_team * BOT_PICKUP_RATING_HIGH, 100000);
1066                 else
1067                         navigation_routerating(this, head.owner, ratingscale_enemy * BOT_PICKUP_RATING_HIGH, 100000);
1068         }
1069
1070         havocbot_goalrating_items(this, 1, this.origin, 10000);
1071 }
1072
1073 void havocbot_role_kh_carrier(entity this)
1074 {
1075         if(IS_DEAD(this))
1076                 return;
1077
1078         if (!(this.kh_next))
1079         {
1080                 LOG_TRACE("changing role to freelancer");
1081                 this.havocbot_role = havocbot_role_kh_freelancer;
1082                 this.havocbot_role_timeout = 0;
1083                 return;
1084         }
1085
1086         if (this.bot_strategytime < time)
1087         {
1088                 this.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1089                 navigation_goalrating_start(this);
1090
1091                 if(kh_Key_AllOwnedByWhichTeam() == this.team)
1092                         havocbot_goalrating_kh(this, 10, 0.1, 0.1); // bring home
1093                 else
1094                         havocbot_goalrating_kh(this, 4, 4, 1); // play defensively
1095
1096                 navigation_goalrating_end(this);
1097         }
1098 }
1099
1100 void havocbot_role_kh_defense(entity this)
1101 {
1102         if(IS_DEAD(this))
1103                 return;
1104
1105         if (this.kh_next)
1106         {
1107                 LOG_TRACE("changing role to carrier");
1108                 this.havocbot_role = havocbot_role_kh_carrier;
1109                 this.havocbot_role_timeout = 0;
1110                 return;
1111         }
1112
1113         if (!this.havocbot_role_timeout)
1114                 this.havocbot_role_timeout = time + random() * 10 + 20;
1115         if (time > this.havocbot_role_timeout)
1116         {
1117                 LOG_TRACE("changing role to freelancer");
1118                 this.havocbot_role = havocbot_role_kh_freelancer;
1119                 this.havocbot_role_timeout = 0;
1120                 return;
1121         }
1122
1123         if (this.bot_strategytime < time)
1124         {
1125                 float key_owner_team;
1126                 this.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1127                 navigation_goalrating_start(this);
1128
1129                 key_owner_team = kh_Key_AllOwnedByWhichTeam();
1130                 if(key_owner_team == this.team)
1131                         havocbot_goalrating_kh(this, 10, 0.1, 0.1); // defend key carriers
1132                 else if(key_owner_team == -1)
1133                         havocbot_goalrating_kh(this, 4, 1, 0.1); // play defensively
1134                 else
1135                         havocbot_goalrating_kh(this, 0.1, 0.1, 10); // ATTACK ANYWAY
1136
1137                 navigation_goalrating_end(this);
1138         }
1139 }
1140
1141 void havocbot_role_kh_offense(entity this)
1142 {
1143         if(IS_DEAD(this))
1144                 return;
1145
1146         if (this.kh_next)
1147         {
1148                 LOG_TRACE("changing role to carrier");
1149                 this.havocbot_role = havocbot_role_kh_carrier;
1150                 this.havocbot_role_timeout = 0;
1151                 return;
1152         }
1153
1154         if (!this.havocbot_role_timeout)
1155                 this.havocbot_role_timeout = time + random() * 10 + 20;
1156         if (time > this.havocbot_role_timeout)
1157         {
1158                 LOG_TRACE("changing role to freelancer");
1159                 this.havocbot_role = havocbot_role_kh_freelancer;
1160                 this.havocbot_role_timeout = 0;
1161                 return;
1162         }
1163
1164         if (this.bot_strategytime < time)
1165         {
1166                 float key_owner_team;
1167
1168                 this.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1169                 navigation_goalrating_start(this);
1170
1171                 key_owner_team = kh_Key_AllOwnedByWhichTeam();
1172                 if(key_owner_team == this.team)
1173                         havocbot_goalrating_kh(this, 10, 0.1, 0.1); // defend anyway
1174                 else if(key_owner_team == -1)
1175                         havocbot_goalrating_kh(this, 0.1, 1, 4); // play offensively
1176                 else
1177                         havocbot_goalrating_kh(this, 0.1, 0.1, 10); // ATTACK! EMERGENCY!
1178
1179                 navigation_goalrating_end(this);
1180         }
1181 }
1182
1183 void havocbot_role_kh_freelancer(entity this)
1184 {
1185         if(IS_DEAD(this))
1186                 return;
1187
1188         if (this.kh_next)
1189         {
1190                 LOG_TRACE("changing role to carrier");
1191                 this.havocbot_role = havocbot_role_kh_carrier;
1192                 this.havocbot_role_timeout = 0;
1193                 return;
1194         }
1195
1196         if (!this.havocbot_role_timeout)
1197                 this.havocbot_role_timeout = time + random() * 10 + 10;
1198         if (time > this.havocbot_role_timeout)
1199         {
1200                 if (random() < 0.5)
1201                 {
1202                         LOG_TRACE("changing role to offense");
1203                         this.havocbot_role = havocbot_role_kh_offense;
1204                 }
1205                 else
1206                 {
1207                         LOG_TRACE("changing role to defense");
1208                         this.havocbot_role = havocbot_role_kh_defense;
1209                 }
1210                 this.havocbot_role_timeout = 0;
1211                 return;
1212         }
1213
1214         if (this.bot_strategytime < time)
1215         {
1216                 float key_owner_team;
1217
1218                 this.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1219                 navigation_goalrating_start(this);
1220
1221                 key_owner_team = kh_Key_AllOwnedByWhichTeam();
1222                 if(key_owner_team == this.team)
1223                         havocbot_goalrating_kh(this, 10, 0.1, 0.1); // defend anyway
1224                 else if(key_owner_team == -1)
1225                         havocbot_goalrating_kh(this, 1, 10, 4); // prefer dropped keys
1226                 else
1227                         havocbot_goalrating_kh(this, 0.1, 0.1, 10); // ATTACK ANYWAY
1228
1229                 navigation_goalrating_end(this);
1230         }
1231 }
1232
1233
1234 // register this as a mutator
1235
1236 MUTATOR_HOOKFUNCTION(kh, ClientDisconnect)
1237 {
1238         entity player = M_ARGV(0, entity);
1239
1240         kh_Key_DropAll(player, true);
1241 }
1242
1243 MUTATOR_HOOKFUNCTION(kh, MakePlayerObserver)
1244 {
1245         entity player = M_ARGV(0, entity);
1246
1247         kh_Key_DropAll(player, true);
1248 }
1249
1250 MUTATOR_HOOKFUNCTION(kh, PlayerDies)
1251 {
1252         entity frag_attacker = M_ARGV(1, entity);
1253         entity frag_target = M_ARGV(2, entity);
1254
1255         if(frag_target == frag_attacker)
1256                 kh_Key_DropAll(frag_target, true);
1257         else if(IS_PLAYER(frag_attacker))
1258                 kh_Key_DropAll(frag_target, false);
1259         else
1260                 kh_Key_DropAll(frag_target, true);
1261 }
1262
1263 MUTATOR_HOOKFUNCTION(kh, GiveFragsForKill, CBC_ORDER_FIRST)
1264 {
1265         entity frag_attacker = M_ARGV(0, entity);
1266         entity frag_target = M_ARGV(1, entity);
1267         float frag_score = M_ARGV(2, float);
1268         M_ARGV(2, float) = kh_HandleFrags(frag_attacker, frag_target, frag_score);
1269 }
1270
1271 MUTATOR_HOOKFUNCTION(kh, MatchEnd)
1272 {
1273         kh_finalize();
1274 }
1275
1276 MUTATOR_HOOKFUNCTION(kh, GetTeamCount, CBC_ORDER_EXCLUSIVE)
1277 {
1278         M_ARGV(0, float) = kh_teams;
1279 }
1280
1281 MUTATOR_HOOKFUNCTION(kh, SpectateCopy)
1282 {
1283         entity spectatee = M_ARGV(0, entity);
1284         entity client = M_ARGV(1, entity);
1285
1286         client.kh_state = spectatee.kh_state;
1287 }
1288
1289 MUTATOR_HOOKFUNCTION(kh, PlayerUseKey)
1290 {
1291         entity player = M_ARGV(0, entity);
1292
1293         if(MUTATOR_RETURNVALUE == 0)
1294         {
1295                 entity k = player.kh_next;
1296                 if(k)
1297                 {
1298                         kh_Key_DropOne(k);
1299                         return true;
1300                 }
1301         }
1302 }
1303
1304 MUTATOR_HOOKFUNCTION(kh, HavocBot_ChooseRole)
1305 {
1306     entity bot = M_ARGV(0, entity);
1307
1308         if(IS_DEAD(bot))
1309                 return true;
1310
1311         float r = random() * 3;
1312         if (r < 1)
1313                 bot.havocbot_role = havocbot_role_kh_offense;
1314         else if (r < 2)
1315                 bot.havocbot_role = havocbot_role_kh_defense;
1316         else
1317                 bot.havocbot_role = havocbot_role_kh_freelancer;
1318
1319         return true;
1320 }
1321
1322 MUTATOR_HOOKFUNCTION(kh, DropSpecialItems)
1323 {
1324         entity frag_target = M_ARGV(0, entity);
1325
1326         kh_Key_DropAll(frag_target, false);
1327 }
1328
1329 MUTATOR_HOOKFUNCTION(kh, reset_map_global)
1330 {
1331         kh_Controller_SetThink(autocvar_g_balance_keyhunt_delay_round + (game_starttime - time), kh_StartRound);
1332 }