qcsrc/server/bot/default/havocbot/havocbot.qc

   1 #include "havocbot.qh"
   2
   3 #include <common/constants.qh>
   4 #include <common/impulses/all.qh>
   5 #include <common/items/_mod.qh>
   6 #include <common/mapobjects/func/ladder.qh>
   7 #include <common/mapobjects/teleporters.qh>
   8 #include <common/mapobjects/trigger/hurt.qh>
   9 #include <common/mapobjects/trigger/jumppads.qh>
  10 #include <common/mutators/mutator/powerups/_mod.qh>
  11 #include <common/mutators/mutator/status_effects/_mod.qh>
  12 #include <common/net_linked.qh>
  13 #include <common/physics/player.qh>
  14 #include <common/state.qh>
  15 #include <common/stats.qh>
  16 #include <common/weapons/_all.qh>
  17 #include <common/wepent.qh>
  18 #include <lib/warpzone/common.qh>
  19 #include <server/bot/api.qh>
  20 #include <server/bot/default/aim.qh>
  21 #include <server/bot/default/bot.qh>
  22 #include <server/bot/default/cvars.qh>
  23 #include <server/bot/default/havocbot/roles.qh>
  24 #include <server/bot/default/navigation.qh>
  25 #include <server/bot/default/scripting.qh>
  26 #include <server/bot/default/waypoints.qh>
  27 #include <server/client.qh>
  28 #include <server/damage.qh>
  29 #include <server/items/items.qh>
  30 #include <server/mutators/_mod.qh>
  31 #include <server/weapons/selection.qh>
  32 #include <server/weapons/weaponsystem.qh>
  33 #include <server/world.qh>
  34
  35 void havocbot_ai(entity this)
  36 {
  37         if(this.draggedby)
  38                 return;
  39
  40         this.bot_aimdir_executed = false;
  41         // lock aim if teleported or passing through a warpzone
  42         if (this.lastteleporttime && !this.jumppadcount)
  43                 this.bot_aimdir_executed = true;
  44
  45         if(bot_execute_commands(this))
  46                 return;
  47
  48         // after bot_execute_commands otherwise bots can't be unpaused
  49         if (bot_ispaused(this))
  50                 return;
  51
  52         if (bot_strategytoken == this && !bot_strategytoken_taken)
  53         {
  54                 if(this.havocbot_blockhead)
  55                 {
  56                         this.havocbot_blockhead = false;
  57                 }
  58                 else
  59                 {
  60                         if (!this.jumppadcount && !STAT(FROZEN, this)
  61                                 && !(this.goalcurrent_prev && (this.goalcurrent_prev.wpflags & WAYPOINTFLAG_JUMP) && !IS_ONGROUND(this)))
  62                         {
  63                                 // find a new goal
  64                                 this.havocbot_role(this); // little too far down the rabbit hole
  65                         }
  66                 }
  67
  68                 // if we don't have a goal and we're under water look for a waypoint near the "shore" and push it
  69                 if(!(IS_DEAD(this) || STAT(FROZEN, this)))
  70                 if(!this.goalcurrent)
  71                 if(this.waterlevel == WATERLEVEL_SWIMMING || (this.aistatus & AI_STATUS_OUT_WATER))
  72                 {
  73                         // Look for the closest waypoint out of water
  74                         entity newgoal = NULL;
  75                         IL_EACH(g_waypoints, vdist(it.origin - this.origin, <=, 10000),
  76                         {
  77                                 if(it.origin.z < this.origin.z)
  78                                         continue;
  79
  80                                 if(it.origin.z - this.origin.z - this.view_ofs.z > 100)
  81                                         continue;
  82
  83                                 if (pointcontents(it.origin + it.maxs + '0 0 1') != CONTENT_EMPTY)
  84                                         continue;
  85
  86                                 traceline(this.origin + this.view_ofs, ((it.absmin + it.absmax) * 0.5), true, this);
  87
  88                                 if(trace_fraction < 1)
  89                                         continue;
  90
  91                                 if(!newgoal || vlen2(it.origin - this.origin) < vlen2(newgoal.origin - this.origin))
  92                                         newgoal = it;
  93                         });
  94
  95                         if(newgoal)
  96                         {
  97                         //      te_wizspike(newgoal.origin);
  98                                 navigation_pushroute(this, newgoal);
  99                         }
 100                 }
 101
 102                 // token has been used this frame
 103                 bot_strategytoken_taken = true;
 104         }
 105
 106         if (this.goalcurrent && wasfreed(this.goalcurrent))
 107         {
 108                 navigation_clearroute(this);
 109                 navigation_goalrating_timeout_force(this);
 110                 return;
 111         }
 112
 113         if(IS_DEAD(this) || STAT(FROZEN, this))
 114         {
 115                 if (this.goalcurrent)
 116                         navigation_clearroute(this);
 117                 this.enemy = NULL;
 118                 return;
 119         }
 120
 121         havocbot_chooseenemy(this);
 122
 123         for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
 124         {
 125                 .entity weaponentity = weaponentities[slot];
 126                 if(this.(weaponentity).m_weapon != WEP_Null || slot == 0)
 127                 if(this.(weaponentity).bot_chooseweapontime < time)
 128                 {
 129                         this.(weaponentity).bot_chooseweapontime = time + autocvar_bot_ai_chooseweaponinterval;
 130                         havocbot_chooseweapon(this, weaponentity);
 131                 }
 132         }
 133         havocbot_aim(this);
 134
 135         if (this.enemy)
 136         {
 137                 this.aistatus |= AI_STATUS_ATTACKING;
 138                 this.aistatus &= ~AI_STATUS_ROAMING;
 139
 140                 if(STAT(WEAPONS, this))
 141                 {
 142                         if (autocvar_bot_nofire || IS_INDEPENDENT_PLAYER(this))
 143                         {
 144                                 PHYS_INPUT_BUTTON_ATCK(this) = false;
 145                                 PHYS_INPUT_BUTTON_ATCK2(this) = false;
 146                         }
 147                         else
 148                         {
 149                                 for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
 150                                 {
 151                                         .entity weaponentity = weaponentities[slot];
 152                                         Weapon w = this.(weaponentity).m_weapon;
 153                                         if(w == WEP_Null && slot != 0)
 154                                                 continue;
 155                                         w.wr_aim(w, this, weaponentity);
 156                                         if(PHYS_INPUT_BUTTON_ATCK(this) || PHYS_INPUT_BUTTON_ATCK2(this)) // TODO: what if we didn't fire this weapon, but the previous?
 157                                                 this.(weaponentity).lastfiredweapon = this.(weaponentity).m_weapon.m_id;
 158                                 }
 159                         }
 160                 }
 161                 else
 162                 {
 163                         if(IS_PLAYER(this.enemy))
 164                                 bot_aimdir(this, this.enemy.origin + this.enemy.view_ofs - this.origin - this.view_ofs, 0);
 165                 }
 166         }
 167         else if (this.goalcurrent)
 168         {
 169                 this.aistatus |= AI_STATUS_ROAMING;
 170                 this.aistatus &= ~AI_STATUS_ATTACKING;
 171         }
 172
 173         havocbot_movetogoal(this);
 174         if (!this.bot_aimdir_executed && this.goalcurrent)
 175         {
 176                 // Heading
 177                 vector dir = get_closer_dest(this.goalcurrent, this.origin);
 178                 dir -= this.origin + this.view_ofs;
 179                 dir.z = 0;
 180                 bot_aimdir(this, dir, 0);
 181         }
 182
 183         // if the bot is not attacking, consider reloading weapons
 184         if (!(this.aistatus & AI_STATUS_ATTACKING))
 185         {
 186                 for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
 187                 {
 188                         .entity weaponentity = weaponentities[slot];
 189
 190                         if(this.(weaponentity).m_weapon == WEP_Null && slot != 0)
 191                                 continue;
 192
 193                         // we are currently holding a weapon that's not fully loaded, reload it
 194                         if(skill >= 2) // bots can only reload the held weapon on purpose past this skill
 195                         if(this.(weaponentity).clip_load < this.(weaponentity).clip_size)
 196                                 CS(this).impulse = IMP_weapon_reload.impulse; // not sure if this is done right
 197
 198                         // if we're not reloading a weapon, switch to any weapon in our invnetory that's not fully loaded to reload it next
 199                         // the code above executes next frame, starting the reloading then
 200                         if(skill >= 5) // bots can only look for unloaded weapons past this skill
 201                         if(this.(weaponentity).clip_load >= 0) // only if we're not reloading a weapon already
 202                         {
 203                                 FOREACH(Weapons, it != WEP_Null, {
 204                                         if((STAT(WEAPONS, this) & (it.m_wepset)) && (it.spawnflags & WEP_FLAG_RELOADABLE) && (this.(weaponentity).weapon_load[it.m_id] < it.reloading_ammo))
 205                                         {
 206                                                 this.(weaponentity).m_switchweapon = it;
 207                                                 break;
 208                                         }
 209                                 });
 210                         }
 211                 }
 212         }
 213 }
 214
 215 void havocbot_bunnyhop(entity this, vector dir)
 216 {
 217         bool can_run = false;
 218         if (!(this.aistatus & AI_STATUS_ATTACKING) && this.goalcurrent && !IS_PLAYER(this.goalcurrent)
 219                 && vdist(vec2(this.velocity), >=, autocvar_sv_maxspeed) && !(this.aistatus & AI_STATUS_DANGER_AHEAD)
 220                 && this.waterlevel <= WATERLEVEL_WETFEET && !IS_DUCKED(this)
 221                 && IS_ONGROUND(this) && !(this.goalcurrent_prev && (this.goalcurrent_prev.wpflags & WAYPOINTFLAG_JUMP)))
 222         {
 223                 vector vel_angles = vectoangles(this.velocity);
 224                 vector deviation = vel_angles - vectoangles(dir);
 225                 while (deviation.y < -180) deviation.y = deviation.y + 360;
 226                 while (deviation.y > 180) deviation.y = deviation.y - 360;
 227                 if (fabs(deviation.y) < autocvar_bot_ai_bunnyhop_dir_deviation_max)
 228                 {
 229                         vector gco = get_closer_dest(this.goalcurrent, this.origin);
 230                         float vel = vlen(vec2(this.velocity));
 231
 232                         // with the current physics, jump distance grows linearly with the speed
 233                         float jump_distance = 52.661 + 0.606 * vel;
 234                         jump_distance += this.origin.z - gco.z; // roughly take into account vertical distance too
 235                         if (vdist(vec2(gco - this.origin), >, max(0, jump_distance)))
 236                                 can_run = true;
 237                         else if (!(this.goalcurrent.wpflags & WAYPOINTFLAG_JUMP)
 238                                 && !(this.goalcurrent.wpflags & WAYPOINTFLAG_TELEPORT)
 239                                 && this.goalstack01 && !wasfreed(this.goalstack01) && !(this.goalstack01.wpflags & WAYPOINTFLAG_JUMP)
 240                                 && vdist(vec2(gco - this.goalstack01.origin), >, 70))
 241                         {
 242                                 vector gno = (this.goalstack01.absmin + this.goalstack01.absmax) * 0.5;
 243                                 vector ang = vectoangles(gco - this.origin);
 244                                 deviation = vectoangles(gno - gco) - vel_angles;
 245                                 while (deviation.y < -180) deviation.y = deviation.y + 360;
 246                                 while (deviation.y > 180) deviation.y = deviation.y - 360;
 247
 248                                 float max_turn_angle = autocvar_bot_ai_bunnyhop_turn_angle_max;
 249                                 max_turn_angle -= autocvar_bot_ai_bunnyhop_turn_angle_reduction * ((vel - autocvar_sv_maxspeed) / autocvar_sv_maxspeed);
 250                                 if ((ang.x < 90 || ang.x > 360 - autocvar_bot_ai_bunnyhop_downward_pitch_max)
 251                                         && fabs(deviation.y) < max(autocvar_bot_ai_bunnyhop_turn_angle_min, max_turn_angle))
 252                                 {
 253                                         can_run = true;
 254                                 }
 255                         }
 256                 }
 257         }
 258
 259         if (can_run)
 260         {
 261                 PHYS_INPUT_BUTTON_JUMP(this) = true;
 262                 this.bot_jump_time = time;
 263                 this.aistatus |= AI_STATUS_RUNNING;
 264         }
 265         else
 266         {
 267                 if (IS_ONGROUND(this) || this.waterlevel > WATERLEVEL_WETFEET)
 268                         this.aistatus &= ~AI_STATUS_RUNNING;
 269         }
 270 }
 271
 272 void havocbot_keyboard_movement(entity this, vector destorg)
 273 {
 274         if(time <= this.havocbot_keyboardtime)
 275                 return;
 276
 277         float sk = skill + this.bot_moveskill;
 278         this.havocbot_keyboardtime =
 279                 max(
 280                         this.havocbot_keyboardtime
 281                                 + 0.05 / max(1, sk + this.havocbot_keyboardskill)
 282                                 + random() * 0.025 / max(0.00025, skill + this.havocbot_keyboardskill)
 283                 , time);
 284         vector keyboard = CS(this).movement / autocvar_sv_maxspeed;
 285
 286         float trigger = autocvar_bot_ai_keyboard_threshold;
 287
 288         // categorize forward movement
 289         // at skill < 1.5 only forward
 290         // at skill < 2.5 only individual directions
 291         // at skill < 4.5 only individual directions, and forward diagonals
 292         // at skill >= 4.5, all cases allowed
 293         if (keyboard.x > trigger)
 294         {
 295                 keyboard.x = 1;
 296                 if (sk < 2.5)
 297                         keyboard.y = 0;
 298         }
 299         else if (keyboard.x < -trigger && sk > 1.5)
 300         {
 301                 keyboard.x = -1;
 302                 if (sk < 4.5)
 303                         keyboard.y = 0;
 304         }
 305         else
 306         {
 307                 keyboard.x = 0;
 308                 if (sk < 1.5)
 309                         keyboard.y = 0;
 310         }
 311         if (sk < 4.5)
 312                 keyboard.z = 0;
 313
 314         if (keyboard.y > trigger)
 315                 keyboard.y = 1;
 316         else if (keyboard.y < -trigger)
 317                 keyboard.y = -1;
 318         else
 319                 keyboard.y = 0;
 320
 321         if (keyboard.z > trigger)
 322                 keyboard.z = 1;
 323         else if (keyboard.z < -trigger)
 324                 keyboard.z = -1;
 325         else
 326                 keyboard.z = 0;
 327
 328         // make sure bots don't get stuck if havocbot_keyboardtime is very high
 329         if (keyboard == '0 0 0')
 330                 this.havocbot_keyboardtime = min(this.havocbot_keyboardtime, time + 0.2);
 331
 332         this.havocbot_keyboard = keyboard * autocvar_sv_maxspeed;
 333         if (this.havocbot_ducktime > time)
 334                 PHYS_INPUT_BUTTON_CROUCH(this) = true;
 335
 336         keyboard = this.havocbot_keyboard;
 337         float blend = bound(0, vlen(destorg - this.origin) / autocvar_bot_ai_keyboard_distance, 1); // When getting close move with 360 degree
 338         //dprint("movement ", vtos(CS(this).movement), " keyboard ", vtos(keyboard), " blend ", ftos(blend), "\n");
 339         CS(this).movement = CS(this).movement + (keyboard - CS(this).movement) * blend;
 340 }
 341
 342 // return true when bot isn't getting closer to the current goal
 343 bool havocbot_checkgoaldistance(entity this, vector gco)
 344 {
 345         if (this.bot_stop_moving_timeout > time)
 346                 return false;
 347         float curr_dist_z = max(20, fabs(this.origin.z - gco.z));
 348         float curr_dist_2d = max(20, vlen(vec2(this.origin - gco)));
 349         float distance_time = this.goalcurrent_distance_time;
 350         if(distance_time < 0)
 351                 distance_time = -distance_time;
 352         if(curr_dist_z >= this.goalcurrent_distance_z && curr_dist_2d >= this.goalcurrent_distance_2d)
 353         {
 354                 if(!distance_time)
 355                         this.goalcurrent_distance_time = time;
 356                 else if (time - distance_time > 0.5)
 357                         return true;
 358         }
 359         else
 360         {
 361                 // reduce it a little bit so it works even with very small approaches to the goal
 362                 this.goalcurrent_distance_z = max(20, curr_dist_z - 10);
 363                 this.goalcurrent_distance_2d = max(20, curr_dist_2d - 10);
 364                 this.goalcurrent_distance_time = 0;
 365         }
 366         return false;
 367 }
 368
 369 entity havocbot_select_an_item_of_group(entity this, int gr)
 370 {
 371         entity selected = NULL;
 372         float selected_dist2 = 0;
 373         // select farthest item of this group from bot's position
 374         IL_EACH(g_items, it.item_group == gr && it.solid,
 375         {
 376                 float dist2 = vlen2(this.origin - it.origin);
 377                 if (dist2 < 600 ** 2 && dist2 > selected_dist2)
 378                 {
 379                         selected = it;
 380                         selected_dist2 = vlen2(this.origin - selected.origin);
 381                 }
 382         });
 383
 384         if (!selected)
 385                 return NULL;
 386
 387         set_tracewalk_dest(selected, this.origin, false);
 388         if (!tracewalk(this, this.origin, STAT(PL_MIN, this), STAT(PL_MAX, this),
 389                 tracewalk_dest, tracewalk_dest_height, bot_navigation_movemode))
 390         {
 391                 return NULL;
 392         }
 393
 394         return selected;
 395 }
 396
 397 // Check for water/slime/lava and dangerous edges
 398 // (only when the bot is on the ground or jumping intentionally)
 399 // returns true for danger
 400 bool havocbot_checkdanger(entity this, vector dst_ahead)
 401 {
 402         vector dst_down = dst_ahead - '0 0 3000';
 403         traceline(this.origin + this.view_ofs, dst_ahead, true, NULL);
 404
 405         float s = CONTENT_SOLID;
 406         if (trace_fraction == 1 && !this.jumppadcount
 407                 && !waypoint_is_hardwiredlink(this.goalcurrent_prev, this.goalcurrent)
 408                 && !(this.goalcurrent_prev && (this.goalcurrent_prev.wpflags & WAYPOINTFLAG_JUMP)))
 409         if ((IS_ONGROUND(this)) || (this.aistatus & AI_STATUS_RUNNING) || (this.aistatus & AI_STATUS_ROAMING) || PHYS_INPUT_BUTTON_JUMP(this))
 410         {
 411                 // Look downwards
 412                 traceline(dst_ahead , dst_down, true, NULL);
 413                 //te_lightning2(NULL, this.origin + this.view_ofs, dst_ahead); // Draw "ahead" look
 414                 //te_lightning2(NULL, dst_ahead, trace_endpos); // Draw "downwards" look
 415                 if (trace_endpos.z < this.origin.z + this.mins.z)
 416                 {
 417                         if (trace_dphitq3surfaceflags & Q3SURFACEFLAG_SKY)
 418                                 return true;
 419                         else if (trace_endpos.z < min(this.origin.z + this.mins.z, this.goalcurrent.origin.z) - 100)
 420                                 return true;
 421                         else
 422                         {
 423                                 s = pointcontents(trace_endpos + '0 0 1');
 424                                 if (s != CONTENT_SOLID)
 425                                 {
 426                                         if (s == CONTENT_LAVA || s == CONTENT_SLIME)
 427                                                 return true;
 428                                         else if (tracebox_hits_trigger_hurt(dst_ahead, this.mins, this.maxs, trace_endpos))
 429                                         {
 430                                                 // the traceline check isn't enough but is good as optimization,
 431                                                 // when not true (most of the time) this tracebox call is avoided
 432                                                 tracebox(dst_ahead, this.mins, this.maxs, dst_down, true, this);
 433                                                 if (tracebox_hits_trigger_hurt(dst_ahead, this.mins, this.maxs, trace_endpos))
 434                                                 {
 435                                                         return true;
 436                                                 }
 437                                         }
 438                                 }
 439                         }
 440                 }
 441         }
 442         return false;
 443 }
 444
 445 void havocbot_movetogoal(entity this)
 446 {
 447         vector diff;
 448         vector dir;
 449         vector flatdir;
 450         float dodge_enemy_factor = 1;
 451         float maxspeed = autocvar_sv_maxspeed;
 452         //float dist;
 453         vector dodge;
 454         //if (this.goalentity)
 455         //      te_lightning2(this, this.origin, (this.goalentity.absmin + this.goalentity.absmax) * 0.5);
 456         CS(this).movement = '0 0 0';
 457
 458         PHYS_INPUT_BUTTON_CROUCH(this) = boolean(this.goalcurrent.wpflags & WAYPOINTFLAG_CROUCH);
 459
 460         PHYS_INPUT_BUTTON_JETPACK(this) = false;
 461         // Jetpack navigation
 462         if(this.navigation_jetpack_goal)
 463         if(this.goalcurrent==this.navigation_jetpack_goal)
 464         if(GetResource(this, RES_FUEL))
 465         {
 466                 if(autocvar_bot_debug_goalstack)
 467                 {
 468                         debuggoalstack(this);
 469                         te_wizspike(this.navigation_jetpack_point);
 470                 }
 471
 472                 // Take off
 473                 if (!(this.aistatus & AI_STATUS_JETPACK_FLYING))
 474                 {
 475                         // Brake almost completely so it can get a good direction
 476                         if(vdist(this.velocity, >, 10))
 477                                 return;
 478                         this.aistatus |= AI_STATUS_JETPACK_FLYING;
 479                 }
 480
 481                 makevectors(this.v_angle.y * '0 1 0');
 482                 dir = normalize(this.navigation_jetpack_point - this.origin);
 483
 484                 // Landing
 485                 if(this.aistatus & AI_STATUS_JETPACK_LANDING)
 486                 {
 487                         // Calculate brake distance in xy
 488                         float d = vlen(vec2(this.origin - (this.goalcurrent.absmin + this.goalcurrent.absmax) * 0.5));
 489                         float vel2 = vlen2(vec2(this.velocity));
 490                         float db = (vel2 / (autocvar_g_jetpack_acceleration_side * 2)) + 100;
 491                         //LOG_INFOF("distance %d, velocity %d, brake at %d ", ceil(d), ceil(v), ceil(db));
 492                         if(d < db || d < 500)
 493                         {
 494                                 // Brake
 495                                 if (vel2 > (maxspeed * 0.3) ** 2)
 496                                 {
 497                                         CS(this).movement_x = dir * v_forward * -maxspeed;
 498                                         return;
 499                                 }
 500                                 // Switch to normal mode
 501                                 this.navigation_jetpack_goal = NULL;
 502                                 this.aistatus &= ~AI_STATUS_JETPACK_LANDING;
 503                                 this.aistatus &= ~AI_STATUS_JETPACK_FLYING;
 504                                 return;
 505                         }
 506                 }
 507                 else if(checkpvs(this.origin,this.goalcurrent))
 508                 {
 509                         // If I can see the goal switch to landing code
 510                         this.aistatus &= ~AI_STATUS_JETPACK_FLYING;
 511                         this.aistatus |= AI_STATUS_JETPACK_LANDING;
 512                         return;
 513                 }
 514
 515                 // Flying
 516                 PHYS_INPUT_BUTTON_JETPACK(this) = true;
 517                 if(this.navigation_jetpack_point.z - STAT(PL_MAX, this).z + STAT(PL_MIN, this).z < this.origin.z)
 518                 {
 519                         CS(this).movement_x = dir * v_forward * maxspeed;
 520                         CS(this).movement_y = dir * v_right * maxspeed;
 521                 }
 522                 return;
 523         }
 524
 525         // Handling of jump pads
 526         if(this.jumppadcount)
 527         {
 528                 if(this.goalcurrent.wpflags & WAYPOINTFLAG_TELEPORT)
 529                 {
 530                         this.aistatus |= AI_STATUS_OUT_JUMPPAD;
 531                         if(navigation_poptouchedgoals(this))
 532                                 return;
 533                 }
 534                 else if(this.aistatus & AI_STATUS_OUT_JUMPPAD)
 535                 {
 536                         // If got stuck on the jump pad try to reach the farthest visible waypoint
 537                         // but with some randomness so it can try out different paths
 538                         if(!this.goalcurrent)
 539                         {
 540                                 entity newgoal = NULL;
 541                                 IL_EACH(g_waypoints, vdist(it.origin - this.origin, <=, 1000),
 542                                 {
 543                                         if(it.wpflags & WAYPOINTFLAG_TELEPORT)
 544                                         if(it.origin.z < this.origin.z - 100 && vdist(vec2(it.origin - this.origin), <, 100))
 545                                                 continue;
 546
 547                                         traceline(this.origin + this.view_ofs, ((it.absmin + it.absmax) * 0.5), true, this);
 548
 549                                         if(trace_fraction < 1)
 550                                                 continue;
 551
 552                                         if(!newgoal || ((random() < 0.8) && vlen2(it.origin - this.origin) > vlen2(newgoal.origin - this.origin)))
 553                                                 newgoal = it;
 554                                 });
 555
 556                                 if(newgoal)
 557                                 {
 558                                         this.ignoregoal = this.goalcurrent;
 559                                         this.ignoregoaltime = time + autocvar_bot_ai_ignoregoal_timeout;
 560                                         navigation_clearroute(this);
 561                                         navigation_routetogoal(this, newgoal, this.origin);
 562                                         if(autocvar_bot_debug_goalstack)
 563                                                 debuggoalstack(this);
 564                                         this.aistatus &= ~AI_STATUS_OUT_JUMPPAD;
 565                                 }
 566                         }
 567                         else //if (this.goalcurrent)
 568                         {
 569                                 if (this.goalcurrent.bot_pickup)
 570                                 {
 571                                         entity jumppad_wp = this.goalcurrent_prev;
 572                                         navigation_poptouchedgoals(this);
 573                                         if(!this.goalcurrent && jumppad_wp.wp00)
 574                                         {
 575                                                 // head to the jumppad destination once bot reaches the goal item
 576                                                 navigation_pushroute(this, jumppad_wp.wp00);
 577                                         }
 578                                 }
 579                                 vector gco = (this.goalcurrent.absmin + this.goalcurrent.absmax) * 0.5;
 580                                 if (this.origin.z > gco.z && vdist(vec2(this.velocity), <, maxspeed))
 581                                 {
 582                                         if (this.velocity.z < 0)
 583                                                 this.aistatus &= ~AI_STATUS_OUT_JUMPPAD;
 584                                 }
 585                                 else if(havocbot_checkgoaldistance(this, gco))
 586                                 {
 587                                         navigation_clearroute(this);
 588                                         navigation_goalrating_timeout_force(this);
 589                                 }
 590                                 else
 591                                         return;
 592                         }
 593                 }
 594                 else //if (!(this.aistatus & AI_STATUS_OUT_JUMPPAD))
 595                 {
 596                         if(this.velocity.z > 0 && this.origin.z - this.lastteleport_origin.z > (this.maxs.z - this.mins.z) * 0.5)
 597                         {
 598                                 vector velxy = this.velocity; velxy_z = 0;
 599                                 if(vdist(velxy, <, maxspeed * 0.2))
 600                                 {
 601                                         LOG_TRACE("Warning: ", this.netname, " got stuck on a jumppad (velocity in xy is ", vtos(velxy), "), trying to get out of it now");
 602                                         this.aistatus |= AI_STATUS_OUT_JUMPPAD;
 603                                 }
 604                                 return;
 605                         }
 606
 607                         // Don't chase players while using a jump pad
 608                         if(IS_PLAYER(this.goalcurrent) || IS_PLAYER(this.goalstack01))
 609                                 return;
 610                 }
 611         }
 612         else if(this.aistatus & AI_STATUS_OUT_JUMPPAD)
 613                 this.aistatus &= ~AI_STATUS_OUT_JUMPPAD;
 614
 615         // If there is a trigger_hurt right below try to use the jetpack or make a rocketjump
 616         if (skill > 6 && !(IS_ONGROUND(this)))
 617         {
 618                 #define ROCKETJUMP_DAMAGE() WEP_CVAR(devastator, damage) * 0.8 \
 619                         * ((StatusEffects_active(STATUSEFFECT_Strength, this)) ? autocvar_g_balance_powerup_strength_selfdamage : 1) \
 620                         * ((StatusEffects_active(STATUSEFFECT_Shield, this)) ? autocvar_g_balance_powerup_invincible_takedamage : 1)
 621
 622                 // save some CPU cycles by checking trigger_hurt after checking
 623                 // that something can be done to evade it (cheaper checks)
 624                 int action_for_trigger_hurt = 0;
 625                 if (this.items & IT_JETPACK)
 626                         action_for_trigger_hurt = 1;
 627                 else if (!this.jumppadcount && !waypoint_is_hardwiredlink(this.goalcurrent_prev, this.goalcurrent)
 628                         && !(this.goalcurrent_prev && this.goalcurrent_prev.wpflags & WAYPOINTFLAG_JUMP)
 629                         && GetResource(this, RES_HEALTH) + GetResource(this, RES_ARMOR) > ROCKETJUMP_DAMAGE())
 630                 {
 631                         action_for_trigger_hurt = 2;
 632                 }
 633                 else if (!this.goalcurrent)
 634                         action_for_trigger_hurt = 3;
 635
 636                 if (action_for_trigger_hurt)
 637                 {
 638                         tracebox(this.origin, this.mins, this.maxs, this.origin + '0 0 -65536', MOVE_NOMONSTERS, this);
 639                         if(!tracebox_hits_trigger_hurt(this.origin, this.mins, this.maxs, trace_endpos))
 640                                 action_for_trigger_hurt = 0;
 641                 }
 642
 643                 if(action_for_trigger_hurt == 1) // jetpack
 644                 {
 645                         tracebox(this.origin, this.mins, this.maxs, this.origin + '0 0 65536', MOVE_NOMONSTERS, this);
 646                         if(tracebox_hits_trigger_hurt(this.origin, this.mins, this.maxs, trace_endpos + '0 0 1' ))
 647                         {
 648                                 if(this.velocity.z<0)
 649                                         PHYS_INPUT_BUTTON_JETPACK(this) = true;
 650                         }
 651                         else
 652                                 PHYS_INPUT_BUTTON_JETPACK(this) = true;
 653
 654                         // If there is no goal try to move forward
 655
 656                         if(this.goalcurrent==NULL)
 657                                 dir = v_forward;
 658                         else
 659                                 dir = normalize(( ( this.goalcurrent.absmin + this.goalcurrent.absmax ) * 0.5 ) - this.origin);
 660
 661                         vector xyvelocity = this.velocity; xyvelocity_z = 0;
 662                         float xyspeed = xyvelocity * dir;
 663
 664                         if(xyspeed < (maxspeed / 2))
 665                         {
 666                                 makevectors(this.v_angle.y * '0 1 0');
 667                                 tracebox(this.origin, this.mins, this.maxs, this.origin + (dir * maxspeed * 3), MOVE_NOMONSTERS, this);
 668                                 if(trace_fraction==1)
 669                                 {
 670                                         CS(this).movement_x = dir * v_forward * maxspeed;
 671                                         CS(this).movement_y = dir * v_right * maxspeed;
 672                                         if (skill < 10)
 673                                                 havocbot_keyboard_movement(this, this.origin + dir * 100);
 674                                 }
 675                         }
 676
 677                         this.havocbot_blockhead = true;
 678
 679                         return;
 680                 }
 681                 else if(action_for_trigger_hurt == 2) // rocketjump
 682                 {
 683                         if(this.velocity.z < 0)
 684                         {
 685                                 for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
 686                                 {
 687                                         .entity weaponentity = weaponentities[slot];
 688
 689                                         if(this.(weaponentity).m_weapon == WEP_Null && slot != 0)
 690                                                 continue;
 691
 692                                         if(client_hasweapon(this, WEP_DEVASTATOR, weaponentity, true, false))
 693                                         {
 694                                                 CS(this).movement_x = maxspeed;
 695
 696                                                 if(this.rocketjumptime)
 697                                                 {
 698                                                         if(time > this.rocketjumptime)
 699                                                         {
 700                                                                 PHYS_INPUT_BUTTON_ATCK2(this) = true;
 701                                                                 this.rocketjumptime = 0;
 702                                                         }
 703                                                         return;
 704                                                 }
 705
 706                                                 this.(weaponentity).m_switchweapon = WEP_DEVASTATOR;
 707                                                 this.v_angle_x = 90;
 708                                                 PHYS_INPUT_BUTTON_ATCK(this) = true;
 709                                                 this.rocketjumptime = time + WEP_CVAR(devastator, detonatedelay);
 710                                                 return;
 711                                         }
 712                                 }
 713                         }
 714                 }
 715                 else if(action_for_trigger_hurt == 3) // no goal
 716                 {
 717                         // If there is no goal try to move forward
 718                         CS(this).movement_x = maxspeed;
 719                 }
 720         }
 721
 722         // If we are under water with no goals, swim up
 723         if(this.waterlevel && !this.goalcurrent)
 724         {
 725                 dir = '0 0 0';
 726                 if(this.waterlevel>WATERLEVEL_SWIMMING)
 727                         dir.z = 1;
 728                 else if(this.velocity.z >= 0 && !(this.waterlevel == WATERLEVEL_WETFEET && this.watertype == CONTENT_WATER))
 729                         PHYS_INPUT_BUTTON_JUMP(this) = true;
 730                 makevectors(this.v_angle.y * '0 1 0');
 731                 vector v = dir * maxspeed;
 732                 CS(this).movement.x = v * v_forward;
 733                 CS(this).movement.y = v * v_right;
 734                 CS(this).movement.z = v * v_up;
 735         }
 736
 737         // if there is nowhere to go, exit
 738         if (this.goalcurrent == NULL)
 739                 return;
 740
 741
 742         bool locked_goal = false;
 743         if((this.goalentity && wasfreed(this.goalentity))
 744                 || (this.goalcurrent == this.goalentity && this.goalentity.tag_entity))
 745         {
 746                 navigation_clearroute(this);
 747                 navigation_goalrating_timeout_force(this);
 748                 return;
 749         }
 750         else if(this.goalentity.tag_entity)
 751         {
 752                 navigation_goalrating_timeout_expire(this, 2);
 753         }
 754         else if(this.goalentity.bot_pickup)
 755         {
 756                 if(this.goalentity.bot_pickup_respawning)
 757                 {
 758                         if(this.goalentity.solid) // item respawned
 759                                 this.goalentity.bot_pickup_respawning = false;
 760                         else if(time < this.goalentity.scheduledrespawntime - 10) // item already taken (by someone else)
 761                         {
 762                                 if(checkpvs(this.origin, this.goalentity))
 763                                 {
 764                                         this.goalentity.bot_pickup_respawning = false;
 765                                         navigation_goalrating_timeout_expire(this, random());
 766                                 }
 767                                 locked_goal = true; // wait for item to respawn
 768                         }
 769                         else if(this.goalentity == this.goalcurrent)
 770                                 locked_goal = true; // wait for item to respawn
 771                 }
 772                 else if(!this.goalentity.solid && !boxesoverlap(this.goalentity.absmin, this.goalentity.absmax, this.absmin, this.absmax))
 773                 {
 774                         if(checkpvs(this.origin, this.goalentity))
 775                         {
 776                                 navigation_goalrating_timeout_expire(this, random());
 777                         }
 778                 }
 779         }
 780         if (this.goalcurrent == this.goalentity && this.goalentity_lock_timeout > time)
 781                 locked_goal = true;
 782
 783         if (navigation_shortenpath(this))
 784         {
 785                 if (vdist(this.origin - this.goalcurrent_prev.origin, <, 50)
 786                         && navigation_goalrating_timeout_can_be_anticipated(this))
 787                 {
 788                         navigation_goalrating_timeout_force(this);
 789                 }
 790         }
 791
 792         bool goalcurrent_can_be_removed = false;
 793         if (IS_PLAYER(this.goalcurrent) || IS_MONSTER(this.goalcurrent))
 794         {
 795                 bool freeze_state_changed = (boolean(STAT(FROZEN, this.goalentity)) != this.goalentity_shouldbefrozen);
 796                 if (IS_DEAD(this.goalcurrent) || (this.goalentity == this.goalcurrent && freeze_state_changed))
 797                 {
 798                         goalcurrent_can_be_removed = true;
 799                         // don't remove if not visible
 800                         if (checkpvs(this.origin + this.view_ofs, this.goalcurrent))
 801                         {
 802                                 if (IS_DEAD(this.goalcurrent))
 803                                 {
 804                                         IL_EACH(g_items, it.enemy == this.goalcurrent && Item_IsLoot(it),
 805                                         {
 806                                                 if (vdist(it.origin - this.goalcurrent.death_origin, <, 50))
 807                                                 {
 808                                                         navigation_clearroute(this);
 809                                                         navigation_pushroute(this, it);
 810                                                         // loot can't be immediately rated since it isn't on ground yet
 811                                                         // it will be rated after a second when on ground, meanwhile head to it
 812                                                         navigation_goalrating_timeout_expire(this, 1);
 813                                                         return;
 814                                                 }
 815                                         });
 816                                 }
 817                                 if (!Item_IsLoot(this.goalcurrent))
 818                                 {
 819                                         navigation_goalrating_timeout_force(this);
 820                                         return;
 821                                 }
 822                         }
 823                 }
 824                 else if (!(STAT(FROZEN, this.goalentity)) && this.bot_tracewalk_time < time)
 825                 {
 826                         set_tracewalk_dest(this.goalcurrent, this.origin, true);
 827                         if (!(trace_ent == this || tracewalk(this, this.origin, this.mins, this.maxs,
 828                                 tracewalk_dest, tracewalk_dest_height, bot_navigation_movemode)))
 829                         {
 830                                 navigation_goalrating_timeout_force(this);
 831                                 return;
 832                         }
 833                         this.bot_tracewalk_time = max(time, this.bot_tracewalk_time) + 0.25;
 834                 }
 835         }
 836
 837         if(!locked_goal)
 838         {
 839                 // optimize path finding by anticipating goalrating when bot is near a waypoint;
 840                 // in this case path finding can start directly from a waypoint instead of
 841                 // looking for all the reachable waypoints up to a certain distance
 842                 if (navigation_poptouchedgoals(this))
 843                 {
 844                         if (this.goalcurrent)
 845                         {
 846                                 if (goalcurrent_can_be_removed)
 847                                 {
 848                                         // remove even if not visible
 849                                         navigation_goalrating_timeout_force(this);
 850                                         return;
 851                                 }
 852                                 else if (navigation_goalrating_timeout_can_be_anticipated(this))
 853                                         navigation_goalrating_timeout_force(this);
 854                         }
 855                         else
 856                         {
 857                                 entity old_goal = this.goalcurrent_prev;
 858                                 if (old_goal.item_group && this.item_group != old_goal.item_group)
 859                                 {
 860                                         // Avoid multiple costly calls of path finding code that selects one of the closest
 861                                         // item of the group by telling the bot to head directly to the farthest item.
 862                                         // Next time we let the bot select a goal as usual which can be another item
 863                                         // of this group (the closest one) and so on
 864                                         this.item_group = old_goal.item_group;
 865                                         entity new_goal = havocbot_select_an_item_of_group(this, old_goal.item_group);
 866                                         if (new_goal)
 867                                                 navigation_pushroute(this, new_goal);
 868                                 }
 869                         }
 870                 }
 871         }
 872
 873         // if ran out of goals try to use an alternative goal or get a new strategy asap
 874         if(this.goalcurrent == NULL)
 875         {
 876                 navigation_goalrating_timeout_force(this);
 877                 return;
 878         }
 879
 880
 881         if(autocvar_bot_debug_goalstack)
 882                 debuggoalstack(this);
 883
 884         bool bunnyhop_forbidden = false;
 885         vector destorg = get_closer_dest(this.goalcurrent, this.origin);
 886         if (this.jumppadcount && this.goalcurrent.wpflags & WAYPOINTFLAG_TELEPORT)
 887         {
 888                 // if bot used the jumppad, push towards jumppad origin until jumppad waypoint gets removed
 889                 destorg = this.goalcurrent.origin;
 890         }
 891         else if (this.goalcurrent.wpisbox)
 892         {
 893                 // if bot is inside the teleport waypoint, head to teleport origin until teleport gets used
 894                 // do it even if bot is on a ledge above a teleport/jumppad so it doesn't get stuck
 895                 if (boxesoverlap(this.goalcurrent.absmin, this.goalcurrent.absmax, this.origin + eZ * this.mins.z, this.origin + eZ * this.maxs.z)
 896                         || (this.absmin.z > destorg.z && destorg.x == this.origin.x && destorg.y == this.origin.y))
 897                 {
 898                         bunnyhop_forbidden = true;
 899                         destorg = this.goalcurrent.origin;
 900                         if(destorg.z > this.origin.z)
 901                                 PHYS_INPUT_BUTTON_JUMP(this) = true;
 902                 }
 903         }
 904
 905         diff = destorg - this.origin;
 906
 907         if (time < this.bot_stop_moving_timeout
 908                 || (this.goalcurrent == this.goalentity && time < this.goalentity_lock_timeout && vdist(diff, <, 10)))
 909         {
 910                 // stop if the locked goal has been reached
 911                 destorg = this.origin;
 912                 diff = dir = '0 0 0';
 913         }
 914         else if (IS_PLAYER(this.goalcurrent) || IS_MONSTER(this.goalcurrent))
 915         {
 916                 if (vdist(diff, <, 80))
 917                 {
 918                         // stop if too close to target player (even if frozen)
 919                         destorg = this.origin;
 920                         diff = dir = '0 0 0';
 921                 }
 922                 else
 923                 {
 924                         // move destorg out of target players, otherwise bot will consider them
 925                         // an obstacle that needs to be jumped (especially if frozen)
 926                         dir = normalize(diff);
 927                         destorg -= dir * PL_MAX_CONST.x * M_SQRT2;
 928                         diff = destorg - this.origin;
 929                 }
 930         }
 931         else
 932                 dir = normalize(diff);
 933         flatdir = (diff.z == 0) ? dir : normalize(vec2(diff));
 934
 935         bool danger_detected = false;
 936         vector do_break = '0 0 0';
 937
 938         //if (this.bot_dodgevector_time < time)
 939         {
 940                 //this.bot_dodgevector_time = time + cvar("bot_ai_dodgeupdateinterval");
 941                 //this.bot_dodgevector_jumpbutton = 1;
 942
 943                 this.aistatus &= ~AI_STATUS_DANGER_AHEAD;
 944                 makevectors(this.v_angle.y * '0 1 0');
 945                 if (this.waterlevel > WATERLEVEL_WETFEET)
 946                 {
 947                         if (this.waterlevel > WATERLEVEL_SWIMMING)
 948                         {
 949                                 if(!this.goalcurrent)
 950                                         this.aistatus |= AI_STATUS_OUT_WATER;
 951                                 else if(destorg.z > this.origin.z)
 952                                         PHYS_INPUT_BUTTON_JUMP(this) = true;
 953                         }
 954                         else
 955                         {
 956                                 if(this.velocity.z >= 0 && !(this.watertype == CONTENT_WATER && destorg.z < this.origin.z) &&
 957                                         (this.aistatus & AI_STATUS_OUT_WATER))
 958                                 {
 959                                         PHYS_INPUT_BUTTON_JUMP(this) = true;
 960                                         dir = flatdir;
 961                                 }
 962                                 else
 963                                 {
 964                                         if (destorg.z > this.origin.z)
 965                                                 dir = flatdir;
 966                                 }
 967                         }
 968                 }
 969                 else
 970                 {
 971                         float s = 0;
 972                         vector offset;
 973                         if(this.aistatus & AI_STATUS_OUT_WATER)
 974                                 this.aistatus &= ~AI_STATUS_OUT_WATER;
 975
 976                         // jump if going toward an obstacle that doesn't look like stairs we
 977                         // can walk up directly
 978                         vector deviation = '0 0 0';
 979                         float current_speed = vlen(vec2(this.velocity));
 980                         if (current_speed < maxspeed * 0.2)
 981                                 current_speed = maxspeed * 0.2;
 982                         else
 983                         {
 984                                 deviation = vectoangles(diff) - vectoangles(this.velocity);
 985                                 while (deviation.y < -180) deviation.y += 360;
 986                                 while (deviation.y > 180) deviation.y -= 360;
 987                         }
 988                         float turning = false;
 989                         vector flat_diff = vec2(diff);
 990                         offset = max(32, current_speed * cos(deviation.y * DEG2RAD) * 0.3) * flatdir;
 991                         vector actual_destorg = this.origin + offset;
 992                         if (this.goalcurrent_prev && (this.goalcurrent_prev.wpflags & WAYPOINTFLAG_JUMP))
 993                         {
 994                                 if (time > this.bot_stop_moving_timeout
 995                                         && fabs(deviation.y) > 20 && current_speed > maxspeed * 0.4
 996                                         && vdist(vec2(this.origin - this.goalcurrent_prev.origin), <, 50))
 997                                 {
 998                                         this.bot_stop_moving_timeout = time + 0.1;
 999                                 }
1000                                 if (current_speed > autocvar_sv_maxspeed * 0.9
1001                                         && vlen2(flat_diff) < vlen2(vec2(this.goalcurrent_prev.origin - destorg))
1002                                         && vdist(vec2(this.origin - this.goalcurrent_prev.origin), >, 50)
1003                                         && vdist(vec2(this.origin - this.goalcurrent_prev.origin), <, 150)
1004                                 )
1005                                 {
1006                                         PHYS_INPUT_BUTTON_JUMP(this) = true;
1007                                         this.bot_jump_time = time;
1008                                 }
1009                         }
1010                         else if (!this.goalstack01 || (this.goalcurrent.wpflags & (WAYPOINTFLAG_TELEPORT | WAYPOINTFLAG_LADDER)))
1011                         {
1012                                 if (vlen2(flat_diff) < vlen2(offset))
1013                                 {
1014                                         if ((this.goalcurrent.wpflags & WAYPOINTFLAG_JUMP) && this.goalstack01)
1015                                         {
1016                                                 // oblique warpzones need a jump otherwise bots gets stuck
1017                                                 PHYS_INPUT_BUTTON_JUMP(this) = true;
1018                                         }
1019                                         else
1020                                         {
1021                                                 actual_destorg.x = destorg.x;
1022                                                 actual_destorg.y = destorg.y;
1023                                         }
1024                                 }
1025                         }
1026                         else if (vdist(flat_diff, <, 32) && diff.z < -16) // destination is under the bot
1027                         {
1028                                 actual_destorg.x = destorg.x;
1029                                 actual_destorg.y = destorg.y;
1030                         }
1031                         else if (vlen2(flat_diff) < vlen2(offset))
1032                         {
1033                                 vector next_goal_org = (this.goalstack01.absmin + this.goalstack01.absmax) * 0.5;
1034                                 vector next_dir = normalize(vec2(next_goal_org - destorg));
1035                                 float dist = vlen(vec2(this.origin + offset - destorg));
1036                                 // if current and next goal are close to each other make sure
1037                                 // actual_destorg isn't set beyond next_goal_org
1038                                 if (dist ** 2 > vlen2(vec2(next_goal_org - destorg)))
1039                                         actual_destorg = next_goal_org;
1040                                 else
1041                                         actual_destorg = vec2(destorg) + dist * next_dir;
1042                                 actual_destorg.z = this.origin.z;
1043                                 turning = true;
1044                         }
1045
1046                         LABEL(jumpobstacle_check);
1047                         dir = flatdir = normalize(actual_destorg - this.origin);
1048
1049                         bool jump_forbidden = false;
1050                         if (!turning && fabs(deviation.y) > 50)
1051                                 jump_forbidden = true;
1052                         else if (IS_DUCKED(this))
1053                         {
1054                                 tracebox(this.origin, PL_MIN_CONST, PL_MAX_CONST, this.origin, false, this);
1055                                 if (trace_startsolid)
1056                                         jump_forbidden = true;
1057                         }
1058
1059                         if (!jump_forbidden)
1060                         {
1061                                 tracebox(this.origin, this.mins, this.maxs, actual_destorg, false, this);
1062                                 if (trace_fraction < 1 && trace_plane_normal.z < 0.7)
1063                                 {
1064                                         s = trace_fraction;
1065                                         tracebox(this.origin + stepheightvec, this.mins, this.maxs, actual_destorg + stepheightvec, false, this);
1066                                         if (trace_fraction < s + 0.01 && trace_plane_normal.z < 0.7)
1067                                         {
1068                                                 // found an obstacle
1069                                                 if (turning && fabs(deviation.y) > 5)
1070                                                 {
1071                                                         // check if the obstacle is still there without turning
1072                                                         actual_destorg = destorg;
1073                                                         turning = false;
1074                                                         this.bot_tracewalk_time = time + 0.25;
1075                                                         goto jumpobstacle_check;
1076                                                 }
1077                                                 s = trace_fraction;
1078                                                 // don't artificially reduce max jump height in real-time
1079                                                 // (jumpstepheightvec is reduced a bit to make the jumps easy in tracewalk)
1080                                                 vector jump_height = (IS_ONGROUND(this)) ? stepheightvec + jumpheight_vec : jumpstepheightvec;
1081                                                 tracebox(this.origin + jump_height, this.mins, this.maxs, actual_destorg + jump_height, false, this);
1082                                                 if (trace_fraction > s)
1083                                                 {
1084                                                         PHYS_INPUT_BUTTON_JUMP(this) = true;
1085                                                         this.bot_jump_time = time;
1086                                                 }
1087                                                 else
1088                                                 {
1089                                                         jump_height = stepheightvec + jumpheight_vec / 2;
1090                                                         tracebox(this.origin + jump_height, this.mins, this.maxs, actual_destorg + jump_height, false, this);
1091                                                         if (trace_fraction > s)
1092                                                         {
1093                                                                 PHYS_INPUT_BUTTON_JUMP(this) = true;
1094                                                                 this.bot_jump_time = time;
1095                                                         }
1096                                                 }
1097                                         }
1098                                 }
1099                         }
1100
1101                         // if bot for some reason doesn't get close to the current goal find another one
1102                         if(!this.jumppadcount && !IS_PLAYER(this.goalcurrent))
1103                         if(!(locked_goal && this.goalcurrent_distance_z < 50 && this.goalcurrent_distance_2d < 50))
1104                         if(havocbot_checkgoaldistance(this, destorg))
1105                         {
1106                                 if(this.goalcurrent_distance_time < 0) // can't get close for the second time
1107                                 {
1108                                         navigation_clearroute(this);
1109                                         navigation_goalrating_timeout_force(this);
1110                                         return;
1111                                 }
1112
1113                                 set_tracewalk_dest(this.goalcurrent, this.origin, false);
1114                                 if (!tracewalk(this, this.origin, this.mins, this.maxs,
1115                                         tracewalk_dest, tracewalk_dest_height, bot_navigation_movemode))
1116                                 {
1117                                         navigation_clearroute(this);
1118                                         navigation_goalrating_timeout_force(this);
1119                                         return;
1120                                 }
1121
1122                                 // give bot only another chance to prevent bot getting stuck
1123                                 // in case it thinks it can walk but actually can't
1124                                 this.goalcurrent_distance_z = FLOAT_MAX;
1125                                 this.goalcurrent_distance_2d = FLOAT_MAX;
1126                                 this.goalcurrent_distance_time = -time; // mark second try
1127                         }
1128
1129                         if (skill + this.bot_moveskill <= 3 && time > this.bot_stop_moving_timeout
1130                                 && current_speed > maxspeed * 0.9 && fabs(deviation.y) > 70)
1131                         {
1132                                 this.bot_stop_moving_timeout = time + 0.4 + random() * 0.2;
1133                         }
1134
1135                         // Check for water/slime/lava and dangerous edges
1136                         // (only when the bot is on the ground or jumping intentionally)
1137                         offset = (vdist(this.velocity, >, 32) ? this.velocity * 0.2 : flatdir * 32);
1138                         vector dst_ahead = this.origin + this.view_ofs + offset;
1139                         bool unreachable = false;
1140                         if (havocbot_checkdanger(this, dst_ahead))
1141                         {
1142                                 if (destorg.z > this.origin.z + jumpstepheightvec.z)
1143                                 {
1144                                         // the goal is probably on an upper platform, assume bot can't get there
1145                                         unreachable = true;
1146                                 }
1147                                 else
1148                                         danger_detected = true;
1149                         }
1150
1151                         dir = flatdir;
1152                         makevectors(this.v_angle.y * '0 1 0');
1153
1154                         if (danger_detected || (s == CONTENT_WATER))
1155                         {
1156                                 this.aistatus |= AI_STATUS_DANGER_AHEAD;
1157                                 if(IS_PLAYER(this.goalcurrent))
1158                                         unreachable = true;
1159                         }
1160
1161                         // slow down if bot is in the air and goal is under it
1162                         if (!waypoint_is_hardwiredlink(this.goalcurrent_prev, this.goalcurrent)
1163                                 && vdist(flat_diff, <, 250) && this.origin.z - destorg.z > 120
1164                                 && (!IS_ONGROUND(this) || vdist(vec2(this.velocity), >, maxspeed * 0.3)))
1165                         {
1166                                 // tracebox wouldn't work when bot is still on the ledge
1167                                 traceline(this.origin, this.origin - '0 0 200', true, this);
1168                                 if (this.origin.z - trace_endpos.z > 120)
1169                                         do_break = normalize(this.velocity) * -1;
1170                         }
1171
1172                         if(unreachable)
1173                         {
1174                                 navigation_clearroute(this);
1175                                 navigation_goalrating_timeout_force(this);
1176                                 this.ignoregoal = this.goalcurrent;
1177                                 this.ignoregoaltime = time + autocvar_bot_ai_ignoregoal_timeout;
1178                         }
1179                 }
1180
1181                 dodge = havocbot_dodge(this);
1182                 if (dodge)
1183                         dodge *= bound(0, 0.5 + (skill + this.bot_dodgeskill) * 0.1, 1);
1184                 // midair sets moveskill to 0 so avoid jumping when dodging in midair mutator
1185                 if (dodge.z > 0 && this.bot_moveskill == 0)
1186                         dodge.z = 0;
1187                 if (this.enemy)
1188                 {
1189                         traceline(this.origin, (this.enemy.absmin + this.enemy.absmax) * 0.5, true, NULL);
1190                         if (IS_PLAYER(trace_ent))
1191                                 dodge_enemy_factor = bound(0, (skill + this.bot_dodgeskill) / 7, 1);
1192                 }
1193                 //this.bot_dodgevector = dir;
1194                 //this.bot_dodgevector_jumpbutton = PHYS_INPUT_BUTTON_JUMP(this);
1195
1196                 // don't dodge to danger
1197                 if (havocbot_checkdanger(this, this.origin + this.view_ofs + dodge * 32))
1198                 {
1199                         dodge = '0 0 0';
1200                 }
1201         }
1202
1203         float ladder_zdir = 0;
1204         if(this.ladder_entity)
1205         {
1206                 if(this.goalcurrent.origin.z + this.goalcurrent.mins.z > this.origin.z + this.mins.z)
1207                 {
1208                         if(this.origin.z + this.mins.z  < this.ladder_entity.origin.z + this.ladder_entity.maxs.z)
1209                                 ladder_zdir = 1;
1210                 }
1211                 else
1212                 {
1213                         if(this.origin.z + this.mins.z  > this.ladder_entity.origin.z + this.ladder_entity.mins.z)
1214                                 ladder_zdir = -1;
1215                 }
1216                 if (ladder_zdir)
1217                 {
1218                         if (vdist(vec2(diff), <, 40))
1219                                 dir.z = ladder_zdir * 4;
1220                         else
1221                                 dir.z = ladder_zdir * 2;
1222                         dir = normalize(dir);
1223                 }
1224         }
1225
1226         if (this.goalcurrent.wpisbox
1227                 && boxesoverlap(this.goalcurrent.absmin, this.goalcurrent.absmax, this.origin, this.origin))
1228         {
1229                 // bot is inside teleport waypoint but hasn't touched the real teleport yet
1230                 // head to teleport origin
1231                 dir = (this.goalcurrent.origin - this.origin);
1232                 dir.z = 0;
1233                 dir = normalize(dir);
1234         }
1235
1236         // already executed when bot targets an enemy
1237         if (!this.bot_aimdir_executed)
1238         {
1239                 if (time < this.bot_stop_moving_timeout)
1240                         bot_aimdir(this, normalize(this.goalcurrent.origin - this.origin), 0);
1241                 else
1242                         bot_aimdir(this, dir, 0);
1243         }
1244
1245         vector evadedanger = '0 0 0';
1246         if (!ladder_zdir)
1247         {
1248                 dir *= dodge_enemy_factor;
1249                 if (danger_detected && vdist(this.velocity, >, maxspeed * 0.8) && this.goalcurrent_prev
1250                         && this.goalcurrent.classname == "waypoint")
1251                 {
1252                         vector p = this.origin + this.velocity * 0.2;
1253                         vector evadedanger = point_line_vec(p, vec2(this.goalcurrent_prev.origin) + eZ * p.z,
1254                                 vec2(destorg - this.goalcurrent_prev.origin));
1255                         if (vdist(evadedanger, >, 20))
1256                         {
1257                                 if (vdist(evadedanger, >, 40))
1258                                         do_break = normalize(this.velocity) * -1;
1259                                 evadedanger = normalize(evadedanger);
1260                                 evadedanger *= bound(1, 3 - (skill + this.bot_dodgeskill), 3); // Noobs fear dangers a lot and take more distance from them
1261                         }
1262                         else
1263                                 evadedanger = '0 0 0';
1264                 }
1265                 dir = normalize(dir + dodge + do_break + evadedanger);
1266         }
1267
1268         makevectors(this.v_angle);
1269         //dir = this.bot_dodgevector;
1270         //if (this.bot_dodgevector_jumpbutton)
1271         //      PHYS_INPUT_BUTTON_JUMP(this) = true;
1272         CS(this).movement_x = dir * v_forward * maxspeed;
1273         CS(this).movement_y = dir * v_right * maxspeed;
1274         CS(this).movement_z = dir * v_up * maxspeed;
1275
1276         // when high enough skill bots engage in combat they move randomly
1277         if (SUPERBOT && this.aistatus == AI_STATUS_ATTACKING && !dodge)
1278         {
1279                 if (!this.randomdirectiontime || this.randomdirectiontime + 0.35 < time)
1280                 {
1281                         // 75% chance to generate a random direction to follow for
1282                         // 0.3 seconds, there's a 15% chance to fail the generation
1283                         // and only generation attempt one every 0.35s so bots move
1284                         // towards their goal slightly
1285                         if (random() < 0.15)
1286                                 this.randomdirection = '0 0 0';
1287                         else
1288                         {
1289                                 // random values from -1 to 1
1290                                 this.randomdirection.x = crandom() * maxspeed;
1291                                 this.randomdirection.y = crandom() * maxspeed;
1292                                 //this.randomdirection.z = crandom() * maxspeed;
1293                         }
1294
1295                         this.randomdirectiontime = time;
1296                 }
1297                 if (this.randomdirectiontime + 0.3 >= time && this.randomdirection)
1298                 {
1299                         CS(this).movement_x = this.randomdirection.x;
1300                         CS(this).movement_y = this.randomdirection.y;
1301                         // no random vertical direction
1302                 }
1303         }
1304
1305
1306         // Emulate keyboard interface
1307         if (skill < 10)
1308                 havocbot_keyboard_movement(this, destorg);
1309
1310         // Bunnyhop!
1311         if (!bunnyhop_forbidden && !evadedanger && !do_break && skill + this.bot_moveskill >= autocvar_bot_ai_bunnyhop_skilloffset)
1312                 havocbot_bunnyhop(this, dir);
1313
1314         if (dir * v_up >= autocvar_sv_jumpvelocity * 0.5 && IS_ONGROUND(this))
1315                 PHYS_INPUT_BUTTON_JUMP(this) = true;
1316         if (dodge)
1317         {
1318                 if (dodge * v_up > 0 && random() * frametime >= 0.2 * bound(0, (10 - skill - this.bot_dodgeskill) * 0.1, 1))
1319                         PHYS_INPUT_BUTTON_JUMP(this) = true;
1320                 if (dodge * v_up < 0 && random() * frametime >= 0.5 * bound(0, (10 - skill - this.bot_dodgeskill) * 0.1, 1))
1321                 {
1322                         if(IS_ONGROUND(this))
1323                                 PHYS_INPUT_BUTTON_JUMP(this) = false;
1324                         this.havocbot_ducktime = time + 0.3 / bound(0.1, skill + this.bot_dodgeskill, 10);
1325                         PHYS_INPUT_BUTTON_CROUCH(this) = true;
1326                 }
1327         }
1328 }
1329
1330 void havocbot_chooseenemy(entity this)
1331 {
1332         if (autocvar_bot_nofire || IS_INDEPENDENT_PLAYER(this))
1333         {
1334                 this.enemy = NULL;
1335                 return;
1336         }
1337
1338         if (this.enemy)
1339         {
1340                 if (!bot_shouldattack(this, this.enemy))
1341                 {
1342                         // enemy died or something, find a new target
1343                         this.enemy = NULL;
1344                         this.havocbot_chooseenemy_finished = time;
1345                 }
1346                 else if (this.havocbot_stickenemy_time && time < this.havocbot_stickenemy_time)
1347                 {
1348                         // tracking last chosen enemy
1349                         vector targ_pos = (this.enemy.absmin + this.enemy.absmax) * 0.5;
1350                         traceline(this.origin + this.view_ofs, targ_pos, false, NULL);
1351                         if (trace_ent == this.enemy || trace_fraction == 1)
1352                         if (vdist(targ_pos - this.origin, <, 1000))
1353                         {
1354                                 // remain tracking them for a shot while (case they went after a small corner or pilar
1355                                 this.havocbot_chooseenemy_finished = time + 0.5;
1356                                 return;
1357                         }
1358
1359                         // stop preferring this enemy
1360                         this.havocbot_stickenemy_time = 0;
1361                 }
1362         }
1363         if (time < this.havocbot_chooseenemy_finished)
1364                 return;
1365         // don't limit the detection interval to several seconds for bots with enough skill
1366         if (SUPERBOT)
1367                 this.havocbot_chooseenemy_finished = time + 0.1;
1368         else
1369                 this.havocbot_chooseenemy_finished = time + autocvar_bot_ai_enemydetectioninterval;
1370
1371         vector eye = this.origin + this.view_ofs;
1372         entity best = NULL;
1373         float bestrating = autocvar_bot_ai_enemydetectionradius ** 2;
1374
1375         // Backup hit flags
1376         int hf = this.dphitcontentsmask;
1377
1378         // Search for enemies, if no enemy can be seen directly try to look through transparent objects
1379
1380         this.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_CORPSE;
1381
1382         bool scan_transparent = false;
1383         bool scan_secondary_targets = false;
1384         bool have_secondary_targets = false;
1385         while(true)
1386         {
1387                 scan_secondary_targets = false;
1388                 LABEL(scan_targets)
1389                 IL_EACH(g_bot_targets, it.bot_attack,
1390                 {
1391                         if(!scan_secondary_targets)
1392                         {
1393                                 if(it.classname == "misc_breakablemodel")
1394                                 {
1395                                         have_secondary_targets = true;
1396                                         continue;
1397                                 }
1398                         }
1399                         else if(it.classname != "misc_breakablemodel")
1400                                 continue;
1401
1402                         vector v = (it.absmin + it.absmax) * 0.5;
1403                         float distance = vlen2(v - eye);
1404
1405                         if (SUPERBOT)
1406                         {
1407                                 if (bot_shouldattack(this, it))
1408                                 {
1409                                         // skilled enough bots take account target health and distance
1410                                         float health = GetResource(it, RES_HEALTH);
1411                                         float armor  = GetResource(it, RES_ARMOR);
1412                                         float rating = bound(50, health + armor, 250) * distance;
1413                                         if (!best || (rating < bestrating))
1414                                         {
1415                                                 traceline(eye, v, true, this);
1416                                                 if (trace_ent == it || trace_fraction >= 1)
1417                                                 {
1418                                                         best = it;
1419                                                         bestrating = rating;
1420                                                 }
1421                                         }
1422                                 }
1423                         }
1424                         else
1425                         {
1426                                 if (distance < bestrating && bot_shouldattack(this, it))
1427                                 {
1428                                         traceline(eye, v, true, this);
1429                                         if (trace_ent == it || trace_fraction >= 1)
1430                                         {
1431                                                 best = it;
1432                                                 bestrating = distance;
1433                                         }
1434                                 }
1435                         }
1436                 });
1437
1438                 if(!best && have_secondary_targets && !scan_secondary_targets)
1439                 {
1440                         scan_secondary_targets = true;
1441                         // restart the loop
1442                         bestrating = autocvar_bot_ai_enemydetectionradius ** 2;
1443
1444                         goto scan_targets;
1445                 }
1446
1447                 // I want to do a second scan if no enemy was found or I don't have weapons
1448                 // TODO: Perform the scan when using the rifle (requires changes on the rifle code)
1449                 if(best || STAT(WEAPONS, this)) // || this.weapon == WEP_RIFLE.m_id
1450                         break;
1451                 if(scan_transparent)
1452                         break;
1453
1454                 // Set flags to see through transparent objects
1455                 this.dphitcontentsmask |= DPCONTENTS_OPAQUE;
1456
1457                 scan_transparent = true;
1458         }
1459
1460         // Restore hit flags
1461         this.dphitcontentsmask = hf;
1462
1463         this.enemy = best;
1464         this.havocbot_stickenemy_time = time + autocvar_bot_ai_enemydetectioninterval_stickingtoenemy;
1465         if(best && best.classname == "misc_breakablemodel")
1466                 this.havocbot_stickenemy_time = 0;
1467 }
1468
1469 float havocbot_chooseweapon_checkreload(entity this, .entity weaponentity, int new_weapon)
1470 {
1471         // bots under this skill cannot find unloaded weapons to reload idly when not in combat,
1472         // so skip this for them, or they'll never get to reload their weapons at all.
1473         // this also allows bots under this skill to be more stupid, and reload more often during combat :)
1474         if(skill < 5)
1475                 return false;
1476
1477         // if this weapon is scheduled for reloading, don't switch to it during combat
1478         if (this.(weaponentity).weapon_load[new_weapon] < 0)
1479         {
1480                 FOREACH(Weapons, it != WEP_Null, {
1481                         if(it.wr_checkammo1(it, this, weaponentity) + it.wr_checkammo2(it, this, weaponentity))
1482                                 return true; // other weapon available
1483                 });
1484         }
1485
1486         return false;
1487 }
1488
1489 void havocbot_chooseweapon(entity this, .entity weaponentity)
1490 {
1491         int i;
1492         float w;
1493
1494         // ;)
1495         if(g_weaponarena_weapons == WEPSET(TUBA))
1496         {
1497                 this.(weaponentity).m_switchweapon = WEP_TUBA;
1498                 return;
1499         }
1500
1501         // TODO: clean this up by moving it to weapon code
1502         if (this.enemy == NULL)
1503         {
1504                 // Choose the first available weapon from medium range weaponlist
1505                 // TODO: don't do this but don't make bots hold out a blaster out either
1506                 for (i = 0; i < REGISTRY_COUNT(Weapons) && bot_weapons_mid[i] != -1 ; ++i){
1507                         w = bot_weapons_mid[i];
1508                         if (bot_custom_weapon)
1509                         {
1510                                 if (client_hasweapon(this, REGISTRY_GET(Weapons, w), weaponentity, true, false))
1511                                 {
1512                                         if ((this.(weaponentity).m_weapon == WEP_Null) || havocbot_chooseweapon_checkreload(this, weaponentity, w))
1513                                                 continue;
1514                                         this.(weaponentity).m_switchweapon = REGISTRY_GET(Weapons, w);
1515                                         return;
1516                                 }
1517                         }
1518                 }
1519
1520                 // If no weapon was chosen get the first available weapon
1521                 if (this.(weaponentity).m_weapon == WEP_Null)
1522                         FOREACH(Weapons, it != WEP_Null, {
1523                                 if (client_hasweapon(this, it, weaponentity, true, false))
1524                                 {
1525                                         this.(weaponentity).m_switchweapon = it;
1526                                         return;
1527                                 }
1528                         });
1529                 return;
1530         }
1531
1532         // Do not change weapon during the next second after a combo
1533         float f = time - this.lastcombotime;
1534         if(f < 1)
1535                 return;
1536
1537         float distance; distance=bound(10,vlen(this.origin-this.enemy.origin)-200,10000);
1538
1539         // Should it do a weapon combo?
1540         float af, ct, combo_time, combo;
1541
1542         af = ATTACK_FINISHED(this, weaponentity);
1543         ct = autocvar_bot_ai_weapon_combo_threshold;
1544
1545         // Bots with no skill will be 4 times more slower than "godlike" bots when doing weapon combos
1546         // Ideally this 4 should be calculated as longest_weapon_refire / bot_ai_weapon_combo_threshold
1547         combo_time = time + ct + (ct * ((-0.3*(skill+this.bot_weaponskill))+3));
1548
1549         combo = false;
1550
1551         if(autocvar_bot_ai_weapon_combo)
1552         if(this.(weaponentity).m_weapon.m_id == this.(weaponentity).lastfiredweapon)
1553         if(af > combo_time)
1554         {
1555                 combo = true;
1556                 this.lastcombotime = time;
1557         }
1558
1559         distance *= (2 ** this.bot_rangepreference);
1560
1561         // Custom weapon list based on distance to the enemy
1562         if(bot_custom_weapon){
1563
1564                 // Choose weapons for far distance
1565                 if ( distance > bot_distance_far ) {
1566                         for(i=0; i < REGISTRY_COUNT(Weapons) && bot_weapons_far[i] != -1 ; ++i){
1567                                 w = bot_weapons_far[i];
1568                                 if ( client_hasweapon(this, REGISTRY_GET(Weapons, w), weaponentity, true, false) )
1569                                 {
1570                                         if ((this.(weaponentity).m_weapon.m_id == w && combo) || havocbot_chooseweapon_checkreload(this, weaponentity, w))
1571                                                 continue;
1572                                         this.(weaponentity).m_switchweapon = REGISTRY_GET(Weapons, w);
1573                                         return;
1574                                 }
1575                         }
1576                 }
1577
1578                 // Choose weapons for mid distance
1579                 if ( distance > bot_distance_close) {
1580                         for(i=0; i < REGISTRY_COUNT(Weapons) && bot_weapons_mid[i] != -1 ; ++i){
1581                                 w = bot_weapons_mid[i];
1582                                 if ( client_hasweapon(this, REGISTRY_GET(Weapons, w), weaponentity, true, false) )
1583                                 {
1584                                         if ((this.(weaponentity).m_weapon.m_id == w && combo) || havocbot_chooseweapon_checkreload(this, weaponentity, w))
1585                                                 continue;
1586                                         this.(weaponentity).m_switchweapon = REGISTRY_GET(Weapons, w);
1587                                         return;
1588                                 }
1589                         }
1590                 }
1591
1592                 // Choose weapons for close distance
1593                 for(i=0; i < REGISTRY_COUNT(Weapons) && bot_weapons_close[i] != -1 ; ++i){
1594                         w = bot_weapons_close[i];
1595                         if ( client_hasweapon(this, REGISTRY_GET(Weapons, w), weaponentity, true, false) )
1596                         {
1597                                 if ((this.(weaponentity).m_weapon.m_id == w && combo) || havocbot_chooseweapon_checkreload(this, weaponentity, w))
1598                                         continue;
1599                                 this.(weaponentity).m_switchweapon = REGISTRY_GET(Weapons, w);
1600                                 return;
1601                         }
1602                 }
1603         }
1604 }
1605
1606 void havocbot_aim(entity this)
1607 {
1608         // if aim rate is a multiple of think rate due to precision errors the sum of multiple think times
1609         // can be slightly greater than aim time and cause a jump of a whole think time (bot_netxtthink)
1610         // in that case this small tolerance time makes so that aim time snaps to think time
1611         if (time < this.nextaim - 0.01)
1612                 return;
1613         this.nextaim = time + 0.1;
1614
1615         vector myvel = this.velocity;
1616         if (!this.waterlevel)
1617                 myvel.z = 0;
1618         if(MUTATOR_CALLHOOK(HavocBot_Aim, this)) { /* do nothing */ }
1619         else if (this.enemy)
1620         {
1621                 vector enemyvel = this.enemy.velocity;
1622                 if (!this.enemy.waterlevel)
1623                         enemyvel.z = 0;
1624         }
1625 }
1626
1627 bool havocbot_moveto_refresh_route(entity this)
1628 {
1629         // Refresh path to goal if necessary
1630         entity wp;
1631         wp = this.havocbot_personal_waypoint;
1632         navigation_goalrating_start(this);
1633         navigation_routerating(this, wp, 10000, 10000);
1634         navigation_goalrating_end(this);
1635         return (this.goalentity != NULL);
1636 }
1637
1638 float havocbot_moveto(entity this, vector pos)
1639 {
1640         entity wp;
1641
1642         if(this.aistatus & AI_STATUS_WAYPOINT_PERSONAL_GOING)
1643         {
1644                 // Step 4: Move to waypoint
1645                 if(this.havocbot_personal_waypoint==NULL)
1646                 {
1647                         LOG_TRACE("Error: ", this.netname, " trying to walk to a non existent personal waypoint");
1648                         this.aistatus &= ~AI_STATUS_WAYPOINT_PERSONAL_GOING;
1649                         return CMD_STATUS_ERROR;
1650                 }
1651
1652                 if (!bot_strategytoken_taken)
1653                 if(this.havocbot_personal_waypoint_searchtime<time)
1654                 {
1655                         bot_strategytoken_taken = true;
1656                         if(havocbot_moveto_refresh_route(this))
1657                         {
1658                                 LOG_TRACE(this.netname, " walking to its personal waypoint (after ", ftos(this.havocbot_personal_waypoint_failcounter), " failed attempts)");
1659                                 this.havocbot_personal_waypoint_searchtime = time + 10;
1660                                 this.havocbot_personal_waypoint_failcounter = 0;
1661                         }
1662                         else
1663                         {
1664                                 this.havocbot_personal_waypoint_failcounter += 1;
1665                                 this.havocbot_personal_waypoint_searchtime = time + 2;
1666                                 if(this.havocbot_personal_waypoint_failcounter >= 30)
1667                                 {
1668                                         LOG_TRACE("Warning: can't walk to the personal waypoint located at ", vtos(this.havocbot_personal_waypoint.origin));
1669                                         this.aistatus &= ~AI_STATUS_WAYPOINT_PERSONAL_LINKING;
1670                                         delete(this.havocbot_personal_waypoint);
1671                                         return CMD_STATUS_ERROR;
1672                                 }
1673                                 else
1674                                         LOG_TRACE(this.netname, " can't walk to its personal waypoint (after ", ftos(this.havocbot_personal_waypoint_failcounter), " failed attempts), trying later");
1675                         }
1676                 }
1677
1678                 if(autocvar_bot_debug_goalstack)
1679                         debuggoalstack(this);
1680
1681
1682                 // Go!
1683                 havocbot_movetogoal(this);
1684
1685                 if (!this.bot_aimdir_executed && this.goalcurrent)
1686                 {
1687                         // Heading
1688                         vector dir = get_closer_dest(this.goalcurrent, this.origin);
1689                         dir -= this.origin + this.view_ofs;
1690                         dir.z = 0;
1691                         bot_aimdir(this, dir, 0);
1692                 }
1693
1694                 if(this.aistatus & AI_STATUS_WAYPOINT_PERSONAL_REACHED)
1695                 {
1696                         // Step 5: Waypoint reached
1697                         LOG_TRACE(this.netname, "'s personal waypoint reached");
1698                         waypoint_remove(this.havocbot_personal_waypoint);
1699                         this.aistatus &= ~AI_STATUS_WAYPOINT_PERSONAL_REACHED;
1700                         return CMD_STATUS_FINISHED;
1701                 }
1702
1703                 return CMD_STATUS_EXECUTING;
1704         }
1705
1706         // Step 2: Linking waypoint
1707         if(this.aistatus & AI_STATUS_WAYPOINT_PERSONAL_LINKING)
1708         {
1709                 // Wait until it is linked
1710                 if(!this.havocbot_personal_waypoint.wplinked)
1711                 {
1712                         LOG_TRACE(this.netname, " waiting for personal waypoint to be linked");
1713                         return CMD_STATUS_EXECUTING;
1714                 }
1715
1716                 this.havocbot_personal_waypoint_searchtime = time; // so we set the route next frame
1717                 this.aistatus &= ~AI_STATUS_WAYPOINT_PERSONAL_LINKING;
1718                 this.aistatus |= AI_STATUS_WAYPOINT_PERSONAL_GOING;
1719
1720                 // Step 3: Route to waypoint
1721                 LOG_TRACE(this.netname, " walking to its personal waypoint");
1722
1723                 return CMD_STATUS_EXECUTING;
1724         }
1725
1726         // Step 1: Spawning waypoint
1727         wp = waypoint_spawnpersonal(this, pos);
1728         if(wp==NULL)
1729         {
1730                 LOG_TRACE("Error: Can't spawn personal waypoint at ",vtos(pos));
1731                 return CMD_STATUS_ERROR;
1732         }
1733
1734         this.havocbot_personal_waypoint = wp;
1735         this.havocbot_personal_waypoint_failcounter = 0;
1736         this.aistatus |= AI_STATUS_WAYPOINT_PERSONAL_LINKING;
1737
1738         // if pos is inside a teleport, then let's mark it as teleport waypoint
1739         IL_EACH(g_teleporters, WarpZoneLib_BoxTouchesBrush(pos, pos, it, NULL),
1740         {
1741                 wp.wpflags |= WAYPOINTFLAG_TELEPORT;
1742                 this.lastteleporttime = 0;
1743         });
1744
1745 /*
1746         if(wp.wpflags & WAYPOINTFLAG_TELEPORT)
1747                 print("routing to a teleporter\n");
1748         else
1749                 print("routing to a non-teleporter\n");
1750 */
1751
1752         return CMD_STATUS_EXECUTING;
1753 }
1754
1755 float havocbot_resetgoal(entity this)
1756 {
1757         navigation_clearroute(this);
1758         return CMD_STATUS_FINISHED;
1759 }
1760
1761 void havocbot_setupbot(entity this)
1762 {
1763         this.bot_ai = havocbot_ai;
1764         this.cmd_moveto = havocbot_moveto;
1765         this.cmd_resetgoal = havocbot_resetgoal;
1766
1767         // NOTE: bot is not player yet
1768         havocbot_chooserole(this);
1769 }
1770
1771 vector havocbot_dodge(entity this)
1772 {
1773         // LordHavoc: disabled because this is too expensive
1774         // Dr. Jaska: re-enable this but only for bots with high enough skill
1775         if (!SUPERBOT)
1776                 return '0 0 0';
1777
1778 #if 1
1779         entity head;
1780         vector dodge, v, n;
1781         float danger, bestdanger, vl, d;
1782         dodge = '0 0 0';
1783         bestdanger = -20;
1784         // check for dangerous objects near bot or approaching bot
1785         head = findchainfloat(bot_dodge, true);
1786         while(head)
1787         {
1788                 if (head.owner != this)
1789                 {
1790                         vl = vlen(head.velocity);
1791                         if (vl > autocvar_sv_maxspeed * 0.3)
1792                         {
1793                                 n = normalize(head.velocity);
1794                                 v = this.origin - head.origin;
1795                                 d = v * n;
1796                                 if (d > (0 - head.bot_dodgerating))
1797                                 if (d < (vl * 0.2 + head.bot_dodgerating))
1798                                 {
1799                                         // calculate direction and distance from the
1800                                         // flight path by removing the forward axis
1801                                         v = v - (n * (v * n));
1802                                         danger = head.bot_dodgerating - vlen(v);
1803                                         if (bestdanger < danger)
1804                                         {
1805                                                 bestdanger = danger;
1806                                                 // dodge to the side of the object
1807                                                 dodge = normalize(v);
1808                                         }
1809                                 }
1810                         }
1811                         else
1812                         {
1813                                 danger = head.bot_dodgerating - vlen(head.origin - this.origin);
1814                                 if (bestdanger < danger)
1815                                 {
1816                                         bestdanger = danger;
1817                                         dodge = normalize(this.origin - head.origin);
1818                                 }
1819                         }
1820                 }
1821                 head = head.chain;
1822         }
1823         return dodge;
1824 #else
1825         return '0 0 0';
1826 #endif
1827 }