src/game/g_console.pas

   1 (* Copyright (C)  Doom 2D: Forever Developers
   2  *
   3  * This program is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, version 3 of the License ONLY.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  14  *)
  15 {$INCLUDE ../shared/a_modes.inc}
  16 unit g_console;
  17
  18 interface
  19
  20 uses
  21   utils; // for SSArray
  22
  23   const
  24     ACTION_JUMP = 0;
  25     ACTION_MOVELEFT = 1;
  26     ACTION_MOVERIGHT = 2;
  27     ACTION_LOOKDOWN = 3;
  28     ACTION_LOOKUP = 4;
  29     ACTION_ATTACK = 5;
  30     ACTION_SCORES = 6;
  31     ACTION_ACTIVATE = 7;
  32     ACTION_STRAFE = 8;
  33
  34     FIRST_ACTION = ACTION_JUMP;
  35     LAST_ACTION = ACTION_STRAFE;
  36
  37   var (* private state *)
  38     Line: AnsiString;
  39     CPos: Word;
  40     conSkipLines: Integer;
  41     MsgArray: Array [0..4] of record
  42       Msg: AnsiString;
  43       Time: Word;
  44     end;
  45
  46 procedure g_Console_Init;
  47 procedure g_Console_Initialize;
  48 procedure g_Console_Finalize;
  49 procedure g_Console_Update;
  50 procedure g_Console_Char (C: AnsiChar);
  51 procedure g_Console_Control (K: Word);
  52 procedure g_Console_Process (L: AnsiString; quiet: Boolean=false);
  53 procedure g_Console_Add (L: AnsiString; show: Boolean=false);
  54 procedure g_Console_Clear;
  55 function  g_Console_CommandBlacklisted (C: AnsiString): Boolean;
  56 procedure g_Console_ReadConfig (filename: String);
  57 procedure g_Console_WriteConfig (filename: String);
  58 procedure g_Console_WriteGameConfig;
  59
  60 function  g_Console_Interactive: Boolean;
  61 function  g_Console_Action (action: Integer): Boolean;
  62 function  g_Console_MatchBind (key: Integer; down: AnsiString; up: AnsiString = ''): Boolean;
  63 function  g_Console_FindBind (n: Integer; down: AnsiString; up: AnsiString = ''): Integer;
  64 procedure g_Console_BindKey (key: Integer; down: AnsiString; up: AnsiString = ''; rep: Boolean = False);
  65 procedure g_Console_ProcessBind (key: Integer; down: Boolean);
  66 procedure g_Console_ProcessBindRepeat (key: Integer);
  67 procedure g_Console_ResetBinds;
  68
  69 procedure conwriteln (const s: AnsiString; show: Boolean=false);
  70 procedure conwritefln (const s: AnsiString; args: array of const; show: Boolean=false);
  71
  72 procedure conRegVar (const conname: AnsiString; pvar: PBoolean; const ahelp: AnsiString; const amsg: AnsiString; acheat: Boolean=false; ahidden: Boolean=false); overload;
  73 procedure conRegVar (const conname: AnsiString; pvar: PSingle; amin, amax: Single; const ahelp: AnsiString; const amsg: AnsiString; acheat: Boolean=false; ahidden: Boolean=false); overload;
  74 procedure conRegVar (const conname: AnsiString; pvar: PInteger; const ahelp: AnsiString; const amsg: AnsiString; acheat: Boolean=false; ahidden: Boolean=false); overload;
  75 procedure conRegVar (const conname: AnsiString; pvar: PWord; const ahelp: AnsiString; const amsg: AnsiString; acheat: Boolean=false; ahidden: Boolean=false); overload;
  76 procedure conRegVar (const conname: AnsiString; pvar: PCardinal; const ahelp: AnsiString; const amsg: AnsiString; acheat: Boolean=false; ahidden: Boolean=false); overload;
  77 procedure conRegVar (const conname: AnsiString; pvar: PAnsiString; const ahelp: AnsiString; const amsg: AnsiString; acheat: Boolean=false; ahidden: Boolean=false); overload;
  78
  79 // <0: no arg; 0/1: true/false
  80 function conGetBoolArg (p: SSArray; idx: Integer): Integer;
  81
  82 // poor man's floating literal parser; i'm sorry, but `StrToFloat()` sux cocks
  83 function conParseFloat (var res: Single; const s: AnsiString): Boolean;
  84
  85 const
  86   {$IFDEF HEADLESS}
  87     defaultConfigScript = 'dfserver.cfg';
  88   {$ELSE}
  89     defaultConfigScript = 'dfconfig.cfg';
  90   {$ENDIF}
  91
  92 var
  93   gConsoleShow: Boolean = false; // True - êîíñîëü îòêðûòà èëè îòêðûâàåòñÿ
  94   gChatShow: Boolean = false;
  95   gChatTeam: Boolean = false;
  96   gAllowConsoleMessages: Boolean = true;
  97   gJustChatted: Boolean = false; // ÷òîáû àäìèí â èíòåðå ÷àòÿñü íå ïðîìàòûâàë ñòàòèñòèêó
  98   gParsingBinds: Boolean = true; // íå ïåðåñîõðàíÿòü êîíôèã âî âðåìÿ ïàðñèíãà
  99   gPlayerAction: Array [0..1, 0..LAST_ACTION] of Boolean; // [player, action]
 100   gConfigScript: string = defaultConfigScript;
 101
 102 implementation
 103
 104 uses
 105   {$IFDEF ENABLE_MENU}
 106     g_gui, g_menu,
 107   {$ENDIF}
 108   {$IFDEF ENABLE_TOUCH}
 109     g_system,
 110   {$ENDIF}
 111   {$IFDEF ENABLE_GFX}
 112     g_gfx,
 113   {$ENDIF}
 114   {$IFDEF ENABLE_GIBS}
 115     g_gibs,
 116   {$ENDIF}
 117   {$IFDEF ENABLE_SHELLS}
 118     g_shells,
 119   {$ENDIF}
 120   {$IFDEF ENABLE_CORPSES}
 121     g_corpses,
 122   {$ENDIF}
 123   e_input, g_game, g_player, g_items,
 124   SysUtils, g_basic, g_options, Math, e_res,
 125   g_language, g_net, g_netmsg, e_log, conbuf, g_weapons,
 126   Keyboard;
 127
 128 const
 129   configComment = 'generated by doom2d, do not modify';
 130
 131 type
 132   PCommand = ^TCommand;
 133
 134   TCmdProc = procedure (p: SSArray);
 135   TCmdProcEx = procedure (me: PCommand; p: SSArray);
 136
 137   TCommand = record
 138     cmd: AnsiString;
 139     proc: TCmdProc;
 140     procEx: TCmdProcEx;
 141     help: AnsiString;
 142     hidden: Boolean;
 143     ptr: Pointer; // various data
 144     msg: AnsiString; // message for var changes
 145     cheat: Boolean;
 146     action: Integer; // >= 0 for action commands
 147     player: Integer; // used for action commands
 148   end;
 149
 150   TAlias = record
 151     name: AnsiString;
 152     commands: SSArray;
 153   end;
 154
 155
 156 const
 157   MsgTime = 144;
 158   MaxScriptRecursion = 16;
 159
 160 var
 161   RecursionDepth: Word = 0;
 162   RecursionLimitHit: Boolean = False;
 163   InputReady: Boolean; // allow text input in console/chat
 164   //ConsoleHistory: SSArray;
 165   CommandHistory: SSArray;
 166   Whitelist: SSArray;
 167   commands: Array of TCommand = nil;
 168   Aliases: Array of TAlias = nil;
 169   CmdIndex: Word;
 170
 171   gInputBinds: Array [0..e_MaxInputKeys - 1] of record
 172     rep: Boolean;
 173     down, up: SSArray;
 174   end;
 175
 176   menu_toggled: BOOLEAN; (* hack for menu controls *)
 177   ConsoleStdIn: Boolean;
 178
 179 procedure g_Console_Switch;
 180 begin
 181   gChatShow := False;
 182   gConsoleShow := not gConsoleShow;
 183   InputReady := False;
 184   {$IFDEF ENABLE_TOUCH}
 185     sys_ShowKeyboard(gConsoleShow or gChatShow);
 186   {$ENDIF}
 187 end;
 188
 189 procedure g_Console_Chat_Switch (Team: Boolean = False);
 190 begin
 191   if not g_Game_IsNet then Exit;
 192   gConsoleShow := False;
 193   gChatShow := not gChatShow;
 194   gChatTeam := Team;
 195   InputReady := False;
 196   Line := '';
 197   CPos := 1;
 198   {$IFDEF ENABLE_TOUCH}
 199     sys_ShowKeyboard(gConsoleShow or gChatShow);
 200   {$ENDIF}
 201 end;
 202
 203 // poor man's floating literal parser; i'm sorry, but `StrToFloat()` sux cocks
 204 function conParseFloat (var res: Single; const s: AnsiString): Boolean;
 205 var
 206   pos: Integer = 1;
 207   frac: Single = 1;
 208   slen: Integer;
 209 begin
 210   result := false;
 211   res := 0;
 212   slen := Length(s);
 213   while (slen > 0) and (s[slen] <= ' ') do Dec(slen);
 214   while (pos <= slen) and (s[pos] <= ' ') do Inc(pos);
 215   if (pos > slen) then exit;
 216   if (slen-pos = 1) and (s[pos] = '.') then exit; // single dot
 217   // integral part
 218   while (pos <= slen) do
 219   begin
 220     if (s[pos] < '0') or (s[pos] > '9') then break;
 221     res := res*10+Byte(s[pos])-48;
 222     Inc(pos);
 223   end;
 224   if (pos <= slen) then
 225   begin
 226     // must be a dot
 227     if (s[pos] <> '.') then exit;
 228     Inc(pos);
 229     while (pos <= slen) do
 230     begin
 231       if (s[pos] < '0') or (s[pos] > '9') then break;
 232       frac := frac/10;
 233       res += frac*(Byte(s[pos])-48);
 234       Inc(pos);
 235     end;
 236   end;
 237   if (pos <= slen) then exit; // oops
 238   result := true;
 239 end;
 240
 241
 242 // ////////////////////////////////////////////////////////////////////////// //
 243 // <0: no arg; 0/1: true/false; 666: toggle
 244 function conGetBoolArg (p: SSArray; idx: Integer): Integer;
 245 begin
 246   if (idx < 0) or (idx > High(p)) then begin result := -1; exit; end;
 247   result := 0;
 248   if (p[idx] = '1') or (CompareText(p[idx], 'on') = 0) or (CompareText(p[idx], 'true') = 0) or
 249      (CompareText(p[idx], 'tan') = 0) or (CompareText(p[idx], 'yes') = 0) then result := 1
 250   else if (CompareText(p[idx], 'toggle') = 0) or (CompareText(p[idx], 'switch') = 0) or
 251           (CompareText(p[idx], 't') = 0) then result := 666;
 252 end;
 253
 254
 255 procedure boolVarHandler (me: PCommand; p: SSArray);
 256   procedure binaryFlag (var flag: Boolean; msg: AnsiString);
 257   var
 258     old: Boolean;
 259   begin
 260     if (Length(p) > 2) then
 261     begin
 262       conwritefln('too many arguments to ''%s''', [p[0]]);
 263     end
 264     else
 265     begin
 266       old := flag;
 267       case conGetBoolArg(p, 1) of
 268         -1: begin end;
 269          0: if not me.cheat or conIsCheatsEnabled then flag := false else begin conwriteln('not available'); exit; end;
 270          1: if not me.cheat or conIsCheatsEnabled then flag := true else begin conwriteln('not available'); exit; end;
 271          666: if not me.cheat or conIsCheatsEnabled then flag := not flag else begin conwriteln('not available'); exit; end;
 272       end;
 273       if flag <> old then
 274         g_Console_WriteGameConfig();
 275       if (Length(msg) = 0) then msg := p[0] else msg += ':';
 276       if flag then conwritefln('%s tan', [msg]) else conwritefln('%s ona', [msg]);
 277     end;
 278   end;
 279 begin
 280   binaryFlag(PBoolean(me.ptr)^, me.msg);
 281 end;
 282
 283
 284 procedure intVarHandler (me: PCommand; p: SSArray);
 285 var
 286   old: Integer;
 287 begin
 288   if (Length(p) <> 2) then
 289   begin
 290     conwritefln('%s %d', [me.cmd, PInteger(me.ptr)^]);
 291   end
 292   else
 293   begin
 294     try
 295       old := PInteger(me.ptr)^;
 296       PInteger(me.ptr)^ := StrToInt(p[1]);
 297       if PInteger(me.ptr)^ <> old then
 298         g_Console_WriteGameConfig();
 299     except
 300       conwritefln('invalid integer value: "%s"', [p[1]]);
 301     end;
 302   end;
 303 end;
 304
 305
 306 procedure wordVarHandler (me: PCommand; p: SSArray);
 307 var
 308   old: Integer;
 309 begin
 310   if (Length(p) <> 2) then
 311   begin
 312     conwritefln('%s %d', [me.cmd, PInteger(me.ptr)^]);
 313   end
 314   else
 315   begin
 316     try
 317       old := PWord(me.ptr)^;
 318       PWord(me.ptr)^ := min($FFFF, StrToDWord(p[1]));
 319       if PWord(me.ptr)^ <> old then
 320         g_Console_WriteGameConfig();
 321     except
 322       conwritefln('invalid word value: "%s"', [p[1]]);
 323     end;
 324   end;
 325 end;
 326
 327
 328 procedure dwordVarHandler (me: PCommand; p: SSArray);
 329 var
 330   old: Integer;
 331 begin
 332   if (Length(p) <> 2) then
 333   begin
 334     conwritefln('%s %d', [me.cmd, PInteger(me.ptr)^]);
 335   end
 336   else
 337   begin
 338     try
 339       old := PCardinal(me.ptr)^;
 340       PCardinal(me.ptr)^ := StrToDWord(p[1]);
 341       if PCardinal(me.ptr)^ <> old then
 342         g_Console_WriteGameConfig();
 343     except
 344       conwritefln('invalid dword value: "%s"', [p[1]]);
 345     end;
 346   end;
 347 end;
 348
 349
 350 procedure strVarHandler (me: PCommand; p: SSArray);
 351 var
 352   old: AnsiString;
 353 begin
 354   if (Length(p) <> 2) then
 355   begin
 356     conwritefln('%s %s', [me.cmd, QuoteStr(PAnsiString(me.ptr)^)]);
 357   end
 358   else
 359   begin
 360     old := PAnsiString(me.ptr)^;
 361     PAnsiString(me.ptr)^ := p[1];
 362     if PAnsiString(me.ptr)^ <> old then
 363       g_Console_WriteGameConfig();
 364   end;
 365 end;
 366
 367
 368 procedure conRegVar (const conname: AnsiString; pvar: PBoolean; const ahelp: AnsiString; const amsg: AnsiString; acheat: Boolean=false; ahidden: Boolean=false); overload;
 369 var
 370   f: Integer;
 371   cp: PCommand;
 372 begin
 373   f := Length(commands);
 374   SetLength(commands, f+1);
 375   cp := @commands[f];
 376   cp.cmd := LowerCase(conname);
 377   cp.proc := nil;
 378   cp.procEx := boolVarHandler;
 379   cp.help := ahelp;
 380   cp.hidden := ahidden;
 381   cp.ptr := pvar;
 382   cp.msg := amsg;
 383   cp.cheat := acheat;
 384   cp.action := -1;
 385   cp.player := -1;
 386 end;
 387
 388
 389 procedure conRegVar (const conname: AnsiString; pvar: PInteger; const ahelp: AnsiString; const amsg: AnsiString; acheat: Boolean=false; ahidden: Boolean=false); overload;
 390 var
 391   f: Integer;
 392   cp: PCommand;
 393 begin
 394   f := Length(commands);
 395   SetLength(commands, f+1);
 396   cp := @commands[f];
 397   cp.cmd := LowerCase(conname);
 398   cp.proc := nil;
 399   cp.procEx := intVarHandler;
 400   cp.help := ahelp;
 401   cp.hidden := ahidden;
 402   cp.ptr := pvar;
 403   cp.msg := amsg;
 404   cp.cheat := acheat;
 405   cp.action := -1;
 406   cp.player := -1;
 407 end;
 408
 409
 410 procedure conRegVar (const conname: AnsiString; pvar: PWord; const ahelp: AnsiString; const amsg: AnsiString; acheat: Boolean=false; ahidden: Boolean=false); overload;
 411 var
 412   f: Integer;
 413   cp: PCommand;
 414 begin
 415   f := Length(commands);
 416   SetLength(commands, f+1);
 417   cp := @commands[f];
 418   cp.cmd := LowerCase(conname);
 419   cp.proc := nil;
 420   cp.procEx := wordVarHandler;
 421   cp.help := ahelp;
 422   cp.hidden := ahidden;
 423   cp.ptr := pvar;
 424   cp.msg := amsg;
 425   cp.cheat := acheat;
 426   cp.action := -1;
 427   cp.player := -1;
 428 end;
 429
 430
 431 procedure conRegVar (const conname: AnsiString; pvar: PCardinal; const ahelp: AnsiString; const amsg: AnsiString; acheat: Boolean=false; ahidden: Boolean=false); overload;
 432 var
 433   f: Integer;
 434   cp: PCommand;
 435 begin
 436   f := Length(commands);
 437   SetLength(commands, f+1);
 438   cp := @commands[f];
 439   cp.cmd := LowerCase(conname);
 440   cp.proc := nil;
 441   cp.procEx := dwordVarHandler;
 442   cp.help := ahelp;
 443   cp.hidden := ahidden;
 444   cp.ptr := pvar;
 445   cp.msg := amsg;
 446   cp.cheat := acheat;
 447   cp.action := -1;
 448   cp.player := -1;
 449 end;
 450
 451
 452 procedure conRegVar (const conname: AnsiString; pvar: PAnsiString; const ahelp: AnsiString; const amsg: AnsiString; acheat: Boolean=false; ahidden: Boolean=false); overload;
 453 var
 454   f: Integer;
 455   cp: PCommand;
 456 begin
 457   f := Length(commands);
 458   SetLength(commands, f+1);
 459   cp := @commands[f];
 460   cp.cmd := LowerCase(conname);
 461   cp.proc := nil;
 462   cp.procEx := strVarHandler;
 463   cp.help := ahelp;
 464   cp.hidden := ahidden;
 465   cp.ptr := pvar;
 466   cp.msg := amsg;
 467   cp.cheat := acheat;
 468   cp.action := -1;
 469   cp.player := -1;
 470 end;
 471
 472 // ////////////////////////////////////////////////////////////////////////// //
 473 type
 474   PVarSingle = ^TVarSingle;
 475   TVarSingle = record
 476     val: PSingle;
 477     min, max, def: Single; // default will be starting value
 478   end;
 479
 480
 481 procedure singleVarHandler (me: PCommand; p: SSArray);
 482 var
 483   pv: PVarSingle;
 484   nv, old: Single;
 485   msg: AnsiString;
 486 begin
 487   if (Length(p) > 2) then
 488   begin
 489     conwritefln('too many arguments to ''%s''', [me.cmd]);
 490     exit;
 491   end;
 492   pv := PVarSingle(me.ptr);
 493   old := pv.val^;
 494   if (Length(p) = 2) then
 495   begin
 496     if me.cheat and (not conIsCheatsEnabled) then begin conwriteln('not available'); exit; end;
 497     if (CompareText(p[1], 'default') = 0) or (CompareText(p[1], 'def') = 0) or
 498        (CompareText(p[1], 'd') = 0) or (CompareText(p[1], 'off') = 0) or
 499        (CompareText(p[1], 'ona') = 0) then
 500     begin
 501       pv.val^ := pv.def;
 502     end
 503     else
 504     begin
 505       if not conParseFloat(nv, p[1]) then
 506       begin
 507         conwritefln('%s: ''%s'' doesn''t look like a floating number', [me.cmd, p[1]]);
 508         exit;
 509       end;
 510       if (nv < pv.min) then nv := pv.min;
 511       if (nv > pv.max) then nv := pv.max;
 512       pv.val^ := nv;
 513     end;
 514   end;
 515   if pv.val^ <> old then
 516     g_Console_WriteGameConfig();
 517   msg := me.msg;
 518   if (Length(msg) = 0) then msg := me.cmd else msg += ':';
 519   conwritefln('%s %s', [msg, pv.val^]);
 520 end;
 521
 522
 523 procedure conRegVar (const conname: AnsiString; pvar: PSingle; amin, amax: Single; const ahelp: AnsiString; const amsg: AnsiString; acheat: Boolean=false; ahidden: Boolean=false); overload;
 524 var
 525   f: Integer;
 526   cp: PCommand;
 527   pv: PVarSingle;
 528 begin
 529   GetMem(pv, sizeof(TVarSingle));
 530   pv.val := pvar;
 531   pv.min := amin;
 532   pv.max := amax;
 533   pv.def := pvar^;
 534   f := Length(commands);
 535   SetLength(commands, f+1);
 536   cp := @commands[f];
 537   cp.cmd := LowerCase(conname);
 538   cp.proc := nil;
 539   cp.procEx := singleVarHandler;
 540   cp.help := ahelp;
 541   cp.hidden := ahidden;
 542   cp.ptr := pv;
 543   cp.msg := amsg;
 544   cp.cheat := acheat;
 545   cp.action := -1;
 546   cp.player := -1;
 547 end;
 548
 549
 550 // ////////////////////////////////////////////////////////////////////////// //
 551 function GetStrACmd(var Str: AnsiString): AnsiString;
 552 var
 553   a: Integer;
 554 begin
 555   Result := '';
 556   for a := 1 to Length(Str) do
 557     if (a = Length(Str)) or (Str[a+1] = ';') then
 558     begin
 559       Result := Copy(Str, 1, a);
 560       Delete(Str, 1, a+1);
 561       Str := Trim(Str);
 562       Exit;
 563     end;
 564 end;
 565
 566 function ParseAlias(Str: AnsiString): SSArray;
 567 begin
 568   Result := nil;
 569
 570   Str := Trim(Str);
 571
 572   if Str = '' then
 573     Exit;
 574
 575   while Str <> '' do
 576   begin
 577     SetLength(Result, Length(Result)+1);
 578     Result[High(Result)] := GetStrACmd(Str);
 579   end;
 580 end;
 581
 582 procedure ConsoleCommands(p: SSArray);
 583 var
 584   cmd, s: AnsiString;
 585   a, b: Integer;
 586   (* F: TextFile; *)
 587 begin
 588   cmd := LowerCase(p[0]);
 589   s := '';
 590
 591   if cmd = 'clear' then
 592   begin
 593     //ConsoleHistory := nil;
 594     cbufClear();
 595     conSkipLines := 0;
 596
 597     for a := 0 to High(MsgArray) do
 598       with MsgArray[a] do
 599       begin
 600         Msg := '';
 601         Time := 0;
 602       end;
 603   end;
 604
 605   if cmd = 'clearhistory' then
 606     CommandHistory := nil;
 607
 608   if cmd = 'showhistory' then
 609     if CommandHistory <> nil then
 610     begin
 611       g_Console_Add('');
 612       for a := 0 to High(CommandHistory) do
 613         g_Console_Add('  '+CommandHistory[a]);
 614     end;
 615
 616   if cmd = 'commands' then
 617   begin
 618     g_Console_Add('');
 619     g_Console_Add('commands list:');
 620     for a := High(commands) downto 0 do
 621     begin
 622       if (Length(commands[a].help) > 0) then
 623       begin
 624         g_Console_Add('  '+commands[a].cmd+' -- '+commands[a].help);
 625       end
 626       else
 627       begin
 628         g_Console_Add('  '+commands[a].cmd);
 629       end;
 630     end;
 631   end;
 632
 633   if cmd = 'time' then
 634     g_Console_Add(TimeToStr(Now), True);
 635
 636   if cmd = 'date' then
 637     g_Console_Add(DateToStr(Now), True);
 638
 639   if cmd = 'echo' then
 640     if Length(p) > 1 then
 641       begin
 642         if p[1] = 'ololo' then
 643           gCheats := True
 644         else
 645         begin
 646           s := '';
 647           for a := 1 to High(p) do
 648             s := s + p[a] + ' ';
 649           g_Console_Add(b_Text_Format(s), True);
 650         end;
 651       end
 652     else
 653       g_Console_Add('');
 654
 655   if cmd = 'dump' then
 656   begin
 657     (*
 658     if ConsoleHistory <> nil then
 659     begin
 660       if Length(P) > 1 then
 661         s := P[1]
 662       else
 663         s := GameDir+'/console.txt';
 664
 665       {$I-}
 666       AssignFile(F, s);
 667       Rewrite(F);
 668       if IOResult <> 0 then
 669       begin
 670         g_Console_Add(Format(_lc[I_CONSOLE_ERROR_WRITE], [s]));
 671         CloseFile(F);
 672         Exit;
 673       end;
 674
 675       for a := 0 to High(ConsoleHistory) do
 676         WriteLn(F, ConsoleHistory[a]);
 677
 678       CloseFile(F);
 679       g_Console_Add(Format(_lc[I_CONSOLE_DUMPED], [s]));
 680       {$I+}
 681     end;
 682     *)
 683   end;
 684
 685   if cmd = 'exec' then
 686   begin
 687     // exec <filename>
 688     if Length(p) = 2 then
 689       g_Console_ReadConfig(p[1])
 690     else
 691       g_Console_Add('exec <script file>');
 692   end;
 693
 694   if cmd = 'writeconfig' then
 695   begin
 696     // writeconfig <filename>
 697     if Length(p) = 2 then
 698     begin
 699       s := e_GetWriteableDir(ConfigDirs);
 700       g_Console_WriteConfig(e_CatPath(s, p[1]))
 701     end
 702     else
 703     begin
 704       g_Console_Add('writeconfig <file>')
 705     end
 706   end;
 707
 708   if (cmd = 'ver') or (cmd = 'version') then
 709   begin
 710     conwriteln('Doom 2D: Forever v. ' + GAME_VERSION);
 711     conwritefln('Net protocol v. %d', [NET_PROTOCOL_VER]);
 712     conwritefln('Build date: %s at %s', [GAME_BUILDDATE, GAME_BUILDTIME]);
 713   end;
 714
 715   if cmd = 'alias' then
 716   begin
 717     // alias [alias_name] [commands]
 718     if Length(p) > 1 then
 719     begin
 720       for a := 0 to High(Aliases) do
 721         if Aliases[a].name = p[1] then
 722         begin
 723           if Length(p) > 2 then
 724             Aliases[a].commands := ParseAlias(p[2])
 725           else
 726             for b := 0 to High(Aliases[a].commands) do
 727               g_Console_Add(Aliases[a].commands[b]);
 728           Exit;
 729         end;
 730       SetLength(Aliases, Length(Aliases)+1);
 731       a := High(Aliases);
 732       Aliases[a].name := p[1];
 733       if Length(p) > 2 then
 734         Aliases[a].commands := ParseAlias(p[2])
 735       else
 736         for b := 0 to High(Aliases[a].commands) do
 737           g_Console_Add(Aliases[a].commands[b]);
 738     end else
 739       for a := 0 to High(Aliases) do
 740         if Aliases[a].commands <> nil then
 741           g_Console_Add(Aliases[a].name);
 742   end;
 743
 744   if cmd = 'call' then
 745   begin
 746     // call <alias_name>
 747     if Length(p) > 1 then
 748     begin
 749       if Aliases = nil then
 750         Exit;
 751       for a := 0 to High(Aliases) do
 752         if Aliases[a].name = p[1] then
 753         begin
 754           if Aliases[a].commands <> nil then
 755           begin
 756             // with this system proper endless loop detection seems either impossible
 757             // or very dirty to implement, so let's have this instead
 758             // prevents endless loops
 759             for b := 0 to High(Aliases[a].commands) do
 760             begin
 761               Inc(RecursionDepth);
 762               RecursionLimitHit := (RecursionDepth > MaxScriptRecursion) or RecursionLimitHit;
 763               if not RecursionLimitHit then
 764                 g_Console_Process(Aliases[a].commands[b], True);
 765               Dec(RecursionDepth);
 766             end;
 767             if (RecursionDepth = 0) and RecursionLimitHit then
 768             begin
 769               g_Console_Add(Format(_lc[I_CONSOLE_ERROR_CALL], [s]));
 770               RecursionLimitHit := False;
 771             end;
 772           end;
 773           Exit;
 774         end;
 775     end
 776     else
 777       g_Console_Add('call <alias name>');
 778   end;
 779 end;
 780
 781 procedure WhitelistCommand(cmd: AnsiString);
 782 var
 783   a: Integer;
 784 begin
 785   SetLength(Whitelist, Length(Whitelist)+1);
 786   a := High(Whitelist);
 787   Whitelist[a] := LowerCase(cmd);
 788 end;
 789
 790 procedure segfault (p: SSArray);
 791 var
 792   pp: PByte = nil;
 793 begin
 794   pp^ := 0;
 795 end;
 796
 797 function GetCommandString (p: SSArray): AnsiString;
 798   var i: Integer;
 799 begin
 800   result := '';
 801   if Length(p) >= 1 then
 802   begin
 803     result := p[0];
 804     for i := 1 to High(p) do
 805       result := result + '; ' + p[i]
 806   end
 807 end;
 808
 809 function QuoteStr(str: String): String;
 810 begin
 811   if Pos(' ', str) > 0 then
 812     Result := '"' + str + '"'
 813   else
 814     Result := str;
 815 end;
 816
 817 procedure BindCommands (p: SSArray);
 818   var cmd, key: AnsiString; i: Integer;
 819 begin
 820   cmd := LowerCase(p[0]);
 821   case cmd of
 822   'bind':
 823     // bind <key> [down [up]]
 824     if (Length(p) >= 2) and (Length(p) <= 4) then
 825     begin
 826       i := 0;
 827       key := LowerCase(p[1]);
 828       while (i < e_MaxInputKeys) and (key <> LowerCase(e_KeyNames[i])) do inc(i);
 829       if i < e_MaxInputKeys then
 830       begin
 831         if Length(p) = 2 then
 832           g_Console_Add(QuoteStr(e_KeyNames[i]) + ' = ' + QuoteStr(GetCommandString(gInputBinds[i].down)) + ' ' + QuoteStr(GetCommandString(gInputBinds[i].up)))
 833         else if Length(p) = 3 then
 834           g_Console_BindKey(i, p[2], '')
 835         else (* len = 4 *)
 836           g_Console_BindKey(i, p[2], p[3])
 837       end
 838       else
 839         g_Console_Add('bind: "' + p[1] + '" is not a key')
 840     end
 841     else
 842     begin
 843       g_Console_Add('bind <key> <down action> [up action]')
 844     end;
 845   'bindrep':
 846     // bindrep <key>
 847     if Length(p) = 2 then
 848     begin
 849       key := LowerCase(p[1]);
 850       i := 0;
 851       while (i < e_MaxInputKeys) and (key <> LowerCase(e_KeyNames[i])) do inc(i);
 852       if i < e_MaxInputKeys then
 853         gInputBinds[i].rep := True
 854       else
 855         g_Console_Add('bindrep: "' + p[1] + '" is not a key')
 856     end
 857     else
 858       g_Console_Add('bindrep <key>');
 859   'bindunrep':
 860     // bindunrep <key>
 861     if Length(p) = 2 then
 862     begin
 863       key := LowerCase(p[1]);
 864       i := 0;
 865       while (i < e_MaxInputKeys) and (key <> LowerCase(e_KeyNames[i])) do inc(i);
 866       if i < e_MaxInputKeys then
 867         gInputBinds[i].rep := False
 868       else
 869         g_Console_Add('bindunrep: "' + p[1] + '" is not a key')
 870     end
 871     else
 872       g_Console_Add('bindunrep <key>');
 873   'bindlist':
 874     for i := 0 to e_MaxInputKeys - 1 do
 875       if (gInputBinds[i].down <> nil) or (gInputBinds[i].up <> nil) then
 876         g_Console_Add(e_KeyNames[i] + ' ' + QuoteStr(GetCommandString(gInputBinds[i].down)) + ' ' + QuoteStr(GetCommandString(gInputBinds[i].up)));
 877   'unbind':
 878     // unbind <key>
 879     if Length(p) = 2 then
 880     begin
 881       key := LowerCase(p[1]);
 882       i := 0;
 883       while (i < e_MaxInputKeys) and (key <> LowerCase(e_KeyNames[i])) do inc(i);
 884       if i < e_MaxInputKeys then
 885         g_Console_BindKey(i, '')
 886       else
 887         g_Console_Add('unbind: "' + p[1] + '" is not a key')
 888     end
 889     else
 890       g_Console_Add('unbind <key>');
 891   'unbindall':
 892     for i := 0 to e_MaxInputKeys - 1 do
 893       g_Console_BindKey(i, '');
 894 {$IFDEF ENABLE_TOUCH}
 895   'showkeyboard':
 896     sys_ShowKeyboard(True);
 897   'hidekeyboard':
 898     sys_ShowKeyboard(False);
 899 {$ENDIF}
 900   'togglemenu':
 901     begin
 902       if gConsoleShow then
 903         g_Console_Switch
 904       else if gChatShow then
 905         g_Console_Chat_Switch
 906       else
 907       begin
 908         KeyPress(VK_ESCAPE);
 909       end;
 910       menu_toggled := True
 911     end;
 912   'toggleconsole':
 913     g_Console_Switch;
 914   'togglechat':
 915     g_Console_Chat_Switch;
 916   'toggleteamchat':
 917     if gGameSettings.GameMode in [GM_TDM, GM_CTF] then
 918       g_Console_Chat_Switch(True);
 919   end
 920 end;
 921
 922 procedure AddCommand(cmd: AnsiString; proc: TCmdProc; ahelp: AnsiString=''; ahidden: Boolean=false; acheat: Boolean=false);
 923 var
 924   a: Integer;
 925   cp: PCommand;
 926 begin
 927   SetLength(commands, Length(commands)+1);
 928   a := High(commands);
 929   cp := @commands[a];
 930   cp.cmd := LowerCase(cmd);
 931   cp.proc := proc;
 932   cp.procEx := nil;
 933   cp.help := ahelp;
 934   cp.hidden := ahidden;
 935   cp.ptr := nil;
 936   cp.msg := '';
 937   cp.cheat := acheat;
 938   cp.action := -1;
 939   cp.player := -1;
 940 end;
 941
 942 procedure AddAction (cmd: AnsiString; action: Integer; help: AnsiString = ''; hidden: Boolean = False; cheat: Boolean = False);
 943   const
 944     PrefixList: array [0..1] of AnsiString = ('+', '-');
 945     PlayerList: array [0..1] of Integer = (1, 2);
 946   var
 947     s: AnsiString;
 948     i: Integer;
 949
 950   procedure NewAction (cmd: AnsiString; player: Integer);
 951     var cp: PCommand;
 952   begin
 953     SetLength(commands, Length(commands) + 1);
 954     cp := @commands[High(commands)];
 955     cp.cmd := LowerCase(cmd);
 956     cp.proc := nil;
 957     cp.procEx := nil;
 958     cp.help := help;
 959     cp.hidden := hidden;
 960     cp.ptr := nil;
 961     cp.msg := '';
 962     cp.cheat := cheat;
 963     cp.action := action;
 964     cp.player := player;
 965   end;
 966
 967 begin
 968   ASSERT(action >= FIRST_ACTION);
 969   ASSERT(action <= LAST_ACTION);
 970   for s in PrefixList do
 971   begin
 972     NewAction(s + cmd, 0);
 973     for i in PlayerList do
 974       NewAction(s + 'p' + IntToStr(i) + '_' + cmd, i - 1)
 975   end
 976 end;
 977
 978 procedure ReadStdIn;
 979 var
 980   K: Char;
 981   KEv: TKeyEvent;
 982 begin
 983   gConsoleShow := True;
 984   InputReady := True;
 985   // one key per frame
 986   KEv := PollKeyEvent();
 987   if KEv <> 0 then
 988   begin
 989     K := GetKeyEventChar(TranslateKeyEvent(GetKeyEvent()));
 990     Write(K);
 991     case K of
 992       #8: g_Console_Control(IK_BACKSPACE);
 993       #10, #13: g_Console_Control(IK_RETURN);
 994       #32..#126: g_Console_Char(K);
 995       // arrow keys and DEL all return 0 for some reason, so fuck em
 996     end;
 997   end;
 998 end;
 999
