some missing files; g_race_qualifying is still broken (ignores fraglimit, no idea...
[divverent/nexuiz.git] / data / qcsrc / server / havocbot_roles.qc
1
2 .float havocbot_role_timeout;
3 .void() havocbot_previous_role;
4 .float bot_strategytime;
5 .void() havocbot_role;
6 float bot_ignore_bots;
7
8 float canreach(entity e)
9 {
10         return vlen(self.origin - e.origin) < 1500;
11 }
12
13 void havocbot_goalrating_items(float ratingscale, vector org, float sradius)
14 {
15         local entity head;
16         local float t;
17         ratingscale = ratingscale * 0.0001; // items are rated around 10000 already
18         head = findchainfloat(bot_pickup, TRUE);
19         while (head)
20         {
21                 if (head.solid) // must be possible to pick up (respawning items don't count)
22                 if (vlen(head.origin - org) < sradius)
23                 {
24                         // debugging
25                         //if (!head.bot_pickupevalfunc || head.model == "")
26                         //      eprint(head);
27                         // get the value of the item
28                         t = head.bot_pickupevalfunc(self, head);
29                         if (t > 0)
30                                 navigation_routerating(head, t * ratingscale, 2000);
31                 }
32                 head = head.chain;
33         }
34 };
35
36 void havocbot_goalrating_controlpoints(float ratingscale, vector org, float sradius)
37 {
38         local entity head;
39         head = findchain(classname, "dom_controlpoint");
40         while (head)
41         {
42                 if (vlen(head.origin - org) < sradius)
43                 {
44                         if(head.cnt > -1) // this is just being fought for
45                                 navigation_routerating(head, ratingscale, 5000);
46                         else if(head.goalentity.cnt == 0) // unclaimed point
47                                 navigation_routerating(head, ratingscale * 0.5, 5000);
48                         else if(head.goalentity.team != self.team) // other team's point
49                                 navigation_routerating(head, ratingscale * 0.2, 5000);
50                 }
51                 head = head.chain;
52         }
53 };
54
55 /*
56 // LordHavoc: this function was already unused, but for waypoints to be a
57 // useful goal the bots would have to seek out the least-recently-visited
58 // ones, not the closest
59 void havocbot_goalrating_waypoints(float ratingscale, vector org, float sradius)
60 {
61         local entity head;
62         head = findchain(classname, "waypoint");
63         while (head)
64         {
65                 if (vlen(head.origin - org) < sradius && vlen(head.origin - org) > 100)
66                         navigation_routerating(head, ratingscale, 2000);
67                 head = head.chain;
68         }
69 };
70 */
71
72 void havocbot_goalrating_enemyplayers(float ratingscale, vector org, float sradius)
73 {
74         local entity head;
75         local float t, noteam;
76         noteam = ((self.team == 0) || (teamplay == 0)); // fteqcc sucks
77         //dprint("teamplay is "); dprint(ftos(teamplay)); dprint(", own team is ");
78         //dprint(ftos(self.team)); dprint(" -> noteam is "); dprint(ftos(noteam));
79         //dprint("\n");
80
81         FOR_EACH_PLAYER(head)
82         {
83                 if (self != head)
84                 if (head.health > 0)
85                 if ((noteam && (!bot_ignore_bots || clienttype(head) == CLIENTTYPE_REAL)) || head.team != self.team)
86                 if (vlen(head.origin - org) < sradius)
87                 {
88                         t = 100 / (head.health + head.armorvalue);
89                         if (t > 0)
90                         {
91                                 //dprint("found: "); dprint(head.netname); dprint("\n");
92                                 navigation_routerating(head, t * ratingscale, 500);
93                         }
94                 }
95         }
96 };
97
98
99 void() havocbot_role_ctf_middle;
100 void() havocbot_role_ctf_defense;
101 void() havocbot_role_ctf_offense;
102 void() havocbot_role_ctf_interceptor;
103
104 void havocbot_goalrating_ctf_carrieritems(float ratingscale, vector org, float sradius)
105 {
106         local entity head;
107         local float t;
108         head = findchainfloat(bot_pickup, TRUE);
109         while (head)
110         {
111                 // look for health and armor only
112                 if (head.solid) // must be possible to pick up (respawning items don't count)
113                 if (head.health || head.armorvalue)
114                 if (vlen(head.origin - org) < sradius)
115                 {
116                         // debugging
117                         //if (!head.bot_pickupevalfunc || head.model == "")
118                         //      eprint(head);
119                         // get the value of the item
120                         t = head.bot_pickupevalfunc(self, head) * 0.0001;
121                         if (t > 0)
122                                 navigation_routerating(head, t * ratingscale, 500);
123                 }
124                 head = head.chain;
125         }
126 };
127
128 entity ctf_worldflaglist;
129 .entity ctf_worldflagnext;
130 void havocbot_goalrating_ctf_ourflag(float ratingscale)
131 {
132         local entity head;
133         head = ctf_worldflaglist;
134         while (head)
135         {
136                 if (self.team == head.team)
137                         break;
138                 head = head.ctf_worldflagnext;
139         }
140         if (head)
141                 navigation_routerating(head, ratingscale, 10000);
142 };
143
144 void havocbot_goalrating_ctf_enemyflag(float ratingscale)
145 {
146         local entity head;
147         head = ctf_worldflaglist;
148         while (head)
149         {
150                 if (self.team != head.team)
151                         break;
152                 head = head.ctf_worldflagnext;
153         }
154         if (head)
155                 navigation_routerating(head, ratingscale, 10000);
156 };
157
158 void havocbot_goalrating_ctf_enemybase(float ratingscale)
159 {
160         // div0: needs a change in the CTF code
161 };
162
163 void havocbot_goalrating_ctf_ourstolenflag(float ratingscale)
164 {
165         local entity head;
166         head = ctf_worldflaglist;
167         while (head)
168         {
169                 if (self.team == head.team)
170                         break;
171                 head = head.ctf_worldflagnext;
172         }
173         if (head)
174         if (head.cnt != FLAG_BASE)
175                 navigation_routerating(head, ratingscale, 10000);
176 };
177
178 void havocbot_goalrating_ctf_droppedflags(float ratingscale)
179 {
180         local entity head;
181         head = ctf_worldflaglist;
182         while (head)
183         {
184                 if (head.cnt != FLAG_BASE) // flag is carried or out in the field
185                         navigation_routerating(head, ratingscale, 10000);
186                 head = head.ctf_worldflagnext;
187         }
188 };
189
190 // CTF: (always teamplay)
191
192 //role rogue: (is this used?)
193 //pick up items and dropped flags (with big rating boost to dropped flags)
194 void havocbot_role_ctf_rogue()
195 {
196         if (self.bot_strategytime < time)
197         {
198                 self.bot_strategytime = time + cvar("bot_ai_strategyinterval");
199                 navigation_goalrating_start();
200                 havocbot_goalrating_ctf_droppedflags(5000);
201                 //havocbot_goalrating_enemyplayers(3000, self.origin, 3000);
202                 havocbot_goalrating_items(10000, self.origin, 10000);
203                 navigation_goalrating_end();
204         }
205 }
206
207 //role flag carrier:
208 //pick up armor and health
209 //go to our flag spot
210 .float bot_cantfindflag;
211 void havocbot_role_ctf_carrier()
212 {
213         if (self.flagcarried == world)
214         {
215                 dprint("changing role to middle\n");
216                 self.havocbot_role = havocbot_role_ctf_middle;
217                 self.havocbot_role_timeout = 0;
218                 return;
219         }
220         if (self.bot_strategytime < time)
221         {
222                 self.bot_strategytime = time + cvar("bot_ai_strategyinterval");
223                 navigation_goalrating_start();
224                 havocbot_goalrating_ctf_ourflag(50000);
225                 if (navigation_bestgoal)
226                         self.bot_cantfindflag = time + 10;
227                 else if (time > self.bot_cantfindflag)
228                 {
229                         // can't navigate to our own flag :(
230                         Damage(self, self, self, 100000, DEATH_KILL, self.origin, '0 0 0');
231                 }
232                 havocbot_goalrating_ctf_carrieritems(1000, self.origin, 1000);
233                 navigation_goalrating_end();
234         }
235 };
236
237 //role offense:
238 //pick up armor and health
239 //if rockets < 25 || health < 100, change role to middle
240 //if carrying flag, change role to flag carrier
241 //if our flag taken, change role to interceptor
242 //(60-90 second timer) change role to middle
243 //go to enemy flag
244 void havocbot_role_ctf_offense()
245 {
246         local entity f;
247         if (self.flagcarried)
248         {
249                 dprint("changing role to carrier\n");
250                 self.havocbot_role = havocbot_role_ctf_carrier;
251                 self.havocbot_role_timeout = 0;
252                 self.bot_cantfindflag = time + 10;
253                 return;
254         }
255         // check our flag
256         f = ctf_worldflaglist;
257         while (f)
258         {
259                 if (self.team == f.team)
260                         break;
261                 f = f.ctf_worldflagnext;
262         }
263         if (f.cnt != FLAG_BASE && canreach(f))
264         {
265                 dprint("changing role to interceptor\n");
266                 self.havocbot_previous_role = self.havocbot_role;
267                 self.havocbot_role = havocbot_role_ctf_interceptor;
268                 self.havocbot_role_timeout = 0;
269                 return;
270         }
271         if (!self.havocbot_role_timeout)
272                 self.havocbot_role_timeout = time + random() * 30 + 60;
273         if (time > self.havocbot_role_timeout)
274         {
275                 dprint("changing role to middle\n");
276                 self.havocbot_role = havocbot_role_ctf_middle;
277                 self.havocbot_role_timeout = 0;
278                 return;
279         }
280         if (self.bot_strategytime < time)
281         {
282                 self.bot_strategytime = time + cvar("bot_ai_strategyinterval");
283                 navigation_goalrating_start();
284                 havocbot_goalrating_ctf_ourstolenflag(50000);
285                 havocbot_goalrating_ctf_enemyflag(30000);
286                 havocbot_goalrating_ctf_enemybase(20000);
287                 havocbot_goalrating_items(10000, self.origin, 10000);
288                 navigation_goalrating_end();
289         }
290 };
291
292 //role interceptor (temporary role):
293 //pick up items
294 //if carrying flag, change role to flag carrier
295 //if our flag is back, change role to previous role
296 //follow our flag
297 //go to least recently visited area
298 void havocbot_role_ctf_interceptor()
299 {
300         local entity f;
301         if (self.flagcarried)
302         {
303                 dprint("changing role to carrier\n");
304                 self.havocbot_role = havocbot_role_ctf_carrier;
305                 self.havocbot_role_timeout = 0;
306                 self.bot_cantfindflag = time + 10;
307                 return;
308         }
309         // check our flag
310         f = ctf_worldflaglist;
311         while (f)
312         {
313                 if (self.team == f.team)
314                         break;
315                 f = f.ctf_worldflagnext;
316         }
317         if (f.cnt == FLAG_BASE)
318         {
319                 dprint("changing role back\n");
320                 self.havocbot_role = self.havocbot_previous_role;
321                 self.havocbot_role_timeout = 0;
322                 return;
323         }
324
325         if (self.bot_strategytime < time)
326         {
327                 self.bot_strategytime = time + cvar("bot_ai_strategyinterval");
328                 navigation_goalrating_start();
329                 havocbot_goalrating_ctf_ourstolenflag(50000);
330                 havocbot_goalrating_ctf_droppedflags(50000);
331                 havocbot_goalrating_items(10000, self.origin, 10000);
332                 navigation_goalrating_end();
333         }
334 };
335
336 //role middle:
337 //pick up items
338 //if carrying flag, change role to flag carrier
339 //if our flag taken, change role to interceptor
340 //if see flag (of either team) follow it (this has many implications)
341 //(10-20 second timer) change role to defense or offense
342 //go to least recently visited area
343 void havocbot_role_ctf_middle()
344 {
345         local entity f;
346         if (self.flagcarried)
347         {
348                 dprint("changing role to carrier\n");
349                 self.havocbot_role = havocbot_role_ctf_carrier;
350                 self.havocbot_role_timeout = 0;
351                 self.bot_cantfindflag = time + 10;
352                 return;
353         }
354         // check our flag
355         f = ctf_worldflaglist;
356         while (f)
357         {
358                 if (self.team == f.team)
359                         break;
360                 f = f.ctf_worldflagnext;
361         }
362         if (f.cnt != FLAG_BASE && canreach(f))
363         {
364                 dprint("changing role to interceptor\n");
365                 self.havocbot_previous_role = self.havocbot_role;
366                 self.havocbot_role = havocbot_role_ctf_interceptor;
367                 self.havocbot_role_timeout = 0;
368                 return;
369         }
370         if (!self.havocbot_role_timeout)
371                 self.havocbot_role_timeout = time + random() * 10 + 10;
372         if (time > self.havocbot_role_timeout)
373         {
374                 if (random() < 0.5)
375                 {
376                         dprint("changing role to offense\n");
377                         self.havocbot_role = havocbot_role_ctf_offense;
378                 }
379                 else
380                 {
381                         dprint("changing role to defense\n");
382                         self.havocbot_role = havocbot_role_ctf_defense;
383                 }
384                 self.havocbot_role_timeout = 0;
385                 return;
386         }
387
388         if (self.bot_strategytime < time)
389         {
390                 self.bot_strategytime = time + cvar("bot_ai_strategyinterval");
391                 navigation_goalrating_start();
392                 havocbot_goalrating_ctf_ourstolenflag(50000);
393                 havocbot_goalrating_ctf_droppedflags(30000);
394                 //havocbot_goalrating_enemyplayers(1000, self.origin, 1000);
395                 havocbot_goalrating_items(10000, self.origin, 10000);
396                 navigation_goalrating_end();
397         }
398 };
399
400 //role defense:
401 //if rockets < 25 || health < 100, change role to middle
402 //if carrying flag, change role to flag carrier
403 //if our flag taken, change role to interceptor
404 //(30-50 second timer) change role to middle
405 //move to nearest unclaimed defense spot
406 void havocbot_role_ctf_defense()
407 {
408         local entity f;
409         if (self.flagcarried)
410         {
411                 dprint("changing role to carrier\n");
412                 self.havocbot_role = havocbot_role_ctf_carrier;
413                 self.havocbot_role_timeout = 0;
414                 self.bot_cantfindflag = time + 10;
415                 return;
416         }
417         // check our flag
418         f = ctf_worldflaglist;
419         while (f)
420         {
421                 if (self.team == f.team)
422                         break;
423                 f = f.ctf_worldflagnext;
424         }
425         if (f.cnt != FLAG_BASE && canreach(f))
426         {
427                 dprint("changing role to interceptor\n");
428                 self.havocbot_previous_role = self.havocbot_role;
429                 self.havocbot_role = havocbot_role_ctf_interceptor;
430                 self.havocbot_role_timeout = 0;
431                 return;
432         }
433         if (!self.havocbot_role_timeout)
434                 self.havocbot_role_timeout = time + random() * 20 + 30;
435         if (time > self.havocbot_role_timeout)
436         {
437                 dprint("changing role to middle\n");
438                 self.havocbot_role = havocbot_role_ctf_middle;
439                 self.havocbot_role_timeout = 0;
440                 return;
441         }
442         if (self.bot_strategytime < time)
443         {
444                 self.bot_strategytime = time + cvar("bot_ai_strategyinterval");
445                 navigation_goalrating_start();
446                 havocbot_goalrating_ctf_ourstolenflag(200000);
447                 havocbot_goalrating_ctf_droppedflags(50000);
448                 havocbot_goalrating_items(10000, f.origin, 10000);
449                 navigation_goalrating_end();
450         }
451         /*
452         // FIXME: place info_ctf_defensepoint entities in CTF maps and use them
453         // change position occasionally
454         if (time > self.bot_strategytime || self.goalentity.classname != "info_ctf_defensepoint")
455         {
456                 self.bot_strategytime = time + random() * 45 + 15;
457                 self.goalentity = world;
458                 head = findchain(classname, "info_ctf_defensepoint");
459                 while (head)
460                 {
461                         if (time > head.count)
462                         {
463                                 self.goalentity = head;
464                                 head.chain = world;
465                         }
466                         head = head.chain;
467                 }
468                 // if there are no defensepoints defined, switch to middle
469                 if (self.goalentity == world)
470                 {
471                         dprint("changing role to middle\n");
472                         self.havocbot_role = havocbot_role_ctf_middle;
473                         self.havocbot_role_timeout = 0;
474                         return;
475                 }
476         }
477         // keep anyone else from taking this spot
478         if (self.goalentity != world)
479                 self.goalentity.count = time + 0.5;
480         */
481 };
482
483 // CTF:
484 // choose a role according to the situation
485 void() havocbot_role_dm;
486 void havocbot_chooserole_ctf()
487 {
488         local float r;
489         dprint("choose CTF role...\n");
490         if (self.team == COLOR_TEAM3 || self.team == COLOR_TEAM4)
491                 self.havocbot_role = havocbot_role_ctf_rogue;
492         else
493         {
494                 r = random() * 3;
495                 if (r < 1)
496                         self.havocbot_role = havocbot_role_ctf_offense;
497                 else if (r < 2)
498                         self.havocbot_role = havocbot_role_ctf_middle;
499                 else
500                         self.havocbot_role = havocbot_role_ctf_defense;
501         }
502 };
503
504 //DOM:
505 //go to best items, or control points you don't own
506 void havocbot_role_dom()
507 {
508         if (self.bot_strategytime < time)
509         {
510                 self.bot_strategytime = time + cvar("bot_ai_strategyinterval");
511                 navigation_goalrating_start();
512                 havocbot_goalrating_controlpoints(10000, self.origin, 15000);
513                 havocbot_goalrating_items(8000, self.origin, 8000);
514                 //havocbot_goalrating_enemyplayers(3000, self.origin, 2000);
515                 //havocbot_goalrating_waypoints(1, self.origin, 1000);
516                 navigation_goalrating_end();
517         }
518 };
519
520 //DM:
521 //go to best items
522 void havocbot_role_dm()
523 {
524         if (self.bot_strategytime < time)
525         {
526                 self.bot_strategytime = time + cvar("bot_ai_strategyinterval");
527                 navigation_goalrating_start();
528                 havocbot_goalrating_items(10000, self.origin, 10000);
529                 havocbot_goalrating_enemyplayers(5000, self.origin, 20000);
530                 //havocbot_goalrating_waypoints(1, self.origin, 1000);
531                 navigation_goalrating_end();
532         }
533 };
534
535 //Race:
536 //go to next checkpoint, and annoy enemies
537 .float race_checkpoint;
538 void havocbot_role_race()
539 {
540         entity e;
541         if (self.bot_strategytime < time)
542         {
543                 self.bot_strategytime = time + cvar("bot_ai_strategyinterval");
544                 navigation_goalrating_start();
545                 /*
546                 havocbot_goalrating_items(100, self.origin, 10000);
547                 havocbot_goalrating_enemyplayers(500, self.origin, 20000);
548                 */
549
550                 for(e = world; (e = find(e, classname, "trigger_race_checkpoint")) != world; )
551                 {
552                         if(e.cnt == self.race_checkpoint)
553                         {
554                                 navigation_routerating(e, 1000000, 5000);
555                         }
556                         else if(self.race_checkpoint == -1)
557                         {
558                                 navigation_routerating(e, 1000000, 5000);
559                         }
560                 }
561                 
562                 navigation_goalrating_end();
563         }
564 };
565
566 void havocbot_chooserole_dm()
567 {
568         self.havocbot_role = havocbot_role_dm;
569 };
570
571 void havocbot_chooserole_race()
572 {
573         self.havocbot_role = havocbot_role_race;
574 };
575
576 void havocbot_chooserole_dom()
577 {
578         self.havocbot_role = havocbot_role_dom;
579 };
580
581
582
583
584
585
586 entity kh_worldkeylist;
587 .entity kh_worldkeynext;
588 void havocbot_goalrating_kh(float ratingscale_team, float ratingscale_dropped, float ratingscale_enemy)
589 {
590         local entity head;
591         for (head = kh_worldkeylist; head; head = head.kh_worldkeynext)
592         {
593                 if(head.owner == self)
594                         continue;
595                 if(!kh_tracking_enabled)
596                 {
597                         // if it's carried by our team we know about it
598                         // otherwise we have to see it to know about it
599                         if(!head.owner || head.team != self.team)
600                         {
601                                 traceline(self.origin + self.view_ofs, head.origin, MOVE_NOMONSTERS, self);
602                                 if (trace_fraction < 1 && trace_ent != head)
603                                         continue; // skip what I can't see
604                         }
605                 }
606                 if(!head.owner)
607                         navigation_routerating(head, ratingscale_dropped, 100000);
608                 else if(head.team == self.team)
609                         navigation_routerating(head, ratingscale_team, 100000);
610                 else
611                         navigation_routerating(head, ratingscale_enemy, 100000);
612         }
613 };
614
615 void() havocbot_role_kh_carrier;
616 void() havocbot_role_kh_defense;
617 void() havocbot_role_kh_offense;
618 void() havocbot_role_kh_freelancer;
619 void havocbot_role_kh_carrier()
620 {
621         if (!(self.items & IT_KEY1))
622         {
623                 dprint("changing role to freelancer\n");
624                 self.havocbot_role = havocbot_role_kh_freelancer;
625                 self.havocbot_role_timeout = 0;
626                 return;
627         }
628
629         if (self.bot_strategytime < time)
630         {
631                 self.bot_strategytime = time + cvar("bot_ai_strategyinterval");
632                 navigation_goalrating_start();
633
634                 if(kh_Key_AllOwnedByWhichTeam() == self.team)
635                         havocbot_goalrating_kh(100000, 1, 1); // bring home
636                 else
637                         havocbot_goalrating_kh(40000, 40000, 1000); // play defensively
638
639                 havocbot_goalrating_items(10000, self.origin, 10000);
640                 navigation_goalrating_end();
641         }
642 }
643
644 void havocbot_role_kh_defense()
645 {
646         if (self.items & IT_KEY1)
647         {
648                 dprint("changing role to carrier\n");
649                 self.havocbot_role = havocbot_role_kh_carrier;
650                 self.havocbot_role_timeout = 0;
651                 return;
652         }
653
654         if (!self.havocbot_role_timeout)
655                 self.havocbot_role_timeout = time + random() * 10 + 20;
656         if (time > self.havocbot_role_timeout)
657         {
658                 dprint("changing role to freelancer\n");
659                 self.havocbot_role = havocbot_role_kh_freelancer;
660                 self.havocbot_role_timeout = 0;
661                 return;
662         }
663
664         if (self.bot_strategytime < time)
665         {
666                 float key_owner_team;
667                 self.bot_strategytime = time + cvar("bot_ai_strategyinterval");
668                 navigation_goalrating_start();
669
670                 key_owner_team = kh_Key_AllOwnedByWhichTeam();
671                 if(key_owner_team == self.team)
672                         havocbot_goalrating_kh(100000, 1, 1); // defend key carriers
673                 else if(key_owner_team == -1)
674                         havocbot_goalrating_kh(40000, 10000, 1); // play defensively
675                 else
676                         havocbot_goalrating_kh(1, 1, 100000); // ATTACK ANYWAY
677
678                 havocbot_goalrating_items(10000, self.origin, 10000);
679                 navigation_goalrating_end();
680         }
681 };
682
683 void havocbot_role_kh_offense()
684 {
685         if (self.items & IT_KEY1)
686         {
687                 dprint("changing role to carrier\n");
688                 self.havocbot_role = havocbot_role_kh_carrier;
689                 self.havocbot_role_timeout = 0;
690                 return;
691         }
692
693         if (!self.havocbot_role_timeout)
694                 self.havocbot_role_timeout = time + random() * 10 + 20;
695         if (time > self.havocbot_role_timeout)
696         {
697                 dprint("changing role to freelancer\n");
698                 self.havocbot_role = havocbot_role_kh_freelancer;
699                 self.havocbot_role_timeout = 0;
700                 return;
701         }
702
703         if (self.bot_strategytime < time)
704         {
705                 float key_owner_team;
706
707                 self.bot_strategytime = time + cvar("bot_ai_strategyinterval");
708                 navigation_goalrating_start();
709
710                 key_owner_team = kh_Key_AllOwnedByWhichTeam();
711                 if(key_owner_team == self.team)
712                         havocbot_goalrating_kh(100000, 1, 1); // defend anyway
713                 else if(key_owner_team == -1)
714                         havocbot_goalrating_kh(1, 10000, 40000); // play offensively
715                 else
716                         havocbot_goalrating_kh(1, 1, 100000); // ATTACK! EMERGENCY!
717
718                 havocbot_goalrating_items(10000, self.origin, 10000);
719                 navigation_goalrating_end();
720         }
721 };
722
723 void havocbot_role_kh_freelancer()
724 {
725         if (self.items & IT_KEY1)
726         {
727                 dprint("changing role to carrier\n");
728                 self.havocbot_role = havocbot_role_kh_carrier;
729                 self.havocbot_role_timeout = 0;
730                 return;
731         }
732
733         if (!self.havocbot_role_timeout)
734                 self.havocbot_role_timeout = time + random() * 10 + 10;
735         if (time > self.havocbot_role_timeout)
736         {
737                 if (random() < 0.5)
738                 {
739                         dprint("changing role to offense\n");
740                         self.havocbot_role = havocbot_role_kh_offense;
741                 }
742                 else
743                 {
744                         dprint("changing role to defense\n");
745                         self.havocbot_role = havocbot_role_kh_defense;
746                 }
747                 self.havocbot_role_timeout = 0;
748                 return;
749         }
750
751         if (self.bot_strategytime < time)
752         {
753                 float key_owner_team;
754
755                 self.bot_strategytime = time + cvar("bot_ai_strategyinterval");
756                 navigation_goalrating_start();
757
758                 key_owner_team = kh_Key_AllOwnedByWhichTeam();
759                 if(key_owner_team == self.team)
760                         havocbot_goalrating_kh(100000, 1, 1); // defend anyway
761                 else if(key_owner_team == -1)
762                         havocbot_goalrating_kh(10000, 40000, 10000); // prefer dropped keys
763                 else
764                         havocbot_goalrating_kh(1, 1, 100000); // ATTACK ANYWAY
765
766                 havocbot_goalrating_items(10000, self.origin, 10000);
767                 navigation_goalrating_end();
768         }
769 };
770
771
772
773
774
775 void havocbot_chooserole_kh()
776 {
777         local float r;
778         r = random() * 3;
779         if (r < 1)
780                 self.havocbot_role = havocbot_role_kh_offense;
781         else if (r < 2)
782                 self.havocbot_role = havocbot_role_kh_defense;
783         else
784                 self.havocbot_role = havocbot_role_kh_freelancer;
785 };
786
787 void havocbot_chooserole()
788 {
789         dprint("choose a role...\n");
790         navigation_routetogoal(world);
791         self.bot_strategytime = -1;
792         if (g_ctf)
793                 havocbot_chooserole_ctf();
794         else if (g_domination)
795                 havocbot_chooserole_dom();
796         else if (g_keyhunt)
797                 havocbot_chooserole_kh();
798         else if (g_race)
799                 havocbot_chooserole_race();
800         else // assume anything else is deathmatch
801                 havocbot_chooserole_dm();
802 };
803