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