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