1000 procedure g_Console_Initialize;
1001   var a: Integer;
1002 begin
1003   gConsoleShow := False;
1004   gChatShow := False;
1005   InputReady := False;
1006   CPos := 1;
1007
1008   for a := 0 to High(MsgArray) do
1009     with MsgArray[a] do
1010     begin
1011       Msg := '';
1012       Time := 0;
1013     end;
1014
1015   AddCommand('segfault', segfault, 'make segfault');
1016
1017   AddCommand('quit', SystemCommands);
1018   AddCommand('exit', SystemCommands);
1019   AddCommand('r_reset', SystemCommands);
1020   AddCommand('r_maxfps', SystemCommands);
1021   AddCommand('g_language', SystemCommands);
1022
1023   AddCommand('bind', BindCommands);
1024   AddCommand('bindrep', BindCommands);
1025   AddCommand('bindunrep', BindCommands);
1026   AddCommand('bindlist', BindCommands);
1027   AddCommand('unbind', BindCommands);
1028   AddCommand('unbindall', BindCommands);
1029   AddCommand('showkeyboard', BindCommands);
1030   AddCommand('hidekeyboard', BindCommands);
1031   AddCommand('togglemenu', BindCommands);
1032   AddCommand('toggleconsole', BindCommands);
1033   AddCommand('togglechat', BindCommands);
1034   AddCommand('toggleteamchat', BindCommands);
1035
1036   AddCommand('clear', ConsoleCommands, 'clear console');
1037   AddCommand('clearhistory', ConsoleCommands);
1038   AddCommand('showhistory', ConsoleCommands);
1039   AddCommand('commands', ConsoleCommands);
1040   AddCommand('time', ConsoleCommands);
1041   AddCommand('date', ConsoleCommands);
1042   AddCommand('echo', ConsoleCommands);
1043   AddCommand('dump', ConsoleCommands);
1044   AddCommand('exec', ConsoleCommands);
1045   AddCommand('writeconfig', ConsoleCommands);
1046   AddCommand('alias', ConsoleCommands);
1047   AddCommand('call', ConsoleCommands);
1048   AddCommand('ver', ConsoleCommands);
1049   AddCommand('version', ConsoleCommands);
1050
1051   AddCommand('d_window', DebugCommands);
1052   AddCommand('d_winmsg', DebugCommands);
1053   AddCommand('d_monoff', DebugCommands);
1054   AddCommand('d_botoff', DebugCommands);
1055   AddCommand('d_monster', DebugCommands);
1056   AddCommand('d_health', DebugCommands);
1057   AddCommand('d_player', DebugCommands);
1058   AddCommand('d_joy', DebugCommands);
1059   AddCommand('d_mem', DebugCommands);
1060
1061   AddCommand('p1_name', PlayerSettingsCVars);
1062   AddCommand('p2_name', PlayerSettingsCVars);
1063   AddCommand('p1_color', PlayerSettingsCVars);
1064   AddCommand('p2_color', PlayerSettingsCVars);
1065   AddCommand('p1_model', PlayerSettingsCVars);
1066   AddCommand('p2_model', PlayerSettingsCVars);
1067   AddCommand('p1_team', PlayerSettingsCVars);
1068   AddCommand('p2_team', PlayerSettingsCVars);
1069   AddCommand('p1_autoswitch', PlayerSettingsCVars);
1070   AddCommand('p2_autoswitch', PlayerSettingsCVars);
1071   AddCommand('p1_switch_empty', PlayerSettingsCVars);
1072   AddCommand('p2_switch_empty', PlayerSettingsCVars);
1073   AddCommand('p1_skip_fist', PlayerSettingsCVars);
1074   AddCommand('p2_skip_fist', PlayerSettingsCVars);
1075   AddCommand('p1_priority_kastet', PlayerSettingsCVars);
1076   AddCommand('p2_priority_kastet', PlayerSettingsCVars);
1077   AddCommand('p1_priority_saw', PlayerSettingsCVars);
1078   AddCommand('p2_priority_saw', PlayerSettingsCVars);
1079   AddCommand('p1_priority_pistol', PlayerSettingsCVars);
1080   AddCommand('p2_priority_pistol', PlayerSettingsCVars);
1081   AddCommand('p1_priority_shotgun1', PlayerSettingsCVars);
1082   AddCommand('p2_priority_shotgun1', PlayerSettingsCVars);
1083   AddCommand('p1_priority_shotgun2', PlayerSettingsCVars);
1084   AddCommand('p2_priority_shotgun2', PlayerSettingsCVars);
1085   AddCommand('p1_priority_chaingun', PlayerSettingsCVars);
1086   AddCommand('p2_priority_chaingun', PlayerSettingsCVars);
1087   AddCommand('p1_priority_rocketlauncher', PlayerSettingsCVars);
1088   AddCommand('p2_priority_rocketlauncher', PlayerSettingsCVars);
1089   AddCommand('p1_priority_plasma', PlayerSettingsCVars);
1090   AddCommand('p2_priority_plasma', PlayerSettingsCVars);
1091   AddCommand('p1_priority_bfg', PlayerSettingsCVars);
1092   AddCommand('p2_priority_bfg', PlayerSettingsCVars);
1093   AddCommand('p1_priority_super', PlayerSettingsCVars);
1094   AddCommand('p2_priority_super', PlayerSettingsCVars);
1095   AddCommand('p1_priority_flamethrower', PlayerSettingsCVars);
1096   AddCommand('p2_priority_flamethrower', PlayerSettingsCVars);
1097   AddCommand('p1_priority_berserk', PlayerSettingsCVars);
1098   AddCommand('p2_priority_berserk', PlayerSettingsCVars);
1099
1100   AddCommand('g_max_particles', GameCVars);
1101   AddCommand('g_max_shells', GameCVars);
1102   AddCommand('g_max_gibs', GameCVars);
1103   AddCommand('g_max_corpses', GameCVars);
1104   AddCommand('g_force_model', GameCVars);
1105   AddCommand('g_force_model_name', GameCVars);
1106   AddCommand('g_gamemode', GameCVars);
1107   AddCommand('g_friendlyfire', GameCVars);
1108   AddCommand('g_friendly_hit_trace', GameCVars);
1109   AddCommand('g_friendly_hit_projectile', GameCVars);
1110   AddCommand('g_friendly_absorb_damage', GameCVars);
1111   AddCommand('g_weaponstay', GameCVars);
1112   AddCommand('g_allow_exit', GameCVars);
1113   AddCommand('g_dm_keys', GameCVars);
1114   AddCommand('g_allow_monsters', GameCVars);
1115   AddCommand('g_allow_dropflag', GameCVars);
1116   AddCommand('g_throw_flag', GameCVars);
1117   AddCommand('g_bot_vsmonsters', GameCVars);
1118   AddCommand('g_bot_vsplayers', GameCVars);
1119   AddCommand('g_max_bots', GameCVars); // intentionally not whitelisted
1120   AddCommand('g_scorelimit', GameCVars);
1121   AddCommand('g_timelimit', GameCVars);
1122   AddCommand('g_maxlives', GameCVars);
1123   AddCommand('g_warmup_time', GameCVars);
1124   AddCommand('g_spawn_invul', GameCVars);
1125   AddCommand('g_item_respawn_time', GameCVars);
1126   AddCommand('sv_intertime', GameCVars);
1127
1128   AddCommand('sv_name', NetServerCVars);
1129   AddCommand('sv_passwd', NetServerCVars);
1130   AddCommand('sv_maxplrs', NetServerCVars);
1131   AddCommand('sv_public', NetServerCVars);
1132   AddCommand('sv_port', NetServerCVars);
1133
1134   AddCommand('pause', GameCommands);
1135   AddCommand('endgame', GameCommands);
1136   AddCommand('restart', GameCommands);
1137   AddCommand('addbot', GameCommands);
1138   AddCommand('bot_add', GameCommands);
1139   AddCommand('bot_addlist', GameCommands);
1140   AddCommand('bot_addred', GameCommands);
1141   AddCommand('bot_addblue', GameCommands);
1142   AddCommand('bot_removeall', GameCommands);
1143   AddCommand('chat', GameCommands);
1144   AddCommand('teamchat', GameCommands);
1145   AddCommand('announce', GameCommands);
1146   AddCommand('an', GameCommands);
1147   AddCommand('game', GameCommands);
1148   AddCommand('host', GameCommands);
1149   AddCommand('map', GameCommands);
1150   AddCommand('nextmap', GameCommands);
1151   AddCommand('endmap', GameCommands);
1152   AddCommand('goodbye', GameCommands);
1153   AddCommand('suicide', GameCommands);
1154   AddCommand('spectate', GameCommands);
1155   AddCommand('ready', GameCommands);
1156   AddCommand('kick', GameCommands);
1157   AddCommand('kick_id', GameCommands);
1158   AddCommand('kick_pid', GameCommands);
1159   AddCommand('ban', GameCommands);
1160   AddCommand('ban_id', GameCommands);
1161   AddCommand('ban_pid', GameCommands);
1162   AddCommand('permban', GameCommands);
1163   AddCommand('permban_id', GameCommands);
1164   AddCommand('permban_pid', GameCommands);
1165   AddCommand('permban_ip', GameCommands);
1166   AddCommand('unban', GameCommands);
1167   AddCommand('connect', GameCommands);
1168   AddCommand('disconnect', GameCommands);
1169   AddCommand('reconnect', GameCommands);
1170   AddCommand('say', GameCommands);
1171   AddCommand('tell', GameCommands);
1172   AddCommand('centerprint', GameCommands);
1173   AddCommand('overtime', GameCommands);
1174   AddCommand('rcon_password', GameCommands);
1175   AddCommand('rcon', GameCommands);
1176   AddCommand('callvote', GameCommands);
1177   AddCommand('vote', GameCommands);
1178   AddCommand('clientlist', GameCommands);
1179   AddCommand('event', GameCommands);
1180   AddCommand('screenshot', GameCommands);
1181   AddCommand('weapnext', GameCommands);
1182   AddCommand('weapprev', GameCommands);
1183   AddCommand('weapon', GameCommands);
1184   AddCommand('dropflag', GameCommands);
1185   AddCommand('p1_weapnext', GameCommands);
1186   AddCommand('p1_weapprev', GameCommands);
1187   AddCommand('p1_weapon', GameCommands);
1188   AddCommand('p1_weapbest', GameCommands);
1189   AddCommand('p1_dropflag', GameCommands);
1190   AddCommand('p2_weapnext', GameCommands);
1191   AddCommand('p2_weapprev', GameCommands);
1192   AddCommand('p2_weapon', GameCommands);
1193   AddCommand('p2_weapbest', GameCommands);
1194   AddCommand('p2_dropflag', GameCommands);
1195
1196   AddCommand('god', GameCheats);
1197   AddCommand('notarget', GameCheats);
1198   AddCommand('give', GameCheats); // "exit" too ;-)
1199   AddCommand('open', GameCheats);
1200   AddCommand('fly', GameCheats);
1201   AddCommand('noclip', GameCheats);
1202   AddCommand('speedy', GameCheats);
1203   AddCommand('jumpy', GameCheats);
1204   AddCommand('noreload', GameCheats);
1205   AddCommand('aimline', GameCheats);
1206   AddCommand('automap', GameCheats);
1207
1208   AddAction('jump', ACTION_JUMP);
1209   AddAction('moveleft', ACTION_MOVELEFT);
1210   AddAction('moveright', ACTION_MOVERIGHT);
1211   AddAction('lookup', ACTION_LOOKUP);
1212   AddAction('lookdown', ACTION_LOOKDOWN);
1213   AddAction('attack', ACTION_ATTACK);
1214   AddAction('scores', ACTION_SCORES);
1215   AddAction('activate', ACTION_ACTIVATE);
1216   AddAction('strafe', ACTION_STRAFE);
1217
1218   WhitelistCommand('say');
1219   WhitelistCommand('tell');
1220   WhitelistCommand('overtime');
1221   WhitelistCommand('ready');
1222   WhitelistCommand('map');
1223   WhitelistCommand('nextmap');
1224   WhitelistCommand('endmap');
1225   WhitelistCommand('restart');
1226   WhitelistCommand('kick');
1227   WhitelistCommand('kick_pid');
1228   WhitelistCommand('ban');
1229   WhitelistCommand('ban_pid');
1230   WhitelistCommand('centerprint');
1231
1232   WhitelistCommand('addbot');
1233   WhitelistCommand('bot_add');
1234   WhitelistCommand('bot_addred');
1235   WhitelistCommand('bot_addblue');
1236   WhitelistCommand('bot_removeall');
1237
1238   WhitelistCommand('g_gamemode');
1239   WhitelistCommand('g_friendlyfire');
1240   WhitelistCommand('g_friendly_hit_trace');
1241   WhitelistCommand('g_friendly_hit_projectile');
1242   WhitelistCommand('g_friendly_absorb_damage');
1243   WhitelistCommand('g_weaponstay');
1244   WhitelistCommand('g_allow_exit');
1245   WhitelistCommand('g_dm_keys');
1246   WhitelistCommand('g_allow_monsters');
1247   WhitelistCommand('g_bot_vsmonsters');
1248   WhitelistCommand('g_bot_vsplayers');
1249   WhitelistCommand('g_scorelimit');
1250   WhitelistCommand('g_timelimit');
1251   WhitelistCommand('g_maxlives');
1252   WhitelistCommand('g_warmup_time');
1253   WhitelistCommand('g_spawn_invul');
1254   WhitelistCommand('g_item_respawn_time');
1255
1256   g_Console_ResetBinds;
1257   g_Console_ReadConfig(gConfigScript);
1258 //  g_Console_ReadConfig(autoexecScript);
1259   g_Console_ReadConfig('autoexec.cfg');
1260
1261   gParsingBinds := False;
1262 end;
1263
1264 procedure g_Console_Finalize;
1265 begin
1266
1267 end;
1268
1269 procedure g_Console_Init;
1270 begin
1271   g_Console_Add(Format(_lc[I_CONSOLE_WELCOME], [GAME_VERSION]));
1272   g_Console_Add('');
1273 {$IFDEF HEADLESS}
1274   if ConsoleStdIn then
1275   begin
1276     InitKeyboard();
1277     conbufStdOutRawMode := true;
1278   end;
1279 {$ENDIF}
1280 end;
1281
1282 procedure g_Console_Update;
1283 var
1284   a, b: Integer;
1285 begin
1286 {$IFDEF HEADLESS}
1287   if ConsoleStdIn then
1288     ReadStdIn();
1289 {$ENDIF}
1290   InputReady := gConsoleShow or gChatShow;
1291
1292   a := 0;
1293   while a <= High(MsgArray) do
1294   begin
1295     if MsgArray[a].Time > 0 then
1296     begin
1297       if MsgArray[a].Time = 1 then
1298         begin
1299           if a < High(MsgArray) then
1300           begin
1301             for b := a to High(MsgArray)-1 do
1302               MsgArray[b] := MsgArray[b+1];
1303
1304             MsgArray[High(MsgArray)].Time := 0;
1305
1306             a := a - 1;
1307           end;
1308         end
1309       else
1310         Dec(MsgArray[a].Time);
1311     end;
1312
1313     a := a + 1;
1314   end;
1315 end;
1316
1317 procedure g_Console_Char(C: AnsiChar);
1318 begin
1319   if InputReady and (gConsoleShow or gChatShow) then
1320   begin
1321     Insert(C, Line, CPos);
1322     CPos := CPos + 1;
1323   end
1324 end;
1325
1326
1327 var
1328   tcomplist: array of AnsiString = nil;
1329   tcompidx: array of Integer = nil;
1330
1331 procedure Complete ();
1332 var
1333   i, c: Integer;
1334   tused: Integer;
1335   ll, lpfx, cmd: AnsiString;
1336 begin
1337   if (Length(Line) = 0) then
1338   begin
1339     g_Console_Add('');
1340     for i := 0 to High(commands) do
1341     begin
1342       // hidden commands are hidden when cheats aren't enabled
1343       if commands[i].hidden and not conIsCheatsEnabled then continue;
1344       if (Length(commands[i].help) > 0) then
1345       begin
1346         g_Console_Add('  '+commands[i].cmd+' -- '+commands[i].help);
1347       end
1348       else
1349       begin
1350         g_Console_Add('  '+commands[i].cmd);
1351       end;
1352     end;
1353     exit;
1354   end;
1355
1356   ll := LowerCase(Line);
1357   lpfx := '';
1358
1359   if (Length(ll) > 1) and (ll[Length(ll)] = ' ') then
1360   begin
1361     ll := Copy(ll, 0, Length(ll)-1);
1362     for i := 0 to High(commands) do
1363     begin
1364       // hidden commands are hidden when cheats aren't enabled
1365       if commands[i].hidden and not conIsCheatsEnabled then continue;
1366       if (commands[i].cmd = ll) then
1367       begin
1368         if (Length(commands[i].help) > 0) then
1369         begin
1370           g_Console_Add('  '+commands[i].cmd+' -- '+commands[i].help);
1371         end;
1372       end;
1373     end;
1374     exit;
1375   end;
1376
1377   // build completion list
1378   tused := 0;
1379   for i := 0 to High(commands) do
1380   begin
1381     // hidden commands are hidden when cheats aren't enabled
1382     if commands[i].hidden and not conIsCheatsEnabled then continue;
1383     cmd := commands[i].cmd;
1384     if (Length(cmd) >= Length(ll)) and (ll = Copy(cmd, 0, Length(ll))) then
1385     begin
1386       if (tused = Length(tcomplist)) then
1387       begin
1388         SetLength(tcomplist, Length(tcomplist)+128);
1389         SetLength(tcompidx, Length(tcompidx)+128);
1390       end;
1391       tcomplist[tused] := cmd;
1392       tcompidx[tused] := i;
1393       Inc(tused);
1394       if (Length(cmd) > Length(lpfx)) then lpfx := cmd;
1395     end;
1396   end;
1397
1398   // get longest prefix
1399   for i := 0 to tused-1 do
1400   begin
1401     cmd := tcomplist[i];
1402     for c := 1 to Length(lpfx) do
1403     begin
1404       if (c > Length(cmd)) then break;
1405       if (cmd[c] <> lpfx[c]) then begin lpfx := Copy(lpfx, 0, c-1); break; end;
1406     end;
1407   end;
1408
1409   if (tused = 0) then exit;
1410
1411   if (tused = 1) then
1412   begin
1413     Line := tcomplist[0]+' ';
1414     CPos := Length(Line)+1;
1415   end
1416   else
1417   begin
1418     // has longest prefix?
1419     if (Length(lpfx) > Length(ll)) then
1420     begin
1421       Line := lpfx;
1422       CPos:= Length(Line)+1;
1423     end
1424     else
1425     begin
1426       g_Console_Add('');
1427       for i := 0 to tused-1 do
1428       begin
1429         if (Length(commands[tcompidx[i]].help) > 0) then
1430         begin
1431           g_Console_Add('  '+tcomplist[i]+' -- '+commands[tcompidx[i]].help);
1432         end
1433         else
1434         begin
1435           g_Console_Add('  '+tcomplist[i]);
1436         end;
1437       end;
1438     end;
1439   end;
1440 end;
1441
1442
1443 procedure g_Console_Control(K: Word);
1444 begin
1445   case K of
1446     IK_BACKSPACE:
1447       if (Length(Line) > 0) and (CPos > 1) then
1448       begin
1449         Delete(Line, CPos-1, 1);
1450         CPos := CPos-1;
1451       end;
1452     IK_DELETE:
1453       if (Length(Line) > 0) and (CPos <= Length(Line)) then
1454         Delete(Line, CPos, 1);
1455     IK_LEFT, IK_KPLEFT, VK_LEFT, JOY0_LEFT, JOY1_LEFT, JOY2_LEFT, JOY3_LEFT:
1456       if CPos > 1 then
1457         CPos := CPos - 1;
1458     IK_RIGHT, IK_KPRIGHT, VK_RIGHT, JOY0_RIGHT, JOY1_RIGHT, JOY2_RIGHT, JOY3_RIGHT:
1459       if CPos <= Length(Line) then
1460         CPos := CPos + 1;
1461     IK_RETURN, IK_KPRETURN, VK_OPEN, VK_FIRE, JOY0_ATTACK, JOY1_ATTACK, JOY2_ATTACK, JOY3_ATTACK:
1462     begin
1463       if gConsoleShow then
1464         g_Console_Process(Line)
1465       else
1466         if gChatShow then
1467         begin
1468           if (Length(Line) > 0) and g_Game_IsNet then
1469           begin
1470             if gChatTeam then
1471             begin
1472               if g_Game_IsClient then
1473                 MC_SEND_Chat(b_Text_Format(Line), NET_CHAT_TEAM)
1474               else
1475                 MH_SEND_Chat('[' + gPlayer1Settings.name + ']: ' + b_Text_Format(Line),
1476                   NET_CHAT_TEAM, gPlayer1Settings.Team);
1477             end
1478             else
1479             begin
1480               if g_Game_IsClient then
1481                 MC_SEND_Chat(b_Text_Format(Line), NET_CHAT_PLAYER)
1482               else
1483                 MH_SEND_Chat('[' + gPlayer1Settings.name + ']: ' + b_Text_Format(Line),
1484                 NET_CHAT_PLAYER);
1485             end;
1486           end;
1487
1488           Line := '';
1489           CPos := 1;
1490           gJustChatted := True;
1491           g_Console_Chat_Switch;
1492           InputReady := False;
1493         end;
1494     end;
1495     IK_TAB:
1496       if not gChatShow then
1497         Complete();
1498     IK_DOWN, IK_KPDOWN, VK_DOWN, JOY0_DOWN, JOY1_DOWN, JOY2_DOWN, JOY3_DOWN:
1499       if not gChatShow then
1500         if (CommandHistory <> nil) and
1501            (CmdIndex < Length(CommandHistory)) then
1502         begin
1503           if CmdIndex < Length(CommandHistory)-1 then
1504             CmdIndex := CmdIndex + 1;
1505           Line := CommandHistory[CmdIndex];
1506           CPos := Length(Line) + 1;
1507         end;
1508     IK_UP, IK_KPUP, VK_UP, JOY0_UP, JOY1_UP, JOY2_UP, JOY3_UP:
1509       if not gChatShow then
1510         if (CommandHistory <> nil) and
1511            (CmdIndex <= Length(CommandHistory)) then
1512         begin
1513           if CmdIndex > 0 then
1514             CmdIndex := CmdIndex - 1;
1515           Line := CommandHistory[CmdIndex];
1516           Cpos := Length(Line) + 1;
1517         end;
1518     IK_PAGEUP, IK_KPPAGEUP, VK_PREV, JOY0_PREV, JOY1_PREV, JOY2_PREV, JOY3_PREV: // PgUp
1519       if not gChatShow then Inc(conSkipLines);
1520     IK_PAGEDN, IK_KPPAGEDN, VK_NEXT, JOY0_NEXT, JOY1_NEXT, JOY2_NEXT, JOY3_NEXT: // PgDown
1521       if not gChatShow and (conSkipLines > 0) then Dec(conSkipLines);
1522     IK_HOME, IK_KPHOME:
1523       CPos := 1;
1524     IK_END, IK_KPEND:
1525       CPos := Length(Line) + 1;
1526     IK_A..IK_Z, IK_SPACE, IK_SHIFT, IK_RSHIFT, IK_CAPSLOCK, IK_LBRACKET, IK_RBRACKET,
1527     IK_SEMICOLON, IK_QUOTE, IK_BACKSLASH, IK_SLASH, IK_COMMA, IK_DOT, (*IK_EQUALS,*)
1528     IK_0, IK_1, IK_2, IK_3, IK_4, IK_5, IK_6, IK_7, IK_8, IK_9, IK_MINUS, IK_EQUALS:
1529       (* see TEXTINPUT event *)
1530   end
1531 end;
1532
1533 function GetStr(var Str: AnsiString): AnsiString;
1534 var
1535   a, b: Integer;
1536 begin
1537   Result := '';
1538   if Str[1] = '"' then
1539   begin
1540     for b := 1 to Length(Str) do
1541       if (b = Length(Str)) or (Str[b+1] = '"') then
1542       begin
1543         Result := Copy(Str, 2, b-1);
1544         Delete(Str, 1, b+1);
1545         Str := Trim(Str);
1546         Exit;
1547       end;
1548   end;
1549
1550   for a := 1 to Length(Str) do
1551     if (a = Length(Str)) or (Str[a+1] = ' ') then
1552     begin
1553       Result := Copy(Str, 1, a);
1554       Delete(Str, 1, a+1);
1555       Str := Trim(Str);
1556       Exit;
1557     end;
1558 end;
1559
1560 function ParseString(Str: AnsiString): SSArray;
1561 begin
1562   Result := nil;
1563
1564   Str := Trim(Str);
1565
1566   if Str = '' then
1567     Exit;
1568
1569   while Str <> '' do
1570   begin
1571     SetLength(Result, Length(Result)+1);
1572     Result[High(Result)] := GetStr(Str);
1573   end;
1574 end;
1575
1576 procedure g_Console_Add (L: AnsiString; show: Boolean=false);
1577
1578   procedure conmsg (s: AnsiString);
1579   var
1580     a: Integer;
1581   begin
1582     if length(s) = 0 then exit;
1583     for a := 0 to High(MsgArray) do
1584     begin
1585       with MsgArray[a] do
1586       begin
1587         if Time = 0 then
1588         begin
1589           Msg := s;
1590           Time := MsgTime;
1591           exit;
1592         end;
1593       end;
1594     end;
1595     for a := 0 to High(MsgArray)-1 do MsgArray[a] := MsgArray[a+1];
1596     with MsgArray[High(MsgArray)] do
1597     begin
1598       Msg := L;
1599       Time := MsgTime;
1600     end;
1601   end;
1602
1603 var
1604   f: Integer;
1605 begin
1606   // put it to console
1607   cbufPut(L);
1608   if (length(L) = 0) or ((L[length(L)] <> #10) and (L[length(L)] <> #13)) then cbufPut(#10);
1609
1610   // now show 'em out of console too
1611   show := show and gAllowConsoleMessages;
1612   if show and gShowMessages then
1613   begin
1614     // Âûâîä ñòðîê ñ ïåðåíîñàìè ïî î÷åðåäè
1615     while length(L) > 0 do
1616     begin
1617       f := Pos(#10, L);
1618       if f <= 0 then f := length(L)+1;
1619       conmsg(Copy(L, 1, f-1));
1620       Delete(L, 1, f);
1621     end;
1622   end;
1623
1624   //SetLength(ConsoleHistory, Length(ConsoleHistory)+1);
1625   //ConsoleHistory[High(ConsoleHistory)] := L;
1626 end;
1627
1628
1629 var
1630   consolewriterLastWasEOL: Boolean = false;
1631
1632 procedure consolewriter (constref buf; len: SizeUInt);
1633 var
1634   b: PByte;
1635 begin
1636   if (len < 1) then exit;
1637   b := PByte(@buf);
1638   consolewriterLastWasEOL := (b[len-1] = 13) or (b[len-1] = 10);
1639   while (len > 0) do
1640   begin
1641     if (b[0] <> 13) and (b[0] <> 10) then
1642     begin
1643       cbufPut(AnsiChar(b[0]));
1644     end
1645     else
1646     begin
1647       if (len > 1) and (b[0] = 13) then begin len -= 1; b += 1; end;
1648       cbufPut(#10);
1649     end;
1650     len -= 1;
1651     b += 1;
1652   end;
1653 end;
1654
1655
1656 // returns formatted string if `writerCB` is `nil`, empty string otherwise
1657 //function formatstrf (const fmt: AnsiString; args: array of const; writerCB: TFormatStrFCallback=nil): AnsiString;
1658 //TFormatStrFCallback = procedure (constref buf; len: SizeUInt);
1659 procedure conwriteln (const s: AnsiString; show: Boolean=false);
1660 begin
1661   g_Console_Add(s, show);
1662 end;
1663
1664
1665 procedure conwritefln (const s: AnsiString; args: array of const; show: Boolean=false);
1666 begin
1667   if show then
1668   begin
1669     g_Console_Add(formatstrf(s, args), true);
1670   end
1671   else
1672   begin
1673     consolewriterLastWasEOL := false;
1674     formatstrf(s, args, consolewriter);
1675     if not consolewriterLastWasEOL then cbufPut(#10);
1676   end;
1677 end;
1678
1679
1680 procedure g_Console_Clear();
1681 begin
1682   //ConsoleHistory := nil;
1683   cbufClear();
1684   conSkipLines := 0;
1685 end;
1686
1687 procedure AddToHistory(L: AnsiString);
1688 var
1689   len: Integer;
1690 begin
1691   len := Length(CommandHistory);
1692
1693   if (len = 0) or
1694      (LowerCase(CommandHistory[len-1]) <> LowerCase(L)) then
1695   begin
1696     SetLength(CommandHistory, len+1);
1697     CommandHistory[len] := L;
1698   end;
1699
1700   CmdIndex := Length(CommandHistory);
1701 end;
1702
1703 function g_Console_CommandBlacklisted(C: AnsiString): Boolean;
1704 var
1705   Arr: SSArray;
1706   i: Integer;
1707 begin
1708   Result := True;
1709
1710   Arr := nil;
1711
1712   if Trim(C) = '' then
1713     Exit;
1714
1715   Arr := ParseString(C);
1716   if Arr = nil then
1717     Exit;
1718
1719   for i := 0 to High(Whitelist) do
1720     if Whitelist[i] = LowerCase(Arr[0]) then
1721       Result := False;
1722 end;
1723
1724 procedure g_Console_Process(L: AnsiString; quiet: Boolean = False);
1725 var
1726   Arr: SSArray;
1727   i: Integer;
1728 begin
1729   Arr := nil;
1730
1731   if Trim(L) = '' then
1732     Exit;
1733
1734   conSkipLines := 0; // "unscroll"
1735
1736   if L = 'goobers' then
1737   begin
1738     Line := '';
1739     CPos := 1;
1740     gCheats := true;
1741     g_Console_Add('Your memory serves you well.');
1742     exit;
1743   end;
1744
1745   if not quiet then
1746   begin
1747     g_Console_Add('> '+L);
1748     Line := '';
1749     CPos := 1;
1750   end;
1751
1752   Arr := ParseString(L);
1753   if Arr = nil then
1754     Exit;
1755
1756   if commands = nil then
1757     Exit;
1758
1759   if not quiet then
1760     AddToHistory(L);
1761
1762   for i := 0 to High(commands) do
1763   begin
1764     if commands[i].cmd = LowerCase(Arr[0]) then
1765     begin
1766       if commands[i].action >= 0 then
1767       begin
1768         gPlayerAction[commands[i].player, commands[i].action] := commands[i].cmd[1] = '+';
1769         exit
1770       end;
1771       if assigned(commands[i].procEx) then
1772       begin
1773         commands[i].procEx(@commands[i], Arr);
1774         exit
1775       end;
1776       if assigned(commands[i].proc) then
1777       begin
1778         commands[i].proc(Arr);
1779         exit
1780       end
1781     end
1782   end;
1783
1784   g_Console_Add(Format(_lc[I_CONSOLE_UNKNOWN], [Arr[0]]));
1785 end;
1786
1787
1788 function g_Console_Interactive: Boolean;
1789 begin
1790   Result := gConsoleShow
1791 end;
1792
1793 procedure g_Console_BindKey (key: Integer; down: AnsiString; up: AnsiString = ''; rep: Boolean = False);
1794 begin
1795   // e_LogWritefln('bind "%s" "%s" "%s" <%s>', [LowerCase(e_KeyNames[key]), down, up, key]);
1796   ASSERT(key >= 0);
1797   ASSERT(key < e_MaxInputKeys);
1798   if key > 0 then
1799   begin
1800     gInputBinds[key].rep := rep;
1801     gInputBinds[key].down := ParseAlias(down);
1802     gInputBinds[key].up := ParseAlias(up);
1803   end;
1804   g_Console_WriteGameConfig();
1805 end;
1806
1807 function g_Console_MatchBind (key: Integer; down: AnsiString; up: AnsiString = ''): Boolean;
1808
1809   function EqualsCommandLists (a, b: SSArray): Boolean;
1810     var i, len: Integer;
1811   begin
1812     result := False;
1813     len := Length(a);
1814     if len = Length(b) then
1815     begin
1816       i := 0;
1817       while (i < len) and (a[i] = b[i]) do inc(i);
1818       if i >= len then
1819         result := True
1820     end
1821   end;
1822
1823 begin
1824   ASSERT(key >= 0);
1825   ASSERT(key < e_MaxInputKeys);
1826   result := EqualsCommandLists(ParseAlias(down), gInputBinds[key].down) and EqualsCommandLists(ParseAlias(up), gInputBinds[key].up)
1827 end;
1828
1829 function g_Console_FindBind (n: Integer; down: AnsiString; up: AnsiString = ''): Integer;
1830   var i: Integer;
1831 begin
1832   ASSERT(n >= 1);
1833   result := 0;
1834   if commands = nil then Exit;
1835   i := 0;
1836   while (n >= 1) and (i < e_MaxInputKeys) do
1837   begin
1838     if (i < VK_FIRSTKEY) or (i > VK_LASTKEY) then (* never show virtual keys in gui *)
1839     begin
1840       if g_Console_MatchBind(i, down, up) then
1841       begin
1842         result := i;
1843         dec(n)
1844       end;
1845     end;
1846     inc(i)
1847   end;
1848   if n >= 1 then
1849     result := 0
1850 end;
1851
1852 function g_Console_Action (action: Integer): Boolean;
1853   var i, len: Integer;
1854 begin
1855   ASSERT(action >= FIRST_ACTION);
1856   ASSERT(action <= LAST_ACTION);
1857   i := 0;
1858   len := Length(gPlayerAction);
1859   while (i < len) and (not gPlayerAction[i, action]) do inc(i);
1860   Result := i < len
1861 end;
1862
1863 function BindsAllowed (key: Integer): Boolean;
1864   var grab, active: Boolean;
1865 begin
1866   Result := False;
1867   {$IFDEF DISABLE_MENU}
1868     grab := False;
1869     active := False;
1870   {$ELSE}
1871     grab := g_GUIGrabInput;
1872     active := g_ActiveWindow <> nil;
1873   {$ENDIF}
1874   if (not grab) and (key >= 0) and (key < e_MaxInputKeys) and ((gInputBinds[key].down <> nil) or (gInputBinds[key].up <> nil)) then
1875   begin
1876     if gChatShow then
1877       Result := g_Console_MatchBind(key, 'togglemenu') or
1878                 g_Console_MatchBind(key, 'showkeyboard') or
1879                 g_Console_MatchBind(key, 'hidekeyboard')
1880     else if gConsoleShow or active or (gGameSettings.GameType = GT_NONE) then
1881       Result := g_Console_MatchBind(key, 'togglemenu') or
1882                 g_Console_MatchBind(key, 'toggleconsole') or
1883                 g_Console_MatchBind(key, 'showkeyboard') or
1884                 g_Console_MatchBind(key, 'hidekeyboard')
1885     else (* in game *)
1886       Result := True
1887   end
1888 end;
1889
1890 procedure g_Console_ProcessBind (key: Integer; down: Boolean);
1891   var i: Integer;
1892 begin
1893   if BindsAllowed(key) then
1894   begin
1895     if down then
1896       for i := 0 to High(gInputBinds[key].down) do
1897         g_Console_Process(gInputBinds[key].down[i], True)
1898     else
1899       for i := 0 to High(gInputBinds[key].up) do
1900         g_Console_Process(gInputBinds[key].up[i], True)
1901   end;
1902   if down and not menu_toggled then
1903     KeyPress(key);
1904   menu_toggled := False
1905 end;
1906
1907 procedure g_Console_ProcessBindRepeat (key: Integer);
1908   var i: Integer; active: Boolean;
1909 begin
1910   {$IFDEF DISABLE_MENU}
1911     active := False;
1912   {$ELSE}
1913     active := g_ActiveWindow <> nil;
1914   {$ENDIF}
1915   if gConsoleShow or gChatShow or active then
1916   begin
1917     KeyPress(key); // key repeat in menus and shit
1918     Exit;
1919   end;
1920   if BindsAllowed(key) and gInputBinds[key].rep then
1921   begin
1922     for i := 0 to High(gInputBinds[key].down) do
1923       g_Console_Process(gInputBinds[key].down[i], True);
1924   end;
1925 end;
1926
1927 procedure g_Console_ResetBinds;
1928   var i: Integer;
1929 begin
1930   for i := 0 to e_MaxInputKeys - 1 do
1931     g_Console_BindKey(i, '', '');
1932
1933   g_Console_BindKey(IK_GRAVE, 'toggleconsole');
1934   g_Console_BindKey(IK_ESCAPE, 'togglemenu');
1935   g_Console_BindKey(IK_A, '+p1_moveleft', '-p1_moveleft');
1936   g_Console_BindKey(IK_D, '+p1_moveright', '-p1_moveright');
1937   g_Console_BindKey(IK_W, '+p1_lookup', '-p1_lookup');
1938   g_Console_BindKey(IK_S, '+p1_lookdown', '-p1_lookdown');
1939   g_Console_BindKey(IK_SPACE, '+p1_jump', '-p1_jump');
1940   g_Console_BindKey(IK_H, '+p1_attack', '-p1_attack');
1941   g_Console_BindKey(IK_J, '+p1_activate', '-p1_activate');
1942   g_Console_BindKey(IK_ALT, '+p1_strafe', '-p1_strafe');
1943   g_Console_BindKey(IK_E, 'p1_weapnext', '', True);
1944   g_Console_BindKey(IK_Q, 'p1_weapprev', '', True);
1945   g_Console_BindKey(IK_R, 'p1_dropflag', '');
1946   g_Console_BindKey(IK_1, 'p1_weapon 1');
1947   g_Console_BindKey(IK_2, 'p1_weapon 2');
1948   g_Console_BindKey(IK_3, 'p1_weapon 3');
1949   g_Console_BindKey(IK_4, 'p1_weapon 4');
1950   g_Console_BindKey(IK_5, 'p1_weapon 5');
1951   g_Console_BindKey(IK_6, 'p1_weapon 6');
1952   g_Console_BindKey(IK_7, 'p1_weapon 7');
1953   g_Console_BindKey(IK_8, 'p1_weapon 8');
1954   g_Console_BindKey(IK_9, 'p1_weapon 9');
1955   g_Console_BindKey(IK_0, 'p1_weapon 10');
1956   g_Console_BindKey(IK_MINUS, 'p1_weapon 11');
1957   g_Console_BindKey(IK_T, 'togglechat');
1958   g_Console_BindKey(IK_Y, 'toggleteamchat');
1959   g_Console_BindKey(IK_F11, 'screenshot');
1960   g_Console_BindKey(IK_TAB, '+scores', '-scores');
1961   g_Console_BindKey(IK_PAUSE, 'pause');
1962   g_Console_BindKey(IK_F1, 'vote');
1963
1964   (* for i := 0 to e_MaxJoys - 1 do *)
1965   for i := 0 to 1 do
1966   begin
1967     g_Console_BindKey(e_JoyHatToKey(i, 0, HAT_LEFT), '+p' + IntToStr(i mod 2 + 1) + '_moveleft', '-p' + IntToStr(i mod 2 + 1) + '_moveleft');
1968     g_Console_BindKey(e_JoyHatToKey(i, 0, HAT_RIGHT), '+p' + IntToStr(i mod 2 + 1) + '_moveright', '-p' + IntToStr(i mod 2 + 1) + '_moveright');
1969     g_Console_BindKey(e_JoyHatToKey(i, 0, HAT_UP), '+p' + IntToStr(i mod 2 + 1) + '_lookup', '-p' + IntToStr(i mod 2 + 1) + '_lookup');
1970     g_Console_BindKey(e_JoyHatToKey(i, 0, HAT_DOWN), '+p' + IntToStr(i mod 2 + 1) + '_lookdown', '-p' + IntToStr(i mod 2 + 1) + '_lookdown');
1971     g_Console_BindKey(e_JoyButtonToKey(i, 2), '+p' + IntToStr(i mod 2 + 1) + '_jump', '-p' + IntToStr(i mod 2 + 1) + '_jump');
1972     g_Console_BindKey(e_JoyButtonToKey(i, 0), '+p' + IntToStr(i mod 2 + 1) + '_attack', '-p' + IntToStr(i mod 2 + 1) + '_attack');
1973     g_Console_BindKey(e_JoyButtonToKey(i, 3), '+p' + IntToStr(i mod 2 + 1) + '_activate', '-p' + IntToStr(i mod 2 + 1) + '_activate');
1974     g_Console_BindKey(e_JoyButtonToKey(i, 7), '+p' + IntToStr(i mod 2 + 1) + '_strafe', '-p' + IntToStr(i mod 2 + 1) + '_strafe');
1975     g_Console_BindKey(e_JoyButtonToKey(i, 1), 'p' + IntToStr(i mod 2 + 1) + '_weapnext', '', True);
1976     g_Console_BindKey(e_JoyButtonToKey(i, 4), 'p' + IntToStr(i mod 2 + 1) + '_weapprev', '', True);
1977     g_Console_BindKey(e_JoyButtonToKey(i, 10), 'togglemenu');
1978   end;
1979
1980   g_Console_BindKey(VK_ESCAPE, 'togglemenu');
1981   g_Console_BindKey(VK_LSTRAFE, '+moveleft; +strafe', '-moveleft; -strafe');
1982   g_Console_BindKey(VK_RSTRAFE, '+moveright; +strafe', '-moveright; -strafe');
1983   g_Console_BindKey(VK_LEFT, '+moveleft', '-moveleft');
1984   g_Console_BindKey(VK_RIGHT, '+moveright', '-moveright');
1985   g_Console_BindKey(VK_UP, '+lookup', '-lookup');
1986   g_Console_BindKey(VK_DOWN, '+lookdown', '-lookdown');
1987   g_Console_BindKey(VK_JUMP, '+jump', '-jump');
1988   g_Console_BindKey(VK_FIRE, '+attack', '-attack');
1989   g_Console_BindKey(VK_OPEN, '+activate', '-activate');
1990   g_Console_BindKey(VK_STRAFE, '+strafe', '-strafe');
1991   g_Console_BindKey(VK_NEXT, 'weapnext', '', True);
1992   g_Console_BindKey(VK_PREV, 'weapprev', '', True);
1993   g_Console_BindKey(VK_0, 'weapon 1');
1994   g_Console_BindKey(VK_1, 'weapon 2');
1995   g_Console_BindKey(VK_2, 'weapon 3');
1996   g_Console_BindKey(VK_3, 'weapon 4');
1997   g_Console_BindKey(VK_4, 'weapon 5');
1998   g_Console_BindKey(VK_5, 'weapon 6');
1999   g_Console_BindKey(VK_6, 'weapon 7');
2000   g_Console_BindKey(VK_7, 'weapon 8');
2001   g_Console_BindKey(VK_8, 'weapon 9');
2002   g_Console_BindKey(VK_9, 'weapon 10');
2003   g_Console_BindKey(VK_A, 'weapon 11');
2004   g_Console_BindKey(VK_CHAT, 'togglechat');
2005   g_Console_BindKey(VK_TEAM, 'toggleteamchat');
2006   g_Console_BindKey(VK_CONSOLE, 'toggleconsole');
2007   g_Console_BindKey(VK_PRINTSCR, 'screenshot');
2008   g_Console_BindKey(VK_STATUS, '+scores', '-scores');
2009   g_Console_BindKey(VK_SHOWKBD, 'showkeyboard');
2010   g_Console_BindKey(VK_HIDEKBD, 'hidekeyboard');
2011 end;
2012
2013 procedure g_Console_ReadConfig (filename: String);
2014   var f: TextFile; s: AnsiString; i, len: Integer;
2015 begin
2016   e_LogWritefln('g_Console_ReadConfig (1) "%s"', [filename]);
2017   if e_FindResource(ConfigDirs, filename, false) = true then
2018   begin
2019     e_LogWritefln('g_Console_ReadConfig (2) "%s"', [filename]);
2020     AssignFile(f, filename);
2021     Reset(f);
2022     while not EOF(f) do
2023     begin
2024       ReadLn(f, s);
2025       len := Length(s);
2026       if len > 0 then
2027       begin
2028         i := 1;
2029         (* skip spaces *)
2030         while (i <= len) and (s[i] <= ' ') do inc(i);
2031         (* skip comments *)
2032         if (i <= len) and ((s[i] <> '#') and ((i + 1 > len) or (s[i] <> '/') or (s[i + 1] <> '/'))) then
2033           g_Console_Process(s, True);
2034       end
2035     end;
2036     CloseFile(f);
2037   end
2038 end;
2039
2040 procedure g_Console_WriteConfig (filename: String);
2041   var f: TextFile; i, j: Integer;
2042
2043   procedure WriteFlag(name: string; flag: LongWord);
2044   begin
2045     WriteLn(f, name, IfThen(LongBool(gsGameFlags and flag), 1, 0));
2046   end;
2047
2048   function FormatTeam(team: Byte): string;
2049   begin
2050     if team = TEAM_BLUE then
2051       result := 'blue'
2052     else
2053       result := 'red';
2054   end;
2055
2056 begin
2057   // e_LogWritefln('g_Console_WriteConfig: %s', [filename]);
2058   AssignFile(f, filename);
2059   Rewrite(f);
2060   WriteLn(f, '// ' + configComment);
2061
2062   // binds
2063   WriteLn(f, 'unbindall');
2064   for i := 0 to e_MaxInputKeys - 1 do
2065     if (Length(gInputBinds[i].down) > 0) or (Length(gInputBinds[i].up) > 0) then
2066     begin
2067       Write(f, 'bind ', e_KeyNames[i], ' ', QuoteStr(GetCommandString(gInputBinds[i].down)));
2068       if Length(gInputBinds[i].down) = 0 then
2069         Write(f, '""');
2070       if Length(gInputBinds[i].up) > 0 then
2071         Write(f, ' ', QuoteStr(GetCommandString(gInputBinds[i].up)));
2072       WriteLn(f, '');
2073       if gInputBinds[i].rep then
2074         WriteLn(f, 'bindrep ', e_KeyNames[i]);
2075     end;
2076
2077   // lang
2078   if gAskLanguage then
2079     WriteLn(f, 'g_language ask')
2080   else
2081     WriteLn(f, 'g_language ', gLanguage);
2082
2083   // net server
2084   WriteLn(f, 'sv_name ', QuoteStr(NetServerName));
2085   WriteLn(f, 'sv_passwd ', QuoteStr(NetPassword));
2086   WriteLn(f, 'sv_maxplrs ', NetMaxClients);
2087   WriteLn(f, 'sv_port ', NetPort);
2088   WriteLn(f, 'sv_public ', IfThen(NetUseMaster, 1, 0));
2089
2090   // game settings
2091   {$IFDEF ENABLE_GFX}
2092     WriteLn(f, 'g_max_particles ', g_GFX_GetMax());
2093   {$ENDIF}
2094   {$IFDEF ENABLE_SHELLS}
2095     WriteLn(f, 'g_max_shells ', g_Shells_GetMax());
2096   {$ENDIF}
2097   {$IFDEF ENABLE_GIBS}
2098     WriteLn(f, 'g_max_gibs ', g_Gibs_GetMax());
2099   {$ENDIF}
2100   {$IFDEF ENABLE_CORPSES}
2101     WriteLn(f, 'g_max_corpses ', g_Corpses_GetMax());
2102   {$ENDIF}
2103   WriteLn(f, 'g_force_model ', g_Force_Model_Get());
2104   WriteLn(f, 'g_force_model_name ', g_Forced_Model_GetName());
2105   WriteLn(f, 'sv_intertime ', gDefInterTime);
2106
2107   // gameplay settings
2108   WriteLn(f, 'g_gamemode ', gsGameMode);
2109   WriteLn(f, 'g_scorelimit ', gsScoreLimit);
2110   WriteLn(f, 'g_timelimit ', gsTimeLimit);
2111   WriteLn(f, 'g_maxlives ', gsMaxLives);
2112   WriteLn(f, 'g_item_respawn_time ', gsItemRespawnTime);
2113   WriteLn(f, 'g_spawn_invul ', gsSpawnInvul);
2114   WriteLn(f, 'g_warmup_time ', gsWarmupTime);
2115
2116   WriteFlag('g_friendlyfire ', GAME_OPTION_TEAMDAMAGE);
2117   WriteFlag('g_friendly_hit_trace ', GAME_OPTION_TEAMHITTRACE);
2118   WriteFlag('g_friendly_hit_projectile ', GAME_OPTION_TEAMHITPROJECTILE);
2119   WriteFlag('g_allow_exit ', GAME_OPTION_ALLOWEXIT);
2120   WriteFlag('g_allow_monsters ', GAME_OPTION_MONSTERS);
2121   WriteFlag('g_allow_dropflag ', GAME_OPTION_ALLOWDROPFLAG);
2122   WriteFlag('g_throw_flag ', GAME_OPTION_THROWFLAG);
2123   WriteFlag('g_dm_keys ', GAME_OPTION_DMKEYS);
2124   WriteFlag('g_weaponstay ', GAME_OPTION_WEAPONSTAY);
2125   WriteFlag('g_bot_vsmonsters ', GAME_OPTION_BOTVSMONSTER);
2126   WriteFlag('g_bot_vsplayers ', GAME_OPTION_BOTVSPLAYER);
2127
2128   // players
2129   with gPlayer1Settings do
2130   begin
2131     WriteLn(f, 'p1_name ', QuoteStr(Name));
2132     WriteLn(f, 'p1_color ', Color.R, ' ', Color.G, ' ', Color.B);
2133     WriteLn(f, 'p1_model ', QuoteStr(Model));
2134     WriteLn(f, 'p1_team ', FormatTeam(Team));
2135     WriteLn(f, 'p1_autoswitch ', WeaponSwitch);
2136     WriteLn(f, 'p1_switch_empty ', SwitchToEmpty);
2137     WriteLn(f, 'p1_priority_kastet ', Max(0, WeaponPreferences[WEAPON_KASTET]));
2138     WriteLn(f, 'p1_priority_saw ', Max(0, WeaponPreferences[WEAPON_SAW]));
2139     WriteLn(f, 'p1_priority_pistol ', Max(0, WeaponPreferences[WEAPON_PISTOL]));
2140     WriteLn(f, 'p1_priority_shotgun1 ', Max(0, WeaponPreferences[WEAPON_SHOTGUN1]));
2141     WriteLn(f, 'p1_priority_shotgun2 ', Max(0, WeaponPreferences[WEAPON_SHOTGUN2] ));
2142     WriteLn(f, 'p1_priority_chaingun ', Max(0, WeaponPreferences[WEAPON_CHAINGUN]));
2143     WriteLn(f, 'p1_priority_rocketlauncher ', Max(0, WeaponPreferences[WEAPON_ROCKETLAUNCHER]));
2144     WriteLn(f, 'p1_priority_plasma ', Max(0, WeaponPreferences[WEAPON_PLASMA]));
2145     WriteLn(f, 'p1_priority_bfg ', Max(0, WeaponPreferences[WEAPON_BFG]));
2146     WriteLn(f, 'p1_priority_super ', Max(0, WeaponPreferences[WEAPON_SUPERPULEMET]));
2147     WriteLn(f, 'p1_priority_flamethrower ', Max(0, WeaponPreferences[WEAPON_FLAMETHROWER]));
2148     WriteLn(f, 'p1_priority_berserk ', Max(0, WeaponPreferences[WP_LAST+1]));
2149     //
2150   end;
2151   with gPlayer2Settings do
2152   begin
2153     WriteLn(f, 'p2_name ', QuoteStr(Name));
2154     WriteLn(f, 'p2_color ', Color.R, ' ', Color.G, ' ', Color.B);
2155     WriteLn(f, 'p2_model ', QuoteStr(Model));
2156     WriteLn(f, 'p2_team ', FormatTeam(Team));
2157     WriteLn(f, 'p2_autoswitch ', WeaponSwitch);
2158     WriteLn(f, 'p2_switch_empty ', SwitchToEmpty);
2159     WriteLn(f, 'p2_priority_kastet ', Max(0, WeaponPreferences[WEAPON_KASTET]));
2160     WriteLn(f, 'p2_priority_saw ', Max(0, WeaponPreferences[WEAPON_SAW]));
2161     WriteLn(f, 'p2_priority_pistol ', Max(0, WeaponPreferences[WEAPON_PISTOL]));
2162     WriteLn(f, 'p2_priority_shotgun1 ', Max(0, WeaponPreferences[WEAPON_SHOTGUN1]));
2163     WriteLn(f, 'p2_priority_shotgun2 ', Max(0, WeaponPreferences[WEAPON_SHOTGUN1]));
2164     WriteLn(f, 'p2_priority_chaingun ', Max(0, WeaponPreferences[WEAPON_CHAINGUN]));
2165     WriteLn(f, 'p2_priority_rocketlauncher ', Max(0, WeaponPreferences[WEAPON_ROCKETLAUNCHER]));
2166     WriteLn(f, 'p2_priority_plasma ', Max(0, WeaponPreferences[WEAPON_PLASMA]));
2167     WriteLn(f, 'p2_priority_bfg ', Max(0, WeaponPreferences[WEAPON_BFG]));
2168     WriteLn(f, 'p2_priority_super ', Max(0, WeaponPreferences[WEAPON_SUPERPULEMET]));
2169     WriteLn(f, 'p2_priority_flamethrower ', Max(0, WeaponPreferences[WEAPON_FLAMETHROWER]));
2170     WriteLn(f, 'p2_priority_berserk ', Max(0, WeaponPreferences[WP_LAST+1]));
2171   end;
2172
2173   // all cvars
2174   for i := 0 to High(commands) do
2175   begin
2176     if not commands[i].cheat then
2177     begin
2178       if @commands[i].procEx = @boolVarHandler then
2179       begin
2180         if PBoolean(commands[i].ptr)^ then j := 1 else j := 0;
2181         WriteLn(f, commands[i].cmd, ' ', j)
2182       end
2183       else if @commands[i].procEx = @intVarHandler then
2184       begin
2185         WriteLn(f, commands[i].cmd, ' ', PInteger(commands[i].ptr)^)
2186       end
2187       else if @commands[i].procEx = @wordVarHandler then
2188       begin
2189         WriteLn(f, commands[i].cmd, ' ', PWord(commands[i].ptr)^)
2190       end
2191       else if @commands[i].procEx = @dwordVarHandler then
2192       begin
2193         WriteLn(f, commands[i].cmd, ' ', PCardinal(commands[i].ptr)^)
2194       end
2195       else if @commands[i].procEx = @singleVarHandler then
2196       begin
2197         WriteLn(f, commands[i].cmd, ' ', PVarSingle(commands[i].ptr).val^:0:6)
2198       end
2199       else if @commands[i].procEx = @strVarHandler then
2200       begin
2201         if Length(PAnsiString(commands[i].ptr)^) = 0 then
2202           WriteLn(f, commands[i].cmd, ' ""')
2203         else
2204           WriteLn(f, commands[i].cmd, ' ', QuoteStr(PAnsiString(commands[i].ptr)^))
2205       end
2206     end
2207   end;
2208
2209   WriteLn(f, 'r_maxfps ', gMaxFPS);
2210   WriteLn(f, 'r_reset');
2211   CloseFile(f)
2212 end;
2213
2214 procedure g_Console_WriteGameConfig;
2215   var s: AnsiString;
2216 begin
2217   if gParsingBinds = false then
2218   begin
2219     s := e_GetWriteableDir(ConfigDirs);
2220     g_Console_WriteConfig(e_CatPath(s, gConfigScript))
2221   end
2222 end;
2223
2224 procedure Init;
2225   var i: Integer;
2226 begin
2227   conRegVar('console_stdin', @ConsoleStdIn, 'enable reading commands from stdin', 'enable reading commands from stdin');
2228 {$IFDEF HEADLESS}
2229   ConsoleStdIn := True;
2230 {$ELSE}
2231   ConsoleStdIn := False;
2232 {$ENDIF}
2233   conRegVar('d_eres', @debug_e_res, '', '');
2234   for i := 1 to e_MaxJoys do
2235     conRegVar('joy' + IntToStr(i) + '_deadzone', @e_JoystickDeadzones[i - 1], '', '')
2236 end;
2237
2238 initialization
2239   Init
2240
2241 {$IFDEF HEADLESS}
2242 finalization
2243   DoneKeyboard;
2244   conbufStdOutRawMode := false;
2245 {$ENDIF}
2246
2247 end.