Fix "bot_cmd X pause" command not working (broken since 8da4929ec)
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / bot / default / scripting.qc
1 #include "scripting.qh"
2
3 #include "cvars.qh"
4
5 #include <common/state.qh>
6 #include <common/physics/player.qh>
7
8 #include "bot.qh"
9
10 .int state;
11
12 .float bot_cmdqueuebuf_allocated;
13 .float bot_cmdqueuebuf;
14 .float bot_cmdqueuebuf_start;
15 .float bot_cmdqueuebuf_end;
16
17 void bot_clearqueue(entity bot)
18 {
19         if(!bot.bot_cmdqueuebuf_allocated)
20                 return;
21         buf_del(bot.bot_cmdqueuebuf);
22         bot.bot_cmdqueuebuf_allocated = false;
23         LOG_TRACE("bot ", bot.netname, " queue cleared");
24 }
25
26 void bot_queuecommand(entity bot, string cmdstring)
27 {
28         if(!bot.bot_cmdqueuebuf_allocated)
29         {
30                 bot.bot_cmdqueuebuf = buf_create();
31                 bot.bot_cmdqueuebuf_allocated = true;
32                 bot.bot_cmdqueuebuf_start = 0;
33                 bot.bot_cmdqueuebuf_end = 0;
34         }
35
36         bufstr_set(bot.bot_cmdqueuebuf, bot.bot_cmdqueuebuf_end, cmdstring);
37
38         // if the command was a "sound" command, precache the sound NOW
39         // this prevents lagging!
40         {
41                 float sp;
42                 string parm;
43                 string cmdstr;
44
45                 sp = strstrofs(cmdstring, " ", 0);
46                 if(sp >= 0)
47                 {
48                         parm = substring(cmdstring, sp + 1, -1);
49                         cmdstr = substring(cmdstring, 0, sp);
50                         if(cmdstr == "sound")
51                         {
52                                 // find the LAST word
53                                 for (;;)
54                                 {
55                                         sp = strstrofs(parm, " ", 0);
56                                         if(sp < 0)
57                                                 break;
58                                         parm = substring(parm, sp + 1, -1);
59                                 }
60                                 precache_sound(parm);
61                         }
62                 }
63         }
64
65         bot.bot_cmdqueuebuf_end += 1;
66 }
67
68 void bot_dequeuecommand(entity bot, float idx)
69 {
70         if(!bot.bot_cmdqueuebuf_allocated)
71                 error("dequeuecommand but no queue allocated");
72         if(idx < bot.bot_cmdqueuebuf_start)
73                 error("dequeueing a command in the past");
74         if(idx >= bot.bot_cmdqueuebuf_end)
75                 error("dequeueing a command in the future");
76         bufstr_set(bot.bot_cmdqueuebuf, idx, "");
77         if(idx == bot.bot_cmdqueuebuf_start)
78                 bot.bot_cmdqueuebuf_start += 1;
79         if(bot.bot_cmdqueuebuf_start >= bot.bot_cmdqueuebuf_end)
80                 bot_clearqueue(bot);
81 }
82
83 string bot_readcommand(entity bot, float idx)
84 {
85         if(!bot.bot_cmdqueuebuf_allocated)
86                 error("readcommand but no queue allocated");
87         if(idx < bot.bot_cmdqueuebuf_start)
88                 error("reading a command in the past");
89         if(idx >= bot.bot_cmdqueuebuf_end)
90                 error("reading a command in the future");
91         return bufstr_get(bot.bot_cmdqueuebuf, idx);
92 }
93
94 bool bot_havecommand(entity this, int idx)
95 {
96         if(!this.bot_cmdqueuebuf_allocated)
97                 return false;
98         if(idx < this.bot_cmdqueuebuf_start)
99                 return false;
100         if(idx >= this.bot_cmdqueuebuf_end)
101                 return false;
102         return true;
103 }
104
105 const int MAX_BOT_PLACES = 4;
106 .float bot_places_count;
107 .entity bot_places[MAX_BOT_PLACES];
108 .string bot_placenames[MAX_BOT_PLACES];
109 entity bot_getplace(entity this, string placename)
110 {
111         entity e;
112         if(substring(placename, 0, 1) == "@")
113         {
114                 int i, p;
115                 placename = substring(placename, 1, -1);
116                 string s, s2;
117                 for(i = 0; i < this.bot_places_count; ++i)
118                         if(this.(bot_placenames[i]) == placename)
119                                 return this.(bot_places[i]);
120                 // now: i == this.bot_places_count
121                 s = s2 = cvar_string(placename);
122                 p = strstrofs(s2, " ", 0);
123                 if(p >= 0)
124                 {
125                         s = substring(s2, 0, p);
126                         //print("places: ", placename, " -> ", cvar_string(placename), "\n");
127                         cvar_set(placename, strcat(substring(s2, p+1, -1), " ", s));
128                         //print("places: ", placename, " := ", cvar_string(placename), "\n");
129                 }
130                 e = find(NULL, targetname, s);
131                 if(!e)
132                         LOG_INFO("invalid place ", s, "\n");
133                 if(i < MAX_BOT_PLACES)
134                 {
135                         this.(bot_placenames[i]) = strzone(placename);
136                         this.(bot_places[i]) = e;
137                         this.bot_places_count += 1;
138                 }
139                 return e;
140         }
141         else
142         {
143                 e = find(NULL, targetname, placename);
144                 if(!e)
145                         LOG_INFO("invalid place ", placename, "\n");
146                 return e;
147         }
148 }
149
150
151 // Initialize global commands list
152 // NOTE: New commands should be initialized here
153 void bot_commands_init()
154 {
155         bot_cmd_string[BOT_CMD_NULL] = "";
156         bot_cmd_parm_type[BOT_CMD_NULL] = BOT_CMD_PARAMETER_NONE;
157
158         bot_cmd_string[BOT_CMD_PAUSE] = "pause";
159         bot_cmd_parm_type[BOT_CMD_PAUSE] = BOT_CMD_PARAMETER_NONE;
160
161         bot_cmd_string[BOT_CMD_CONTINUE] = "continue";
162         bot_cmd_parm_type[BOT_CMD_CONTINUE] = BOT_CMD_PARAMETER_NONE;
163
164         bot_cmd_string[BOT_CMD_WAIT] = "wait";
165         bot_cmd_parm_type[BOT_CMD_WAIT] = BOT_CMD_PARAMETER_FLOAT;
166
167         bot_cmd_string[BOT_CMD_TURN] = "turn";
168         bot_cmd_parm_type[BOT_CMD_TURN] = BOT_CMD_PARAMETER_FLOAT;
169
170         bot_cmd_string[BOT_CMD_MOVETO] = "moveto";
171         bot_cmd_parm_type[BOT_CMD_MOVETO] = BOT_CMD_PARAMETER_VECTOR;
172
173         bot_cmd_string[BOT_CMD_MOVETOTARGET] = "movetotarget";
174         bot_cmd_parm_type[BOT_CMD_MOVETOTARGET] = BOT_CMD_PARAMETER_STRING;
175
176         bot_cmd_string[BOT_CMD_RESETGOAL] = "resetgoal";
177         bot_cmd_parm_type[BOT_CMD_RESETGOAL] = BOT_CMD_PARAMETER_NONE;
178
179         bot_cmd_string[BOT_CMD_CC] = "cc";
180         bot_cmd_parm_type[BOT_CMD_CC] = BOT_CMD_PARAMETER_STRING;
181
182         bot_cmd_string[BOT_CMD_IF] = "if";
183         bot_cmd_parm_type[BOT_CMD_IF] = BOT_CMD_PARAMETER_STRING;
184
185         bot_cmd_string[BOT_CMD_ELSE] = "else";
186         bot_cmd_parm_type[BOT_CMD_ELSE] = BOT_CMD_PARAMETER_NONE;
187
188         bot_cmd_string[BOT_CMD_FI] = "fi";
189         bot_cmd_parm_type[BOT_CMD_FI] = BOT_CMD_PARAMETER_NONE;
190
191         bot_cmd_string[BOT_CMD_RESETAIM] = "resetaim";
192         bot_cmd_parm_type[BOT_CMD_RESETAIM] = BOT_CMD_PARAMETER_NONE;
193
194         bot_cmd_string[BOT_CMD_AIM] = "aim";
195         bot_cmd_parm_type[BOT_CMD_AIM] = BOT_CMD_PARAMETER_STRING;
196
197         bot_cmd_string[BOT_CMD_AIMTARGET] = "aimtarget";
198         bot_cmd_parm_type[BOT_CMD_AIMTARGET] = BOT_CMD_PARAMETER_STRING;
199
200         bot_cmd_string[BOT_CMD_PRESSKEY] = "presskey";
201         bot_cmd_parm_type[BOT_CMD_PRESSKEY] = BOT_CMD_PARAMETER_STRING;
202
203         bot_cmd_string[BOT_CMD_RELEASEKEY] = "releasekey";
204         bot_cmd_parm_type[BOT_CMD_RELEASEKEY] = BOT_CMD_PARAMETER_STRING;
205
206         bot_cmd_string[BOT_CMD_SELECTWEAPON] = "selectweapon";
207         bot_cmd_parm_type[BOT_CMD_SELECTWEAPON] = BOT_CMD_PARAMETER_FLOAT;
208
209         bot_cmd_string[BOT_CMD_IMPULSE] = "impulse";
210         bot_cmd_parm_type[BOT_CMD_IMPULSE] = BOT_CMD_PARAMETER_FLOAT;
211
212         bot_cmd_string[BOT_CMD_WAIT_UNTIL] = "wait_until";
213         bot_cmd_parm_type[BOT_CMD_WAIT_UNTIL] = BOT_CMD_PARAMETER_FLOAT;
214
215         bot_cmd_string[BOT_CMD_BARRIER] = "barrier";
216         bot_cmd_parm_type[BOT_CMD_BARRIER] = BOT_CMD_PARAMETER_NONE;
217
218         bot_cmd_string[BOT_CMD_CONSOLE] = "console";
219         bot_cmd_parm_type[BOT_CMD_CONSOLE] = BOT_CMD_PARAMETER_STRING;
220
221         bot_cmd_string[BOT_CMD_SOUND] = "sound";
222         bot_cmd_parm_type[BOT_CMD_SOUND] = BOT_CMD_PARAMETER_STRING;
223
224         bot_cmd_string[BOT_CMD_DEBUG_ASSERT_CANFIRE] = "debug_assert_canfire";
225         bot_cmd_parm_type[BOT_CMD_DEBUG_ASSERT_CANFIRE] = BOT_CMD_PARAMETER_FLOAT;
226
227         bot_cmds_initialized = true;
228 }
229
230 // Returns first bot with matching name
231 entity find_bot_by_name(string name)
232 {
233         FOREACH_CLIENT(IS_BOT_CLIENT(it) && it.netname == name,
234         {
235                 return it;
236         });
237
238         return NULL;
239 }
240
241 // Returns a bot by number on list
242 entity find_bot_by_number(float number)
243 {
244         entity bot;
245         float c = 0;
246
247         if(!number)
248                 return NULL;
249
250         bot = findchainflags(flags, FL_CLIENT); // TODO: doesn't findchainflags loop backwards through entities?
251         while (bot)
252         {
253                 if(IS_BOT_CLIENT(bot))
254                 {
255                         if(++c==number)
256                                 return bot;
257                 }
258                 bot = bot.chain;
259         }
260
261         return NULL;
262 }
263
264 float bot_decodecommand(string cmdstring)
265 {
266         float cmd_parm_type;
267         float sp;
268         string parm;
269
270         sp = strstrofs(cmdstring, " ", 0);
271         if(sp < 0)
272         {
273                 parm = "";
274         }
275         else
276         {
277                 parm = substring(cmdstring, sp + 1, -1);
278                 cmdstring = substring(cmdstring, 0, sp);
279         }
280
281         if(!bot_cmds_initialized)
282                 bot_commands_init();
283
284         int i;
285         for(i=1;i<BOT_CMD_COUNTER;++i)
286         {
287                 if(bot_cmd_string[i]!=cmdstring)
288                         continue;
289
290                 cmd_parm_type = bot_cmd_parm_type[i];
291
292                 if(cmd_parm_type!=BOT_CMD_PARAMETER_NONE&&parm=="")
293                 {
294                         LOG_INFO("ERROR: A parameter is required for this command\n");
295                         return 0;
296                 }
297
298                 // Load command into queue
299                 bot_cmd.bot_cmd_type = i;
300
301                 // Attach parameter
302                 switch(cmd_parm_type)
303                 {
304                         case BOT_CMD_PARAMETER_FLOAT:
305                                 bot_cmd.bot_cmd_parm_float = stof(parm);
306                                 break;
307                         case BOT_CMD_PARAMETER_STRING:
308                                 if(bot_cmd.bot_cmd_parm_string)
309                                         strunzone(bot_cmd.bot_cmd_parm_string);
310                                 bot_cmd.bot_cmd_parm_string = strzone(parm);
311                                 break;
312                         case BOT_CMD_PARAMETER_VECTOR:
313                                 bot_cmd.bot_cmd_parm_vector = stov(parm);
314                                 break;
315                         default:
316                                 break;
317                 }
318                 return 1;
319         }
320         LOG_INFO("ERROR: No such command '", cmdstring, "'\n");
321         return 0;
322 }
323
324 void bot_cmdhelp(string scmd)
325 {
326         int i, ntype;
327         string stype;
328
329         if(!bot_cmds_initialized)
330                 bot_commands_init();
331
332         for(i=1;i<BOT_CMD_COUNTER;++i)
333         {
334                 if(bot_cmd_string[i]!=scmd)
335                         continue;
336
337                 ntype = bot_cmd_parm_type[i];
338
339                 switch(ntype)
340                 {
341                         case BOT_CMD_PARAMETER_FLOAT:
342                                 stype = "float number";
343                                 break;
344                         case BOT_CMD_PARAMETER_STRING:
345                                 stype = "string";
346                                 break;
347                         case BOT_CMD_PARAMETER_VECTOR:
348                                 stype = "vector";
349                                 break;
350                         default:
351                                 stype = "none";
352                                 break;
353                 }
354
355                 LOG_INFO(strcat("Command: ",bot_cmd_string[i],"\nParameter: <",stype,"> \n"));
356
357                 LOG_INFO("Description: ");
358                 switch(i)
359                 {
360                         case BOT_CMD_PAUSE:
361                                 LOG_INFO("Stops the bot completely. Any command other than 'continue' will be ignored.");
362                                 break;
363                         case BOT_CMD_CONTINUE:
364                                 LOG_INFO("Disable paused status");
365                                 break;
366                         case BOT_CMD_WAIT:
367                                 LOG_INFO("Pause command parsing and bot ai for N seconds. Pressed key will remain pressed");
368                                 break;
369                         case BOT_CMD_WAIT_UNTIL:
370                                 LOG_INFO("Pause command parsing and bot ai until time is N from the last barrier. Pressed key will remain pressed");
371                                 break;
372                         case BOT_CMD_BARRIER:
373                                 LOG_INFO("Waits till all bots that have a command queue reach this command. Pressed key will remain pressed");
374                                 break;
375                         case BOT_CMD_TURN:
376                                 LOG_INFO("Look to the right or left N degrees. For turning to the left use positive numbers.");
377                                 break;
378                         case BOT_CMD_MOVETO:
379                                 LOG_INFO("Walk to an specific coordinate on the map. Usage: moveto \"x y z\"");
380                                 break;
381                         case BOT_CMD_MOVETOTARGET:
382                                 LOG_INFO("Walk to the specific target on the map");
383                                 break;
384                         case BOT_CMD_RESETGOAL:
385                                 LOG_INFO("Resets the goal stack");
386                                 break;
387                         case BOT_CMD_CC:
388                                 LOG_INFO("Execute client command. Examples: cc \"say something\"; cc god; cc \"name newnickname\"; cc kill;");
389                                 break;
390                         case BOT_CMD_IF:
391                                 LOG_INFO("Perform simple conditional execution.\n");
392                                 LOG_INFO("Syntax: \n");
393                                 LOG_INFO("        sv_cmd .. if \"condition\"\n");
394                                 LOG_INFO("        sv_cmd ..     <instruction if true>\n");
395                                 LOG_INFO("        sv_cmd ..     <instruction if true>\n");
396                                 LOG_INFO("        sv_cmd .. else\n");
397                                 LOG_INFO("        sv_cmd ..     <instruction if false>\n");
398                                 LOG_INFO("        sv_cmd ..     <instruction if false>\n");
399                                 LOG_INFO("        sv_cmd .. fi\n");
400                                 LOG_INFO("Conditions: a=b, a>b, a<b, a\t\t(spaces not allowed)\n");
401                                 LOG_INFO("            Values in conditions can be numbers, cvars in the form cvar.cvar_string or special fields\n");
402                                 LOG_INFO("Fields: health, speed, flagcarrier\n");
403                                 LOG_INFO("Examples: if health>50; if health>cvar.g_balance_laser_primary_damage; if flagcarrier;");
404                                 break;
405                         case BOT_CMD_RESETAIM:
406                                 LOG_INFO("Points the aim to the coordinates x,y 0,0");
407                                 break;
408                         case BOT_CMD_AIM:
409                                 LOG_INFO("Move the aim x/y (horizontal/vertical) degrees relatives to the bot\n");
410                                 LOG_INFO("There is a 3rd optional parameter telling in how many seconds the aim has to reach the new position\n");
411                                 LOG_INFO("Examples: aim \"90 0\"        // Turn 90 degrees inmediately (positive numbers move to the left/up)\n");
412                                 LOG_INFO("          aim \"0 90 2\"      // Will gradually look to the sky in the next two seconds");
413                                 break;
414                         case BOT_CMD_AIMTARGET:
415                                 LOG_INFO("Points the aim to given target");
416                                 break;
417                         case BOT_CMD_PRESSKEY:
418                                 LOG_INFO("Press one of the following keys: forward, backward, left, right, jump, crouch, attack1, attack2, use\n");
419                                 LOG_INFO("Multiple keys can be pressed at time (with many presskey calls) and it will remain pressed until the command \"releasekey\" is called");
420                                 LOG_INFO("Note: The script will not return the control to the bot ai until all keys are released");
421                                 break;
422                         case BOT_CMD_RELEASEKEY:
423                                 LOG_INFO("Release previoulsy used keys. Use the parameter \"all\" to release all keys");
424                                 break;
425                         case BOT_CMD_SOUND:
426                                 LOG_INFO("play sound file at bot location");
427                                 break;
428                         case BOT_CMD_DEBUG_ASSERT_CANFIRE:
429                                 LOG_INFO("verify the state of the weapon entity");
430                                 break;
431                         default:
432                                 LOG_INFO("This command has no description yet.");
433                                 break;
434                 }
435                 LOG_INFO("\n");
436         }
437 }
438
439 void bot_list_commands()
440 {
441         int i;
442         string ptype;
443
444         if(!bot_cmds_initialized)
445                 bot_commands_init();
446
447         LOG_INFO("List of all available commands:\n");
448         LOG_INFO("  Command - Parameter Type\n");
449
450         for(i=1;i<BOT_CMD_COUNTER;++i)
451         {
452                 switch(bot_cmd_parm_type[i])
453                 {
454                         case BOT_CMD_PARAMETER_FLOAT:
455                                 ptype = "float number";
456                                 break;
457                         case BOT_CMD_PARAMETER_STRING:
458                                 ptype = "string";
459                                 break;
460                         case BOT_CMD_PARAMETER_VECTOR:
461                                 ptype = "vector";
462                                 break;
463                         default:
464                                 ptype = "none";
465                                 break;
466                 }
467                 LOG_INFO(strcat("  ",bot_cmd_string[i]," - <",ptype,"> \n"));
468         }
469 }
470
471 // Commands code
472 .int bot_exec_status;
473
474 float bot_cmd_cc(entity this)
475 {
476         SV_ParseClientCommand(this, bot_cmd.bot_cmd_parm_string);
477         return CMD_STATUS_FINISHED;
478 }
479
480 float bot_cmd_impulse(entity this)
481 {
482         this.impulse = bot_cmd.bot_cmd_parm_float;
483         return CMD_STATUS_FINISHED;
484 }
485
486 float bot_cmd_continue(entity this)
487 {
488         this.bot_exec_status &= ~BOT_EXEC_STATUS_PAUSED;
489         return CMD_STATUS_FINISHED;
490 }
491
492 .float bot_cmd_wait_time;
493 float bot_cmd_wait(entity this)
494 {
495         if(this.bot_exec_status & BOT_EXEC_STATUS_WAITING)
496         {
497                 if(time>=this.bot_cmd_wait_time)
498                 {
499                         this.bot_exec_status &= ~BOT_EXEC_STATUS_WAITING;
500                         return CMD_STATUS_FINISHED;
501                 }
502                 else
503                         return CMD_STATUS_EXECUTING;
504         }
505
506         this.bot_cmd_wait_time = time + bot_cmd.bot_cmd_parm_float;
507         this.bot_exec_status |= BOT_EXEC_STATUS_WAITING;
508         return CMD_STATUS_EXECUTING;
509 }
510
511 float bot_cmd_wait_until(entity this)
512 {
513         if(time < bot_cmd.bot_cmd_parm_float + bot_barriertime)
514         {
515                 this.bot_exec_status |= BOT_EXEC_STATUS_WAITING;
516                 return CMD_STATUS_EXECUTING;
517         }
518         this.bot_exec_status &= ~BOT_EXEC_STATUS_WAITING;
519         return CMD_STATUS_FINISHED;
520 }
521
522 float bot_cmd_barrier(entity this)
523 {
524         // 0 = no barrier, 1 = waiting, 2 = waiting finished
525
526         if(this.bot_barrier == 0) // initialization
527         {
528                 this.bot_barrier = 1;
529
530                 //this.colormod = '4 4 0';
531         }
532
533         if(this.bot_barrier == 1) // find other bots
534         {
535                 FOREACH_CLIENT(it.isbot, LAMBDA(
536                         if(it.bot_cmdqueuebuf_allocated)
537                         if(it.bot_barrier != 1)
538                                 return CMD_STATUS_EXECUTING; // not all are at the barrier yet
539                 ));
540
541                 // all bots hit the barrier!
542
543                 // acknowledge barrier
544                 FOREACH_CLIENT(it.isbot, LAMBDA(it.bot_barrier = 2));
545
546                 bot_barriertime = time;
547         }
548
549         // if we get here, the barrier is finished
550         // so end it...
551         this.bot_barrier = 0;
552         //this.colormod = '0 0 0';
553
554         return CMD_STATUS_FINISHED;
555 }
556
557 float bot_cmd_turn(entity this)
558 {
559         this.v_angle_y = this.v_angle.y + bot_cmd.bot_cmd_parm_float;
560         this.v_angle_y = this.v_angle.y - floor(this.v_angle.y / 360) * 360;
561         return CMD_STATUS_FINISHED;
562 }
563
564 float bot_cmd_select_weapon(entity this)
565 {
566         float id = bot_cmd.bot_cmd_parm_float;
567
568         if(id < WEP_FIRST || id > WEP_LAST)
569                 return CMD_STATUS_ERROR;
570
571         if(client_hasweapon(this, Weapons_from(id), true, false))
572                 PS(this).m_switchweapon = Weapons_from(id);
573         else
574                 return CMD_STATUS_ERROR;
575
576         return CMD_STATUS_FINISHED;
577 }
578
579 .int bot_cmd_condition_status;
580
581 const int CMD_CONDITION_NONE = 0;
582 const int CMD_CONDITION_true = 1;
583 const int CMD_CONDITION_false = 2;
584 const int CMD_CONDITION_true_BLOCK = 4;
585 const int CMD_CONDITION_false_BLOCK = 8;
586
587 float bot_cmd_eval(entity this, string expr)
588 {
589         // Search for numbers
590         if(IS_DIGIT(substring(expr, 0, 1)))
591                 return stof(expr);
592
593         // Search for cvars
594         if(substring(expr, 0, 5)=="cvar.")
595                 return cvar(substring(expr, 5, strlen(expr)));
596
597         // Search for fields
598         switch(expr)
599         {
600                 case "health":
601                         return this.health;
602                 case "speed":
603                         return vlen(this.velocity);
604                 case "flagcarrier":
605                         return ((this.flagcarried!=NULL));
606         }
607
608         LOG_INFO(strcat("ERROR: Unable to convert the expression '",expr,"' into a numeric value\n"));
609         return 0;
610 }
611
612 float bot_cmd_if(entity this)
613 {
614         string expr, val_a, val_b;
615         float cmpofs;
616
617         if(this.bot_cmd_condition_status != CMD_CONDITION_NONE)
618         {
619                 // Only one "if" block is allowed at time
620                 LOG_INFO("ERROR: Only one conditional block can be processed at time");
621                 bot_clearqueue(this);
622                 return CMD_STATUS_ERROR;
623         }
624
625         this.bot_cmd_condition_status |= CMD_CONDITION_true_BLOCK;
626
627         // search for operators
628         expr = bot_cmd.bot_cmd_parm_string;
629
630         cmpofs = strstrofs(expr,"=",0);
631
632         if(cmpofs>0)
633         {
634                 val_a = substring(expr,0,cmpofs);
635                 val_b = substring(expr,cmpofs+1,strlen(expr));
636
637                 if(bot_cmd_eval(this, val_a)==bot_cmd_eval(this, val_b))
638                         this.bot_cmd_condition_status |= CMD_CONDITION_true;
639                 else
640                         this.bot_cmd_condition_status |= CMD_CONDITION_false;
641
642                 return CMD_STATUS_FINISHED;
643         }
644
645         cmpofs = strstrofs(expr,">",0);
646
647         if(cmpofs>0)
648         {
649                 val_a = substring(expr,0,cmpofs);
650                 val_b = substring(expr,cmpofs+1,strlen(expr));
651
652                 if(bot_cmd_eval(this, val_a)>bot_cmd_eval(this, val_b))
653                         this.bot_cmd_condition_status |= CMD_CONDITION_true;
654                 else
655                         this.bot_cmd_condition_status |= CMD_CONDITION_false;
656
657                 return CMD_STATUS_FINISHED;
658         }
659
660         cmpofs = strstrofs(expr,"<",0);
661
662         if(cmpofs>0)
663         {
664                 val_a = substring(expr,0,cmpofs);
665                 val_b = substring(expr,cmpofs+1,strlen(expr));
666
667                 if(bot_cmd_eval(this, val_a)<bot_cmd_eval(this, val_b))
668                         this.bot_cmd_condition_status |= CMD_CONDITION_true;
669                 else
670                         this.bot_cmd_condition_status |= CMD_CONDITION_false;
671
672                 return CMD_STATUS_FINISHED;
673         }
674
675         if(bot_cmd_eval(this, expr))
676                 this.bot_cmd_condition_status |= CMD_CONDITION_true;
677         else
678                 this.bot_cmd_condition_status |= CMD_CONDITION_false;
679
680         return CMD_STATUS_FINISHED;
681 }
682
683 float bot_cmd_else(entity this)
684 {
685         this.bot_cmd_condition_status &= ~CMD_CONDITION_true_BLOCK;
686         this.bot_cmd_condition_status |= CMD_CONDITION_false_BLOCK;
687         return CMD_STATUS_FINISHED;
688 }
689
690 float bot_cmd_fi(entity this)
691 {
692         this.bot_cmd_condition_status = CMD_CONDITION_NONE;
693         return CMD_STATUS_FINISHED;
694 }
695
696 float bot_cmd_resetaim(entity this)
697 {
698         this.v_angle = '0 0 0';
699         return CMD_STATUS_FINISHED;
700 }
701
702 .float bot_cmd_aim_begintime;
703 .float bot_cmd_aim_endtime;
704 .vector bot_cmd_aim_begin;
705 .vector bot_cmd_aim_end;
706
707 float bot_cmd_aim(entity this)
708 {
709         // Current direction
710         if(this.bot_cmd_aim_endtime)
711         {
712                 float progress;
713
714                 progress = min(1 - (this.bot_cmd_aim_endtime - time) / (this.bot_cmd_aim_endtime - this.bot_cmd_aim_begintime),1);
715                 this.v_angle = this.bot_cmd_aim_begin + ((this.bot_cmd_aim_end - this.bot_cmd_aim_begin) * progress);
716
717                 if(time>=this.bot_cmd_aim_endtime)
718                 {
719                         this.bot_cmd_aim_endtime = 0;
720                         return CMD_STATUS_FINISHED;
721                 }
722                 else
723                         return CMD_STATUS_EXECUTING;
724         }
725
726         // New aiming direction
727         string parms;
728         float tokens, step;
729
730         parms = bot_cmd.bot_cmd_parm_string;
731
732         tokens = tokenizebyseparator(parms, " ");
733
734         if(tokens<2||tokens>3)
735                 return CMD_STATUS_ERROR;
736
737         step = (tokens == 3) ? stof(argv(2)) : 0;
738
739         if(step == 0)
740         {
741                 this.v_angle_x -= stof(argv(1));
742                 this.v_angle_y += stof(argv(0));
743                 return CMD_STATUS_FINISHED;
744         }
745
746         this.bot_cmd_aim_begin = this.v_angle;
747
748         this.bot_cmd_aim_end_x = this.v_angle.x - stof(argv(1));
749         this.bot_cmd_aim_end_y = this.v_angle.y + stof(argv(0));
750         this.bot_cmd_aim_end_z = 0;
751
752         this.bot_cmd_aim_begintime = time;
753         this.bot_cmd_aim_endtime = time + step;
754
755         return CMD_STATUS_EXECUTING;
756 }
757
758 float bot_cmd_aimtarget(entity this)
759 {
760         if(this.bot_cmd_aim_endtime)
761         {
762                 return bot_cmd_aim(this);
763         }
764
765         entity e;
766         string parms;
767         vector v;
768         float tokens, step;
769
770         parms = bot_cmd.bot_cmd_parm_string;
771
772         tokens = tokenizebyseparator(parms, " ");
773
774         e = bot_getplace(this, argv(0));
775         if(!e)
776                 return CMD_STATUS_ERROR;
777
778         v = e.origin + (e.mins + e.maxs) * 0.5;
779
780         if(tokens==1)
781         {
782                 this.v_angle = vectoangles(v - (this.origin + this.view_ofs));
783                 this.v_angle_x = -this.v_angle.x;
784                 return CMD_STATUS_FINISHED;
785         }
786
787         if(tokens<1||tokens>2)
788                 return CMD_STATUS_ERROR;
789
790         step = stof(argv(1));
791
792         this.bot_cmd_aim_begin = this.v_angle;
793         this.bot_cmd_aim_end = vectoangles(v - (this.origin + this.view_ofs));
794         this.bot_cmd_aim_end_x = -this.bot_cmd_aim_end.x;
795
796         this.bot_cmd_aim_begintime = time;
797         this.bot_cmd_aim_endtime = time + step;
798
799         return CMD_STATUS_EXECUTING;
800 }
801
802 .int bot_cmd_keys;
803
804 const int BOT_CMD_KEY_NONE              = 0;
805 const int BOT_CMD_KEY_FORWARD   = BIT(0);
806 const int BOT_CMD_KEY_BACKWARD  = BIT(1);
807 const int BOT_CMD_KEY_RIGHT     = BIT(2);
808 const int BOT_CMD_KEY_LEFT              = BIT(3);
809 const int BOT_CMD_KEY_JUMP              = BIT(4);
810 const int BOT_CMD_KEY_ATTACK1   = BIT(5);
811 const int BOT_CMD_KEY_ATTACK2   = BIT(6);
812 const int BOT_CMD_KEY_USE               = BIT(7);
813 const int BOT_CMD_KEY_HOOK              = BIT(8);
814 const int BOT_CMD_KEY_CROUCH    = BIT(9);
815 const int BOT_CMD_KEY_CHAT              = BIT(10);
816
817 bool bot_presskeys(entity this)
818 {
819         this.movement = '0 0 0';
820         PHYS_INPUT_BUTTON_JUMP(this) = false;
821         PHYS_INPUT_BUTTON_CROUCH(this) = false;
822         PHYS_INPUT_BUTTON_ATCK(this) = false;
823         PHYS_INPUT_BUTTON_ATCK2(this) = false;
824         PHYS_INPUT_BUTTON_USE(this) = false;
825         PHYS_INPUT_BUTTON_HOOK(this) = false;
826         PHYS_INPUT_BUTTON_CHAT(this) = false;
827
828         if(this.bot_cmd_keys == BOT_CMD_KEY_NONE)
829                 return false;
830
831         if(this.bot_cmd_keys & BOT_CMD_KEY_FORWARD)
832                 this.movement_x = autocvar_sv_maxspeed;
833         else if(this.bot_cmd_keys & BOT_CMD_KEY_BACKWARD)
834                 this.movement_x = -autocvar_sv_maxspeed;
835
836         if(this.bot_cmd_keys & BOT_CMD_KEY_RIGHT)
837                 this.movement_y = autocvar_sv_maxspeed;
838         else if(this.bot_cmd_keys & BOT_CMD_KEY_LEFT)
839                 this.movement_y = -autocvar_sv_maxspeed;
840
841         if(this.bot_cmd_keys & BOT_CMD_KEY_JUMP)
842                 PHYS_INPUT_BUTTON_JUMP(this) = true;
843
844         if(this.bot_cmd_keys & BOT_CMD_KEY_CROUCH)
845                 PHYS_INPUT_BUTTON_CROUCH(this) = true;
846
847         if(this.bot_cmd_keys & BOT_CMD_KEY_ATTACK1)
848                 PHYS_INPUT_BUTTON_ATCK(this) = true;
849
850         if(this.bot_cmd_keys & BOT_CMD_KEY_ATTACK2)
851                 PHYS_INPUT_BUTTON_ATCK2(this) = true;
852
853         if(this.bot_cmd_keys & BOT_CMD_KEY_USE)
854                 PHYS_INPUT_BUTTON_USE(this) = true;
855
856         if(this.bot_cmd_keys & BOT_CMD_KEY_HOOK)
857                 PHYS_INPUT_BUTTON_HOOK(this) = true;
858
859         if(this.bot_cmd_keys & BOT_CMD_KEY_CHAT)
860                 PHYS_INPUT_BUTTON_CHAT(this) = true;
861
862         return true;
863 }
864
865
866 float bot_cmd_keypress_handler(entity this, string key, float enabled)
867 {
868         switch(key)
869         {
870                 case "all":
871                         if(enabled)
872                                 this.bot_cmd_keys = power2of(20) - 1; // >:)
873                         else
874                                 this.bot_cmd_keys = BOT_CMD_KEY_NONE;
875                 case "forward":
876                         if(enabled)
877                         {
878                                 this.bot_cmd_keys |= BOT_CMD_KEY_FORWARD;
879                                 this.bot_cmd_keys &= ~BOT_CMD_KEY_BACKWARD;
880                         }
881                         else
882                                 this.bot_cmd_keys &= ~BOT_CMD_KEY_FORWARD;
883                         break;
884                 case "backward":
885                         if(enabled)
886                         {
887                                 this.bot_cmd_keys |= BOT_CMD_KEY_BACKWARD;
888                                 this.bot_cmd_keys &= ~BOT_CMD_KEY_FORWARD;
889                         }
890                         else
891                                 this.bot_cmd_keys &= ~BOT_CMD_KEY_BACKWARD;
892                         break;
893                 case "left":
894                         if(enabled)
895                         {
896                                 this.bot_cmd_keys |= BOT_CMD_KEY_LEFT;
897                                 this.bot_cmd_keys &= ~BOT_CMD_KEY_RIGHT;
898                         }
899                         else
900                                 this.bot_cmd_keys &= ~BOT_CMD_KEY_LEFT;
901                         break;
902                 case "right":
903                         if(enabled)
904                         {
905                                 this.bot_cmd_keys |= BOT_CMD_KEY_RIGHT;
906                                 this.bot_cmd_keys &= ~BOT_CMD_KEY_LEFT;
907                         }
908                         else
909                                 this.bot_cmd_keys &= ~BOT_CMD_KEY_RIGHT;
910                         break;
911                 case "jump":
912                         if(enabled)
913                                 this.bot_cmd_keys |= BOT_CMD_KEY_JUMP;
914                         else
915                                 this.bot_cmd_keys &= ~BOT_CMD_KEY_JUMP;
916                         break;
917                 case "crouch":
918                         if(enabled)
919                                 this.bot_cmd_keys |= BOT_CMD_KEY_CROUCH;
920                         else
921                                 this.bot_cmd_keys &= ~BOT_CMD_KEY_CROUCH;
922                         break;
923                 case "attack1":
924                         if(enabled)
925                                 this.bot_cmd_keys |= BOT_CMD_KEY_ATTACK1;
926                         else
927                                 this.bot_cmd_keys &= ~BOT_CMD_KEY_ATTACK1;
928                         break;
929                 case "attack2":
930                         if(enabled)
931                                 this.bot_cmd_keys |= BOT_CMD_KEY_ATTACK2;
932                         else
933                                 this.bot_cmd_keys &= ~BOT_CMD_KEY_ATTACK2;
934                         break;
935                 case "use":
936                         if(enabled)
937                                 this.bot_cmd_keys |= BOT_CMD_KEY_USE;
938                         else
939                                 this.bot_cmd_keys &= ~BOT_CMD_KEY_USE;
940                         break;
941                 case "hook":
942                         if(enabled)
943                                 this.bot_cmd_keys |= BOT_CMD_KEY_HOOK;
944                         else
945                                 this.bot_cmd_keys &= ~BOT_CMD_KEY_HOOK;
946                         break;
947                 case "chat":
948                         if(enabled)
949                                 this.bot_cmd_keys |= BOT_CMD_KEY_CHAT;
950                         else
951                                 this.bot_cmd_keys &= ~BOT_CMD_KEY_CHAT;
952                         break;
953                 default:
954                         break;
955         }
956
957         return CMD_STATUS_FINISHED;
958 }
959
960 float bot_cmd_presskey(entity this)
961 {
962         string key;
963
964         key = bot_cmd.bot_cmd_parm_string;
965
966         bot_cmd_keypress_handler(this, key,true);
967
968         return CMD_STATUS_FINISHED;
969 }
970
971 float bot_cmd_releasekey(entity this)
972 {
973         string key;
974
975         key = bot_cmd.bot_cmd_parm_string;
976
977         return bot_cmd_keypress_handler(this, key,false);
978 }
979
980 float bot_cmd_pause(entity this)
981 {
982         PHYS_INPUT_BUTTON_DRAG(this) = false;
983         PHYS_INPUT_BUTTON_USE(this) = false;
984         PHYS_INPUT_BUTTON_ATCK(this) = false;
985         PHYS_INPUT_BUTTON_JUMP(this) = false;
986         PHYS_INPUT_BUTTON_HOOK(this) = false;
987         PHYS_INPUT_BUTTON_CHAT(this) = false;
988         PHYS_INPUT_BUTTON_ATCK2(this) = false;
989         PHYS_INPUT_BUTTON_CROUCH(this) = false;
990
991         this.movement = '0 0 0';
992         this.bot_cmd_keys = BOT_CMD_KEY_NONE;
993
994         this.bot_exec_status |= BOT_EXEC_STATUS_PAUSED;
995         return CMD_STATUS_FINISHED;
996 }
997
998 float bot_cmd_moveto(entity this)
999 {
1000         return this.cmd_moveto(this, bot_cmd.bot_cmd_parm_vector);
1001 }
1002
1003 float bot_cmd_movetotarget(entity this)
1004 {
1005         entity e;
1006         e = bot_getplace(this, bot_cmd.bot_cmd_parm_string);
1007         if(!e)
1008                 return CMD_STATUS_ERROR;
1009         return this.cmd_moveto(this, e.origin + (e.mins + e.maxs) * 0.5);
1010 }
1011
1012 float bot_cmd_resetgoal(entity this)
1013 {
1014         return this.cmd_resetgoal(this);
1015 }
1016
1017
1018 float bot_cmd_sound(entity this)
1019 {
1020         string f;
1021         f = bot_cmd.bot_cmd_parm_string;
1022
1023         float n = tokenizebyseparator(f, " ");
1024
1025         string sample = f;
1026         float chan = CH_WEAPON_B;
1027         float vol = VOL_BASE;
1028         float atten = ATTEN_MIN;
1029
1030         if(n >= 1)
1031                 sample = argv(n - 1);
1032         if(n >= 2)
1033                 chan = stof(argv(0));
1034         if(n >= 3)
1035                 vol = stof(argv(1));
1036         if(n >= 4)
1037                 atten = stof(argv(2));
1038
1039         precache_sound(f);
1040         _sound(this, chan, sample, vol, atten);
1041
1042         return CMD_STATUS_FINISHED;
1043 }
1044
1045 .entity tuba_note;
1046 float bot_cmd_debug_assert_canfire(entity this)
1047 {
1048         float f = bot_cmd.bot_cmd_parm_float;
1049
1050         int slot = 0; // TODO: unhardcode?
1051         .entity weaponentity = weaponentities[slot];
1052         if(this.(weaponentity).state != WS_READY)
1053         {
1054                 if(f)
1055                 {
1056                         this.colormod = '0 8 8';
1057                         LOG_INFO("Bot ", this.netname, " using ", this.weaponname, " wants to fire, inhibited by weaponentity state\n");
1058                 }
1059         }
1060         else if(ATTACK_FINISHED(this, slot) > time)
1061         {
1062                 if(f)
1063                 {
1064                         this.colormod = '8 0 8';
1065                         LOG_INFO("Bot ", this.netname, " using ", this.weaponname, " wants to fire, inhibited by ATTACK_FINISHED (", ftos(ATTACK_FINISHED(this, slot) - time), " seconds left)\n");
1066                 }
1067         }
1068         else if(this.tuba_note)
1069         {
1070                 if(f)
1071                 {
1072                         this.colormod = '8 0 0';
1073                         LOG_INFO("Bot ", this.netname, " using ", this.weaponname, " wants to fire, bot still has an active tuba note\n");
1074                 }
1075         }
1076         else
1077         {
1078                 if(!f)
1079                 {
1080                         this.colormod = '8 8 0';
1081                         LOG_INFO("Bot ", this.netname, " using ", this.weaponname, " thinks it has fired, but apparently did not; ATTACK_FINISHED says ", ftos(ATTACK_FINISHED(this, slot) - time), " seconds left\n");
1082                 }
1083         }
1084
1085         return CMD_STATUS_FINISHED;
1086 }
1087
1088 //
1089
1090 void bot_command_executed(entity this, bool rm)
1091 {
1092         entity cmd;
1093
1094         cmd = bot_cmd;
1095
1096         if(rm)
1097                 bot_dequeuecommand(this, this.bot_cmd_execution_index);
1098
1099         this.bot_cmd_execution_index++;
1100 }
1101
1102 void bot_setcurrentcommand(entity this)
1103 {
1104         bot_cmd = NULL;
1105
1106         if(!this.bot_cmd_current)
1107         {
1108                 this.bot_cmd_current = new_pure(bot_cmd);
1109         }
1110
1111         bot_cmd = this.bot_cmd_current;
1112         if(bot_cmd.bot_cmd_index != this.bot_cmd_execution_index || this.bot_cmd_execution_index == 0)
1113         {
1114                 if(bot_havecommand(this, this.bot_cmd_execution_index))
1115                 {
1116                         string cmdstring;
1117                         cmdstring = bot_readcommand(this, this.bot_cmd_execution_index);
1118                         if(bot_decodecommand(cmdstring))
1119                         {
1120                                 bot_cmd.owner = this;
1121                                 bot_cmd.bot_cmd_index = this.bot_cmd_execution_index;
1122                         }
1123                         else
1124                         {
1125                                 // Invalid command, remove from queue
1126                                 bot_cmd = NULL;
1127                                 bot_dequeuecommand(this, this.bot_cmd_execution_index);
1128                                 this.bot_cmd_execution_index++;
1129                         }
1130                 }
1131                 else
1132                         bot_cmd = NULL;
1133         }
1134 }
1135
1136 void bot_resetqueues()
1137 {
1138         FOREACH_CLIENT(it.isbot, LAMBDA(
1139                 it.bot_cmd_execution_index = 0;
1140                 bot_clearqueue(it);
1141                 // also, cancel all barriers
1142                 it.bot_barrier = 0;
1143                 for(int i = 0; i < it.bot_places_count; ++i)
1144                 {
1145                         strunzone(it.(bot_placenames[i]));
1146                         it.(bot_placenames[i]) = string_null;
1147                 }
1148                 it.bot_places_count = 0;
1149         ));
1150
1151         bot_barriertime = time;
1152 }
1153
1154 // Here we map commands to functions and deal with complex interactions between commands and execution states
1155 // NOTE: Of course you need to include your commands here too :)
1156 float bot_execute_commands_once(entity this)
1157 {
1158         float status, ispressingkey;
1159
1160         // Find command
1161         bot_setcurrentcommand(this);
1162
1163         // Ignore all commands except continue when the bot is paused
1164         if(!(self.bot_exec_status & BOT_EXEC_STATUS_PAUSED))
1165         {
1166                 // if we have no bot command, better return
1167                 // old logic kept pressing previously pressed keys, but that has problems
1168                 // (namely, it means you cannot make a bot "normal" ever again)
1169                 // to keep a bot walking for a while, use the "wait" bot command
1170                 if(bot_cmd == world)
1171                         return 0;
1172         }
1173         else if(bot_cmd.bot_cmd_type != BOT_CMD_CONTINUE)
1174         {
1175                 if(bot_cmd.bot_cmd_type!=BOT_CMD_NULL)
1176                 {
1177                         bot_command_executed(this, true);
1178                         LOG_INFO( "WARNING: Commands are ignored while the bot is paused. Use the command 'continue' instead.\n");
1179                 }
1180                 return 1;
1181         }
1182
1183         // Keep pressing keys raised by the "presskey" command
1184         ispressingkey = boolean(bot_presskeys(this));
1185
1186         // Handle conditions
1187         if (!(bot_cmd.bot_cmd_type==BOT_CMD_FI||bot_cmd.bot_cmd_type==BOT_CMD_ELSE))
1188         if(this.bot_cmd_condition_status & CMD_CONDITION_true && this.bot_cmd_condition_status & CMD_CONDITION_false_BLOCK)
1189         {
1190                 bot_command_executed(this, true);
1191                 return -1;
1192         }
1193         else if(this.bot_cmd_condition_status & CMD_CONDITION_false && this.bot_cmd_condition_status & CMD_CONDITION_true_BLOCK)
1194         {
1195                 bot_command_executed(this, true);
1196                 return -1;
1197         }
1198
1199         // Map commands to functions
1200         switch(bot_cmd.bot_cmd_type)
1201         {
1202                 case BOT_CMD_NULL:
1203                         return ispressingkey;
1204                         //break;
1205                 case BOT_CMD_PAUSE:
1206                         status = bot_cmd_pause(this);
1207                         break;
1208                 case BOT_CMD_CONTINUE:
1209                         status = bot_cmd_continue(this);
1210                         break;
1211                 case BOT_CMD_WAIT:
1212                         status = bot_cmd_wait(this);
1213                         break;
1214                 case BOT_CMD_WAIT_UNTIL:
1215                         status = bot_cmd_wait_until(this);
1216                         break;
1217                 case BOT_CMD_TURN:
1218                         status = bot_cmd_turn(this);
1219                         break;
1220                 case BOT_CMD_MOVETO:
1221                         status = bot_cmd_moveto(this);
1222                         break;
1223                 case BOT_CMD_MOVETOTARGET:
1224                         status = bot_cmd_movetotarget(this);
1225                         break;
1226                 case BOT_CMD_RESETGOAL:
1227                         status = bot_cmd_resetgoal(this);
1228                         break;
1229                 case BOT_CMD_CC:
1230                         status = bot_cmd_cc(this);
1231                         break;
1232                 case BOT_CMD_IF:
1233                         status = bot_cmd_if(this);
1234                         break;
1235                 case BOT_CMD_ELSE:
1236                         status = bot_cmd_else(this);
1237                         break;
1238                 case BOT_CMD_FI:
1239                         status = bot_cmd_fi(this);
1240                         break;
1241                 case BOT_CMD_RESETAIM:
1242                         status = bot_cmd_resetaim(this);
1243                         break;
1244                 case BOT_CMD_AIM:
1245                         status = bot_cmd_aim(this);
1246                         break;
1247                 case BOT_CMD_AIMTARGET:
1248                         status = bot_cmd_aimtarget(this);
1249                         break;
1250                 case BOT_CMD_PRESSKEY:
1251                         status = bot_cmd_presskey(this);
1252                         break;
1253                 case BOT_CMD_RELEASEKEY:
1254                         status = bot_cmd_releasekey(this);
1255                         break;
1256                 case BOT_CMD_SELECTWEAPON:
1257                         status = bot_cmd_select_weapon(this);
1258                         break;
1259                 case BOT_CMD_IMPULSE:
1260                         status = bot_cmd_impulse(this);
1261                         break;
1262                 case BOT_CMD_BARRIER:
1263                         status = bot_cmd_barrier(this);
1264                         break;
1265                 case BOT_CMD_CONSOLE:
1266                         localcmd(strcat(bot_cmd.bot_cmd_parm_string, "\n"));
1267                         status = CMD_STATUS_FINISHED;
1268                         break;
1269                 case BOT_CMD_SOUND:
1270                         status = bot_cmd_sound(this);
1271                         break;
1272                 case BOT_CMD_DEBUG_ASSERT_CANFIRE:
1273                         status = bot_cmd_debug_assert_canfire(this);
1274                         break;
1275                 default:
1276                         LOG_INFO(strcat("ERROR: Invalid command on queue with id '",ftos(bot_cmd.bot_cmd_type),"'\n"));
1277                         return 0;
1278         }
1279
1280         if (status==CMD_STATUS_ERROR)
1281                 LOG_INFO(strcat("ERROR: The command '",bot_cmd_string[bot_cmd.bot_cmd_type],"' returned an error status\n"));
1282
1283         // Move execution pointer
1284         if(status==CMD_STATUS_EXECUTING)
1285         {
1286                 return 1;
1287         }
1288         else
1289         {
1290                 if(autocvar_g_debug_bot_commands)
1291                 {
1292                         string parms;
1293
1294                         switch(bot_cmd_parm_type[bot_cmd.bot_cmd_type])
1295                         {
1296                                 case BOT_CMD_PARAMETER_FLOAT:
1297                                         parms = ftos(bot_cmd.bot_cmd_parm_float);
1298                                         break;
1299                                 case BOT_CMD_PARAMETER_STRING:
1300                                         parms = bot_cmd.bot_cmd_parm_string;
1301                                         break;
1302                                 case BOT_CMD_PARAMETER_VECTOR:
1303                                         parms = vtos(bot_cmd.bot_cmd_parm_vector);
1304                                         break;
1305                                 default:
1306                                         parms = "";
1307                                         break;
1308                         }
1309                         clientcommand(this,strcat("say ^7", bot_cmd_string[bot_cmd.bot_cmd_type]," ",parms,"\n"));
1310                 }
1311
1312                 bot_command_executed(this, true);
1313         }
1314
1315         if(status == CMD_STATUS_FINISHED)
1316                 return -1;
1317
1318         return CMD_STATUS_ERROR;
1319 }
1320
1321 // This function should be (the only) called directly from the bot ai loop
1322 int bot_execute_commands(entity this)
1323 {
1324         int f;
1325         do
1326         {
1327                 f = bot_execute_commands_once(this);
1328         }
1329         while(f < 0);
1330         return f;
1331 }