qcsrc/server/mutators/mutator/gamemode_keyhunt.qc

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