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() 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 = _STAT(KH_KEYS);
 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(entity this)
 797 {
 798         kh_Key_AssignTo(this, world);
 799         kh_Key_Remove(this);
 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 = spawn();
 806         key.count = i;
 807         key.classname = STR_ITEM_KH_KEY;
 808         key.touch = kh_Key_Touch;
 809         key.think = kh_Key_Think;
 810         key.nextthink = time;
 811         key.items = IT_KEY1 | IT_KEY2;
 812         key.cnt = _angle;
 813         key.angles = '0 360 0' * random();
 814         key.event_damage = kh_Key_Damage;
 815         key.takedamage = DAMAGE_YES;
 816         key.modelindex = kh_key_dropped;
 817         key.model = "key";
 818         key.kh_dropperteam = 0;
 819         key.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_PLAYERCLIP | DPCONTENTS_BOTCLIP;
 820         setsize(key, KH_KEY_MIN, KH_KEY_MAX);
 821         key.colormod = Team_ColorRGB(initial_owner.team) * KH_KEY_BRIGHTNESS;
 822         key.reset = key_reset;
 823
 824         switch(initial_owner.team)
 825         {
 826                 case NUM_TEAM_1:
 827                         key.netname = "^1red key";
 828                         break;
 829                 case NUM_TEAM_2:
 830                         key.netname = "^4blue key";
 831                         break;
 832                 case NUM_TEAM_3:
 833                         key.netname = "^3yellow key";
 834                         break;
 835                 case NUM_TEAM_4:
 836                         key.netname = "^6pink key";
 837                         break;
 838                 default:
 839                         key.netname = "NETGIER key";
 840                         break;
 841         }
 842
 843         // link into key list
 844         key.kh_worldkeynext = kh_worldkeylist;
 845         kh_worldkeylist = key;
 846
 847         Send_Notification(NOTIF_ONE, initial_owner, MSG_CENTER, APP_TEAM_NUM_4(initial_owner.team, CENTER_KEYHUNT_START_));
 848
 849         WaypointSprite_Spawn(WP_KeyDropped, 0, 0, key, '0 0 1' * KH_KEY_WP_ZSHIFT, world, key.team, key, waypointsprite_attachedforcarrier, false, RADARICON_FLAG);
 850         key.waypointsprite_attachedforcarrier.waypointsprite_visible_for_player = kh_Key_waypointsprite_visible_for_player;
 851
 852         kh_Key_AssignTo(key, initial_owner);
 853 }
 854
 855 // -1 when no team completely owns all keys yet
 856 float kh_Key_AllOwnedByWhichTeam()  // constantly called. check to see if all the keys are owned by the same team
 857 {
 858         entity key;
 859         float teem;
 860         float keys;
 861
 862         teem = -1;
 863         keys = kh_teams;
 864         FOR_EACH_KH_KEY(key)
 865         {
 866                 if(!key.owner)
 867                         return -1;
 868                 if(teem == -1)
 869                         teem = key.team;
 870                 else if(teem != key.team)
 871                         return -1;
 872                 --keys;
 873         }
 874         if(keys != 0)
 875                 return -1;
 876         return teem;
 877 }
 878
 879 void kh_Key_DropOne(entity key)
 880 {
 881         // prevent collecting this one for some time
 882         entity player;
 883         player = key.owner;
 884
 885         key.kh_droptime = time;
 886         key.enemy = player;
 887
 888         kh_Scores_Event(player, key, "dropkey", 0, 0);
 889         PlayerScore_Add(player, SP_KH_LOSSES, 1);
 890         Send_Notification(NOTIF_ALL, world, MSG_INFO, APP_TEAM_ENT_4(key, INFO_KEYHUNT_DROP_), player.netname);
 891
 892         kh_Key_AssignTo(key, world);
 893         makevectors(player.v_angle);
 894         key.velocity = W_CalculateProjectileVelocity(player.velocity, autocvar_g_balance_keyhunt_throwvelocity * v_forward, false);
 895         key.pusher = world;
 896         key.pushltime = time + autocvar_g_balance_keyhunt_protecttime;
 897         key.kh_dropperteam = key.team;
 898
 899         sound(player, CH_TRIGGER, SND_KH_DROP, VOL_BASE, ATTEN_NORM);
 900 }
 901
 902 void kh_Key_DropAll(entity player, float suicide) // runs whenever a player dies
 903 {
 904         entity key;
 905         entity mypusher;
 906         if(player.kh_next)
 907         {
 908                 mypusher = world;
 909                 if(player.pusher)
 910                         if(time < player.pushltime)
 911                                 mypusher = player.pusher;
 912                 while((key = player.kh_next))
 913                 {
 914                         kh_Scores_Event(player, key, "losekey", 0, 0);
 915                         PlayerScore_Add(player, SP_KH_LOSSES, 1);
 916                         Send_Notification(NOTIF_ALL, world, MSG_INFO, APP_TEAM_ENT_4(key, INFO_KEYHUNT_LOST_), player.netname);
 917                         kh_Key_AssignTo(key, world);
 918                         makevectors('-1 0 0' * (45 + 45 * random()) + '0 360 0' * random());
 919                         key.velocity = W_CalculateProjectileVelocity(player.velocity, autocvar_g_balance_keyhunt_dropvelocity * v_forward, false);
 920                         key.pusher = mypusher;
 921                         key.pushltime = time + autocvar_g_balance_keyhunt_protecttime;
 922                         if(suicide)
 923                                 key.kh_dropperteam = player.team;
 924                 }
 925                 sound(player, CH_TRIGGER, SND_KH_DROP, VOL_BASE, ATTEN_NORM);
 926         }
 927 }
 928
 929 float kh_CheckPlayers(float num)
 930 {
 931         if(num < kh_teams)
 932         {
 933                 float t_team = kh_Team_ByID(num);
 934                 float players = 0;
 935                 entity tmp_player;
 936                 FOR_EACH_PLAYER(tmp_player)
 937                         if(tmp_player.deadflag == DEAD_NO)
 938                                 if(!tmp_player.BUTTON_CHAT)
 939                                         if(tmp_player.team == t_team)
 940                                                 ++players;
 941
 942                 if (!players) { return t_team; }
 943         }
 944         return 0;
 945 }
 946
 947 #define KH_READY_TEAMS() (!p1 + !p2 + ((kh_teams >= 3) ? !p3 : p3) + ((kh_teams >= 4) ? !p4 : p4))
 948 #define KH_READY_TEAMS_OK() (KH_READY_TEAMS() == kh_teams)
 949 void kh_WaitForPlayers()  // delay start of the round until enough players are present
 950 {
 951         if(time < game_starttime)
 952         {
 953                 kh_Controller_SetThink(game_starttime - time + 0.1, kh_WaitForPlayers);
 954                 return;
 955         }
 956
 957         static float prev_missing_teams_mask;
 958         float p1 = kh_CheckPlayers(0), p2 = kh_CheckPlayers(1), p3 = kh_CheckPlayers(2), p4 = kh_CheckPlayers(3);
 959         if(KH_READY_TEAMS_OK())
 960         {
 961                 if(prev_missing_teams_mask > 0)
 962                         Kill_Notification(NOTIF_ALL, world, MSG_CENTER_CPID, CPID_MISSING_TEAMS);
 963                 prev_missing_teams_mask = -1;
 964                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_KEYHUNT_ROUNDSTART, autocvar_g_balance_keyhunt_delay_round);
 965                 kh_Controller_SetThink(autocvar_g_balance_keyhunt_delay_round, kh_StartRound);
 966         }
 967         else
 968         {
 969                 if(player_count == 0)
 970                 {
 971                         if(prev_missing_teams_mask > 0)
 972                                 Kill_Notification(NOTIF_ALL, world, MSG_CENTER_CPID, CPID_MISSING_TEAMS);
 973                         prev_missing_teams_mask = -1;
 974                 }
 975                 else
 976                 {
 977                         float missing_teams_mask = boolean(p1) + boolean(p2) * 2;
 978                         if(kh_teams >= 3) missing_teams_mask += boolean(p3) * 4;
 979                         if(kh_teams >= 4) missing_teams_mask += boolean(p4) * 8;
 980                         if(prev_missing_teams_mask != missing_teams_mask)
 981                         {
 982                                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_MISSING_TEAMS, missing_teams_mask);
 983                                 prev_missing_teams_mask = missing_teams_mask;
 984                         }
 985                 }
 986                 kh_Controller_SetThink(1, kh_WaitForPlayers);
 987         }
 988 }
 989
 990 void kh_EnableTrackingDevice()  // runs after each round
 991 {
 992         Kill_Notification(NOTIF_ALL, world, MSG_CENTER_CPID, CPID_KEYHUNT);
 993         Kill_Notification(NOTIF_ALL, world, MSG_CENTER_CPID, CPID_KEYHUNT_OTHER);
 994
 995         kh_tracking_enabled = true;
 996 }
 997
 998 void kh_StartRound()  // runs at the start of each round
 999 {
1000         float i, players, teem;
1001         entity player;
1002
1003         if(time < game_starttime)
1004         {
1005                 kh_Controller_SetThink(game_starttime - time + 0.1, kh_WaitForPlayers);
1006                 return;
1007         }
1008
1009         float p1 = kh_CheckPlayers(0), p2 = kh_CheckPlayers(1), p3 = kh_CheckPlayers(2), p4 = kh_CheckPlayers(3);
1010         if(!KH_READY_TEAMS_OK())
1011         {
1012                 kh_Controller_SetThink(1, kh_WaitForPlayers);
1013                 return;
1014         }
1015
1016         Kill_Notification(NOTIF_ALL, world, MSG_CENTER_CPID, CPID_KEYHUNT);
1017         Kill_Notification(NOTIF_ALL, world, MSG_CENTER_CPID, CPID_KEYHUNT_OTHER);
1018
1019         for(i = 0; i < kh_teams; ++i)
1020         {
1021                 teem = kh_Team_ByID(i);
1022                 players = 0;
1023                 entity my_player = world;
1024                 FOR_EACH_PLAYER(player)
1025                         if(player.deadflag == DEAD_NO)
1026                                 if(!player.BUTTON_CHAT)
1027                                         if(player.team == teem)
1028                                         {
1029                                                 ++players;
1030                                                 if(random() * players <= 1)
1031                                                         my_player = player;
1032                                         }
1033                 kh_Key_Spawn(my_player, 360 * i / kh_teams, i);
1034         }
1035
1036         kh_tracking_enabled = false;
1037         Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_KEYHUNT_SCAN, autocvar_g_balance_keyhunt_delay_tracking);
1038         kh_Controller_SetThink(autocvar_g_balance_keyhunt_delay_tracking, kh_EnableTrackingDevice);
1039 }
1040
1041 float kh_HandleFrags(entity attacker, entity targ, float f)  // adds to the player score
1042 {
1043         if(attacker == targ)
1044                 return f;
1045
1046         if(targ.kh_next)
1047         {
1048                 if(attacker.team == targ.team)
1049                 {
1050                         entity k;
1051                         float nk;
1052                         nk = 0;
1053                         for(k = targ.kh_next; k != world; k = k.kh_next)
1054                                 ++nk;
1055                         kh_Scores_Event(attacker, targ.kh_next, "carrierfrag", -nk * autocvar_g_balance_keyhunt_score_collect, 0);
1056                 }
1057                 else
1058                 {
1059                         kh_Scores_Event(attacker, targ.kh_next, "carrierfrag", autocvar_g_balance_keyhunt_score_carrierfrag-1, 0);
1060                         PlayerScore_Add(attacker, SP_KH_KCKILLS, 1);
1061                         // the frag gets added later
1062                 }
1063         }
1064
1065         return f;
1066 }
1067
1068 void kh_Initialize()  // sets up th KH environment
1069 {
1070         // setup variables
1071         kh_teams = autocvar_g_keyhunt_teams_override;
1072         if(kh_teams < 2)
1073                 kh_teams = autocvar_g_keyhunt_teams;
1074         kh_teams = bound(2, kh_teams, 4);
1075
1076         // make a KH entity for controlling the game
1077         kh_controller = spawn();
1078         kh_controller.think = kh_Controller_Think;
1079         kh_Controller_SetThink(0, kh_WaitForPlayers);
1080
1081         setmodel(kh_controller, MDL_KH_KEY);
1082         kh_key_dropped = kh_controller.modelindex;
1083         /*
1084         dprint(vtos(kh_controller.mins));
1085         dprint(vtos(kh_controller.maxs));
1086         dprint("\n");
1087         */
1088 #ifdef KH_PLAYER_USE_CARRIEDMODEL
1089         setmodel(kh_controller, MDL_KH_KEY_CARRIED);
1090         kh_key_carried = kh_controller.modelindex;
1091 #else
1092         kh_key_carried = kh_key_dropped;
1093 #endif
1094
1095         kh_controller.model = "";
1096         kh_controller.modelindex = 0;
1097
1098         kh_ScoreRules(kh_teams);
1099 }
1100
1101 void kh_finalize()
1102 {
1103         // to be called before intermission
1104         kh_FinishRound();
1105         remove(kh_controller);
1106         kh_controller = world;
1107 }
1108
1109 // legacy bot role
1110
1111 void() havocbot_role_kh_carrier;
1112 void() havocbot_role_kh_defense;
1113 void() havocbot_role_kh_offense;
1114 void() havocbot_role_kh_freelancer;
1115
1116
1117 void havocbot_goalrating_kh(float ratingscale_team, float ratingscale_dropped, float ratingscale_enemy)
1118 {SELFPARAM();
1119         entity head;
1120         for (head = kh_worldkeylist; head; head = head.kh_worldkeynext)
1121         {
1122                 if(head.owner == self)
1123                         continue;
1124                 if(!kh_tracking_enabled)
1125                 {
1126                         // if it's carried by our team we know about it
1127                         // otherwise we have to see it to know about it
1128                         if(!head.owner || head.team != self.team)
1129                         {
1130                                 traceline(self.origin + self.view_ofs, head.origin, MOVE_NOMONSTERS, self);
1131                                 if (trace_fraction < 1 && trace_ent != head)
1132                                         continue; // skip what I can't see
1133                         }
1134                 }
1135                 if(!head.owner)
1136                         navigation_routerating(head, ratingscale_dropped * BOT_PICKUP_RATING_HIGH, 100000);
1137                 else if(head.team == self.team)
1138                         navigation_routerating(head.owner, ratingscale_team * BOT_PICKUP_RATING_HIGH, 100000);
1139                 else
1140                         navigation_routerating(head.owner, ratingscale_enemy * BOT_PICKUP_RATING_HIGH, 100000);
1141         }
1142
1143         havocbot_goalrating_items(1, self.origin, 10000);
1144 }
1145
1146 void havocbot_role_kh_carrier()
1147 {SELFPARAM();
1148         if(self.deadflag != DEAD_NO)
1149                 return;
1150
1151         if (!(self.kh_next))
1152         {
1153                 LOG_TRACE("changing role to freelancer\n");
1154                 self.havocbot_role = havocbot_role_kh_freelancer;
1155                 self.havocbot_role_timeout = 0;
1156                 return;
1157         }
1158
1159         if (self.bot_strategytime < time)
1160         {
1161                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1162                 navigation_goalrating_start();
1163
1164                 if(kh_Key_AllOwnedByWhichTeam() == self.team)
1165                         havocbot_goalrating_kh(10, 0.1, 0.1); // bring home
1166                 else
1167                         havocbot_goalrating_kh(4, 4, 1); // play defensively
1168
1169                 navigation_goalrating_end();
1170         }
1171 }
1172
1173 void havocbot_role_kh_defense()
1174 {SELFPARAM();
1175         if(self.deadflag != DEAD_NO)
1176                 return;
1177
1178         if (self.kh_next)
1179         {
1180                 LOG_TRACE("changing role to carrier\n");
1181                 self.havocbot_role = havocbot_role_kh_carrier;
1182                 self.havocbot_role_timeout = 0;
1183                 return;
1184         }
1185
1186         if (!self.havocbot_role_timeout)
1187                 self.havocbot_role_timeout = time + random() * 10 + 20;
1188         if (time > self.havocbot_role_timeout)
1189         {
1190                 LOG_TRACE("changing role to freelancer\n");
1191                 self.havocbot_role = havocbot_role_kh_freelancer;
1192                 self.havocbot_role_timeout = 0;
1193                 return;
1194         }
1195
1196         if (self.bot_strategytime < time)
1197         {
1198                 float key_owner_team;
1199                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1200                 navigation_goalrating_start();
1201
1202                 key_owner_team = kh_Key_AllOwnedByWhichTeam();
1203                 if(key_owner_team == self.team)
1204                         havocbot_goalrating_kh(10, 0.1, 0.1); // defend key carriers
1205                 else if(key_owner_team == -1)
1206                         havocbot_goalrating_kh(4, 1, 0.1); // play defensively
1207                 else
1208                         havocbot_goalrating_kh(0.1, 0.1, 10); // ATTACK ANYWAY
1209
1210                 navigation_goalrating_end();
1211         }
1212 }
1213
1214 void havocbot_role_kh_offense()
1215 {SELFPARAM();
1216         if(self.deadflag != DEAD_NO)
1217                 return;
1218
1219         if (self.kh_next)
1220         {
1221                 LOG_TRACE("changing role to carrier\n");
1222                 self.havocbot_role = havocbot_role_kh_carrier;
1223                 self.havocbot_role_timeout = 0;
1224                 return;
1225         }
1226
1227         if (!self.havocbot_role_timeout)
1228                 self.havocbot_role_timeout = time + random() * 10 + 20;
1229         if (time > self.havocbot_role_timeout)
1230         {
1231                 LOG_TRACE("changing role to freelancer\n");
1232                 self.havocbot_role = havocbot_role_kh_freelancer;
1233                 self.havocbot_role_timeout = 0;
1234                 return;
1235         }
1236
1237         if (self.bot_strategytime < time)
1238         {
1239                 float key_owner_team;
1240
1241                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1242                 navigation_goalrating_start();
1243
1244                 key_owner_team = kh_Key_AllOwnedByWhichTeam();
1245                 if(key_owner_team == self.team)
1246                         havocbot_goalrating_kh(10, 0.1, 0.1); // defend anyway
1247                 else if(key_owner_team == -1)
1248                         havocbot_goalrating_kh(0.1, 1, 4); // play offensively
1249                 else
1250                         havocbot_goalrating_kh(0.1, 0.1, 10); // ATTACK! EMERGENCY!
1251
1252                 navigation_goalrating_end();
1253         }
1254 }
1255
1256 void havocbot_role_kh_freelancer()
1257 {SELFPARAM();
1258         if(self.deadflag != DEAD_NO)
1259                 return;
1260
1261         if (self.kh_next)
1262         {
1263                 LOG_TRACE("changing role to carrier\n");
1264                 self.havocbot_role = havocbot_role_kh_carrier;
1265                 self.havocbot_role_timeout = 0;
1266                 return;
1267         }
1268
1269         if (!self.havocbot_role_timeout)
1270                 self.havocbot_role_timeout = time + random() * 10 + 10;
1271         if (time > self.havocbot_role_timeout)
1272         {
1273                 if (random() < 0.5)
1274                 {
1275                         LOG_TRACE("changing role to offense\n");
1276                         self.havocbot_role = havocbot_role_kh_offense;
1277                 }
1278                 else
1279                 {
1280                         LOG_TRACE("changing role to defense\n");
1281                         self.havocbot_role = havocbot_role_kh_defense;
1282                 }
1283                 self.havocbot_role_timeout = 0;
1284                 return;
1285         }
1286
1287         if (self.bot_strategytime < time)
1288         {
1289                 float key_owner_team;
1290
1291                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1292                 navigation_goalrating_start();
1293
1294                 key_owner_team = kh_Key_AllOwnedByWhichTeam();
1295                 if(key_owner_team == self.team)
1296                         havocbot_goalrating_kh(10, 0.1, 0.1); // defend anyway
1297                 else if(key_owner_team == -1)
1298                         havocbot_goalrating_kh(1, 10, 4); // prefer dropped keys
1299                 else
1300                         havocbot_goalrating_kh(0.1, 0.1, 10); // ATTACK ANYWAY
1301
1302                 navigation_goalrating_end();
1303         }
1304 }
1305
1306
1307 // register this as a mutator
1308
1309 MUTATOR_HOOKFUNCTION(kh, ClientDisconnect)
1310 {SELFPARAM();
1311         kh_Key_DropAll(self, true);
1312         return 0;
1313 }
1314
1315 MUTATOR_HOOKFUNCTION(kh, MakePlayerObserver)
1316 {SELFPARAM();
1317         kh_Key_DropAll(self, true);
1318         return 0;
1319 }
1320
1321 MUTATOR_HOOKFUNCTION(kh, PlayerDies)
1322 {SELFPARAM();
1323         if(self == other)
1324                 kh_Key_DropAll(self, true);
1325         else if(IS_PLAYER(other))
1326                 kh_Key_DropAll(self, false);
1327         else
1328                 kh_Key_DropAll(self, true);
1329         return 0;
1330 }
1331
1332 MUTATOR_HOOKFUNCTION(kh, GiveFragsForKill, CBC_ORDER_FIRST)
1333 {
1334         frag_score = kh_HandleFrags(frag_attacker, frag_target, frag_score);
1335         return 0;
1336 }
1337
1338 MUTATOR_HOOKFUNCTION(kh, MatchEnd)
1339 {
1340         kh_finalize();
1341         return 0;
1342 }
1343
1344 MUTATOR_HOOKFUNCTION(kh, GetTeamCount, CBC_ORDER_EXCLUSIVE)
1345 {
1346         ret_float = kh_teams;
1347         return false;
1348 }
1349
1350 MUTATOR_HOOKFUNCTION(kh, SpectateCopy)
1351 {SELFPARAM();
1352         self.kh_state = other.kh_state;
1353         return 0;
1354 }
1355
1356 MUTATOR_HOOKFUNCTION(kh, PlayerUseKey)
1357 {SELFPARAM();
1358         if(MUTATOR_RETURNVALUE == 0)
1359         {
1360                 entity k;
1361                 k = self.kh_next;
1362                 if(k)
1363                 {
1364                         kh_Key_DropOne(k);
1365                         return 1;
1366                 }
1367         }
1368         return 0;
1369 }
1370
1371 MUTATOR_HOOKFUNCTION(kh, HavocBot_ChooseRole)
1372 {
1373         if(self.deadflag != DEAD_NO)
1374                 return true;
1375
1376         float r = random() * 3;
1377         if (r < 1)
1378                 self.havocbot_role = havocbot_role_kh_offense;
1379         else if (r < 2)
1380                 self.havocbot_role = havocbot_role_kh_defense;
1381         else
1382                 self.havocbot_role = havocbot_role_kh_freelancer;
1383
1384         return true;
1385 }
1386
1387 MUTATOR_HOOKFUNCTION(kh, DropSpecialItems)
1388 {
1389         kh_Key_DropAll(frag_target, false);
1390         return false;
1391 }
1392
1393 MUTATOR_HOOKFUNCTION(kh, reset_map_global)
1394 {
1395         kh_Controller_SetThink(autocvar_g_balance_keyhunt_delay_round + (game_starttime - time), kh_StartRound);
1396         return false;
1397 }
1398
1399 #endif