console.cpp

   1
   2 #include "nx.h"
   3 #include <stdarg.h>
   4 #include "console.fdh"
   5
   6 static CommandEntry commands[] =
   7 {
   8         "god", __god, 0, 1,
   9         "script", __script, 1, 1,
  10         "warp", __warp, 1, 999,
  11         "sound", __sound, 1, 1,
  12         "music", __music, 1, 1,
  13         "giveweapon", __giveweapon, 1, 1,
  14         "dropweapon", __dropweapon, 0, 1,
  15         "level", __level, 1, 1,
  16         "ammo", __ammo, 1, 1,
  17         "maxammo", __maxammo, 1, 1,
  18         "hp", __hp, 1, 1,
  19         "maxhp", __maxhp, 1, 1,
  20         "xp", __xp, 1, 1,
  21         "spawn", __spawn, 1, 999,
  22         "animate", __animate, 1, 2,
  23         "infinitedamage", __infinitedamage, 0, 1,
  24         "killall", __killall, 0, 0,
  25         "movemode", __movemode, 1, 1,
  26         "flag", __flag, 1, 1,
  27         "clearflags", __clearflags, 0, 0,
  28         "equip", __equip, 1, 2,
  29         "giveitem", __giveitem, 1, 1,
  30         "takeitem", __takeitem, 1, 1,
  31         "qua", __qua, 0, 1,
  32         "boa", __boa, 1, 1,
  33         "cre", __cre, 0, 0,
  34         "reset", __reset, 0, 0,
  35         "fps", __fps, 0, 1,
  36
  37         "instant-quit", __set_iquit, 1, 1,
  38         "no-quake-in-hell", __set_noquake, 1, 1,
  39         "inhibit-fullscreen", __inhibit_fullscreen, 1, 1,
  40         "emulate-bugs", __emulate_bugs, 1, 1,
  41         "displayformat", __displayformat, 1, 1,
  42         "skip-intro", __skip_intro, 1, 1,
  43
  44         "player->hide", __player_hide, 1, 1,
  45         "player->inputs_locked", __player_inputs_locked, 1, 1,
  46         "game.frozen", __game_frozen, 1, 1,
  47         "textbox.SetVisible", __textbox_setvisible, 1, 1,
  48
  49         "hello", __hello, 0, 0,
  50         "hi", __hello, 0, 0,
  51
  52         NULL, NULL
  53 };
  54
  55
  56 DebugConsole::DebugConsole()
  57 {
  58         fVisible = false;
  59         fLineLen = 0;
  60         fCursorTimer = 0;
  61         fResponseTimer = 0;
  62
  63         fLine[0] = 0;
  64         fResponse[0] = 0;
  65
  66         fKeyDown = 0;
  67         fRepeatTimer = 0;
  68 }
  69
  70 /*
  71 void c------------------------------() {}
  72 */
  73
  74 void DebugConsole::SetVisible(bool newstate)
  75 {
  76         //stat("DebugConsole::SetVisible(%s)", newstate?"true":"false");
  77
  78         if (fVisible != newstate)
  79         {
  80                 fVisible = newstate;
  81                 fKeyDown = 0;
  82                 fRepeatTimer = 0;
  83
  84                 if (newstate)
  85                 {
  86                         fLine[0] = 0;
  87                         fLineLen = 0;
  88                         fBrowsingExpansion = false;
  89                         fBackIndex = fBackBuffer.CountItems();
  90
  91                         fResponse[0] = 0;
  92                         fCursorTimer = 0;
  93                 }
  94         }
  95 }
  96
  97 bool DebugConsole::IsVisible()
  98 {
  99         return fVisible;
 100 }
 101
 102 bool DebugConsole::HandleKey(int key)
 103 {
 104         if (!fVisible) return 0;
 105         if (key != 9) fBrowsingExpansion = false;
 106
 107         if (key != fKeyDown)
 108         {
 109                 fKeyDown = key;
 110                 fRepeatTimer = 25;
 111         }
 112         else
 113         {
 114                 fRepeatTimer = 1;
 115         }
 116
 117         fCursorTimer = 0;
 118
 119         switch(key)
 120         {
 121                 case 27:
 122                 case '`':
 123                 {
 124                         SetVisible(false);
 125                 }
 126                 break;
 127
 128                 case 13:
 129                 case 271:       // numeric enter
 130                 {
 131                         SetVisible(false);
 132
 133                         fLine[fLineLen] = 0;
 134                         Execute(fLine);
 135                         fLineLen = 0;
 136                 }
 137                 break;
 138
 139                 case 10: break;
 140
 141                 case 8:
 142                 {
 143                         if (fLineLen > 0)
 144                                 fLineLen--;
 145                 }
 146                 break;
 147
 148                 case 9:         // command completion
 149                 {
 150                         fLine[fLineLen] = 0;
 151                         ExpandCommand();
 152
 153                         fBrowsingExpansion = true;
 154                         fExpandIndex++;
 155                 }
 156                 break;
 157
 158                 // command backbuffer
 159                 case SDLK_UP:
 160                 case SDLK_DOWN:
 161                 {
 162                         if (fBackBuffer.CountItems() > 0)
 163                         {
 164                                 fBackIndex += (key == SDLK_UP) ? -1 : 1;
 165                                 if (fBackIndex < 0) fBackIndex = (fBackBuffer.CountItems() - 1);
 166                                 else fBackIndex %= fBackBuffer.CountItems();
 167
 168                                 const char *str = fBackBuffer.StringAt(fBackIndex);
 169
 170                                 maxcpy(fLine, str, sizeof(fLine) - 1);
 171                                 fLineLen = strlen(str);
 172                         }
 173                 }
 174                 break;
 175
 176                 default:
 177                 {
 178                         if (fLineLen < (sizeof(fLine) - 1))
 179                                 fLine[fLineLen++] = key;
 180                 }
 181                 break;
 182         }
 183
 184         return 1;
 185 }
 186
 187 void DebugConsole::HandleKeyRelease(int key)
 188 {
 189         if (key == fKeyDown)
 190         {
 191                 fKeyDown = 0;
 192                 fRepeatTimer = 0;
 193         }
 194 }
 195
 196 /*
 197 void c------------------------------() {}
 198 */
 199
 200 void DebugConsole::Draw()
 201 {
 202         if (fResponse[0])
 203         {
 204                 this->DrawText(fResponse);
 205
 206                 if (--fResponseTimer <= 0)
 207                         fResponse[0] = 0;
 208         }
 209         else if (fVisible)
 210         {
 211                 // key-repeat
 212                 if (fKeyDown)
 213                 {
 214                         if (--fRepeatTimer < 0)
 215                                 HandleKey(fKeyDown);
 216                 }
 217
 218                 char buffer[CONSOLE_MAXCMDLEN + 10];
 219                 fLine[fLineLen] = 0;
 220
 221                 sprintf(buffer, "-> %s%c",
 222                         fLine, (fCursorTimer < 20) ? '_' : ' ');
 223
 224                 this->DrawText(buffer);
 225
 226                 if (++fCursorTimer > 30)
 227                         fCursorTimer = 0;
 228         }
 229 }
 230
 231 void DebugConsole::DrawText(const char *text)
 232 {
 233         font_draw_shaded(4, (SCREEN_HEIGHT - 16), text);
 234 }
 235
 236 /*
 237 void c------------------------------() {}
 238 */
 239
 240 void DebugConsole::Print(const char *fmt, ...)
 241 {
 242 va_list ar;
 243
 244         va_start(ar, fmt);
 245         vsnprintf(fResponse, sizeof(fResponse), fmt, ar);
 246         va_end(ar);
 247
 248         stat("%s", fResponse);
 249         fResponseTimer = 60;
 250 }
 251
 252 /*
 253 void c------------------------------() {}
 254 */
 255
 256 bool DebugConsole::Execute(const char *line)
 257 {
 258         stat("DebugConsole::Execute('%s')", line);
 259
 260         // record command in backbuffer
 261         if (fBackBuffer.CountItems() >= CONSOLE_MAX_BACK)
 262                 fBackBuffer.RemoveString(0);
 263         fBackBuffer.AddString(line);
 264
 265         // split command into arguments
 266         StringList args;
 267         char *cmd = SplitCommand(line, &args);
 268
 269         if (cmd)
 270         {
 271                 BList matches;
 272                 MatchCommand(cmd, &matches);
 273                 free(cmd);
 274
 275                 if (matches.CountItems() == 1)
 276                 {
 277                         CommandEntry *command = (CommandEntry *)matches.ItemAt(0);
 278
 279                         if (args.CountItems() < command->minArgs || \
 280                                 args.CountItems() > command->maxArgs)
 281                         {
 282                                 if (command->minArgs == command->maxArgs)
 283                                 {
 284                                         Print("'%s' requires %d argument%s", \
 285                                                 command->name, command->minArgs, \
 286                                                 (command->minArgs == 1) ? "":"s");
 287                                 }
 288                                 else if (args.CountItems() < command->minArgs)
 289                                 {
 290                                         Print("'%s' requires at least %d argument%s",
 291                                                 command->name, command->minArgs,
 292                                                 (command->minArgs == 1) ? "":"s");
 293                                 }
 294                                 else
 295                                 {
 296                                         Print("'%s' requires no more than %d arguments",
 297                                                 command->name, command->maxArgs);
 298                                 }
 299                         }
 300                         else
 301                         {
 302                                 void (*handler)(StringList *, int) = command->handler;
 303                                 int num = (args.CountItems() > 0) ? atoi(args.StringAt(0)) : 0;
 304
 305                                 (*handler)(&args, num);
 306                                 return 1;
 307                         }
 308                 }
 309                 else if (matches.CountItems() == 0)
 310                 {
 311                         Print("I don't understand");
 312                 }
 313                 else
 314                 {
 315                         Print("Ambiguous command");
 316                 }
 317         }
 318
 319         return 0;
 320 }
 321
 322 void DebugConsole::MatchCommand(const char *cmd, BList *matches)
 323 {
 324         for(int i=0; commands[i].name; i++)
 325         {
 326                 if (strcasebegin(commands[i].name, cmd))
 327                         matches->AddItem(&commands[i]);
 328         }
 329 }
 330
 331 // split an input line into command and arguments
 332 // returns the command portion of the line. you must free this buffer.
 333 char *DebugConsole::SplitCommand(const char *line_in, StringList *args)
 334 {
 335         while(*line_in == ' ' || *line_in == '\t') line_in++;
 336         char *line = strdup(line_in);
 337
 338         char *cmd = strtok(line, " \t");
 339         if (cmd && cmd[0])
 340         {
 341                 while(const char *arg = strtok(NULL, " \t"))
 342                 {
 343                         args->AddString(arg);
 344                 }
 345
 346                 return line;
 347         }
 348
 349         free(line);
 350         return NULL;
 351 }
 352
 353 // tab-expand the current command
 354 void DebugConsole::ExpandCommand()
 355 {
 356 StringList args;
 357 BList matches;
 358 char *cmd;
 359
 360         fLine[fLineLen] = 0;
 361
 362         if (!fBrowsingExpansion)
 363         {
 364                 maxcpy(fLineToExpand, fLine, sizeof(fLineToExpand));
 365                 fExpandIndex = 0;
 366         }
 367
 368         cmd = SplitCommand(fLineToExpand, &args);
 369         if (cmd)
 370         {
 371                 MatchCommand(cmd, &matches);
 372                 free(cmd);
 373
 374                 if (matches.CountItems() > 0)
 375                 {
 376                         if (fExpandIndex >= matches.CountItems())
 377                                 fExpandIndex = 0;
 378
 379                         CommandEntry *command = (CommandEntry *)matches.ItemAt(fExpandIndex);
 380                         DString newCommand(command->name);
 381
 382                         for(int i=0;;i++)
 383                         {
 384                                 const char *arg = args.StringAt(i);
 385                                 if (!arg) break;
 386
 387                                 newCommand.AppendChar(' ');
 388                                 newCommand.AppendString(arg);
 389                         }
 390
 391                         if (args.CountItems() < command->minArgs)
 392                                 newCommand.AppendChar(' ');
 393
 394                         maxcpy(fLine, newCommand.String(), sizeof(fLine));
 395                         fLineLen = strlen(fLine);
 396                 }
 397         }
 398
 399         if (matches.CountItems() != 1)
 400                 sound(SND_TINK);
 401 }
 402
 403 /*
 404 void c------------------------------() {}
 405 */
 406
 407 #define Respond         console.Print
 408
 409
 410 static void __god(StringList *args, int num)
 411 {
 412 bool enable;
 413
 414         if (args->CountItems() == 0)
 415                 enable = true;
 416         else
 417                 enable = num;
 418
 419         game.debug.god = enable;
 420 }
 421
 422 static void __script(StringList *args, int num)
 423 {
 424         // release any focus a current script may have on us
 425         if (player->movementmode == MOVEMODE_NORMAL)
 426                 map_focus(NULL);
 427
 428         if (StartScript(num))
 429         {
 430                 Respond("Script %04d started.", num);
 431         }
 432         else
 433         {
 434                 Respond("No such script %04d", num);
 435         }
 436 }
 437
 438 static void __warp(StringList *args, int num)
 439 {
 440         if (num == 0)
 441         {
 442                 DString stagename;
 443                 for(int i=0;i<args->CountItems();i++)
 444                 {
 445                         if (i != 0) stagename.AppendChar(' ');
 446                         stagename.AppendString(args->StringAt(i));
 447                 }
 448
 449                 stat("Looking for '%s'", stagename.String());
 450                 for(num=0;;num++)
 451                 {
 452                         if (num >= num_stages)
 453                         {
 454                                 if (!strcasecmp(stagename.String(), "village"))
 455                                 {
 456                                         num = 11;
 457                                 }
 458                                 else
 459                                 {
 460                                         Respond("Could determine stage number from your description.");
 461                                         return;
 462                                 }
 463
 464                                 break;
 465                         }
 466
 467                         if (strcasebegin(stages[num].stagename, stagename.String()))
 468                                 break;
 469                 }
 470         }
 471
 472         game.switchstage.mapno = num;
 473         game.switchstage.playerx = 16;
 474         game.switchstage.playery = 16;
 475 }
 476
 477 static void __sound(StringList *args, int num)
 478 {
 479         sound(num);
 480         console.SetVisible(true);       // keep console up
 481 }
 482
 483 static void __music(StringList *args, int num)
 484 {
 485         extern const char *org_names[];
 486         bool ok = true;
 487         int i;
 488
 489         const char *name = args->StringAt(0);
 490         if (num == 0 && strcmp(name, "0") != 0)
 491         {
 492                 for(i=1;;i++)
 493                 {
 494                         if (!org_names[i]) break;
 495
 496                         if (strcasebegin(org_names[i], name))
 497                         {
 498                                 num = i;
 499                                 break;
 500                         }
 501                 }
 502
 503                 if (num == 0)
 504                 {
 505                         Respond("Don't know that song.");
 506                         return;
 507                 }
 508         }
 509
 510         if (num < 0) ok = false;
 511         else
 512         {
 513                 for(i=1;i<=num;i++)
 514                 {
 515                         if (!org_names[i])
 516                         {
 517                                 ok = false;
 518                                 break;
 519                         }
 520                 }
 521         }
 522
 523         if (!ok)
 524         {
 525                 Respond("track out of range");
 526                 music(0);
 527         }
 528         else
 529         {
 530                 music(0);
 531                 music(num);
 532                 if (org_names[num])
 533                         Respond("%s started", org_names[num]);
 534         }
 535 }
 536
 537 static void __giveweapon(StringList *args, int num)
 538 {
 539         if (num >= 0 && num < WPN_COUNT)
 540         {
 541                 player->weapons[num].hasWeapon = 1;
 542                 player->weapons[num].maxammo = 0;               // gives it unlimited ammo
 543                 player->weapons[num].ammo = 0;
 544                 player->curWeapon = num;
 545         }
 546 }
 547
 548 static void __dropweapon(StringList *args, int num)
 549 {
 550         if (args->CountItems() == 0)
 551                 num = player->curWeapon;
 552
 553         player->weapons[num].hasWeapon = 0;
 554         player->weapons[num].maxammo = 0;
 555         player->weapons[num].ammo = 0;
 556
 557         if (num == player->curWeapon)
 558                 stat_NextWeapon();
 559 }
 560
 561 // set weapon level
 562 static void __level(StringList *args, int num)
 563 {
 564         num--;
 565         if (num < 0) num = 0;
 566         if (num > 2) num = 2;
 567
 568         if (player->weapons[player->curWeapon].xp < 5)
 569                 player->weapons[player->curWeapon].xp = 5;
 570
 571         for(int timeout=0;timeout<500;timeout++)
 572         {
 573                 if (player->weapons[player->curWeapon].level == num)
 574                 {
 575                         return;
 576                 }
 577                 else if (player->weapons[player->curWeapon].level < num)
 578                 {
 579                         AddXP(1);
 580                 }
 581                 else
 582                 {
 583                         SubXP(1);
 584                 }
 585         }
 586
 587         Respond("Timeout");
 588 }
 589
 590
 591 static void __ammo(StringList *args, int num)
 592 {
 593         player->weapons[player->curWeapon].ammo = num;
 594         if (player->weapons[player->curWeapon].ammo > player->weapons[player->curWeapon].maxammo)
 595                 player->weapons[player->curWeapon].maxammo = player->weapons[player->curWeapon].ammo;
 596 }
 597
 598 static void __maxammo(StringList *args, int num)
 599 {
 600         player->weapons[player->curWeapon].maxammo = num;
 601         if (player->weapons[player->curWeapon].ammo > player->weapons[player->curWeapon].maxammo)
 602                 player->weapons[player->curWeapon].ammo = player->weapons[player->curWeapon].maxammo;
 603 }
 604
 605 static void __hp(StringList *args, int num)
 606 {
 607         player->hp = num;
 608         if (player->hp > player->maxHealth)
 609                 player->maxHealth = player->hp;
 610 }
 611
 612 static void __maxhp(StringList *args, int num)
 613 {
 614         player->maxHealth = num;
 615         if (player->hp > player->maxHealth)
 616         {
 617                 player->hp = player->maxHealth;
 618                 //PHealthBar.displayed_value = player->hp;
 619         }
 620 }
 621
 622 static void __xp(StringList *args, int num)
 623 {
 624         player->weapons[player->curWeapon].xp = num;
 625 }
 626
 627 static void __spawn(StringList *args, int num)
 628 {
 629         int i = 0;
 630
 631         // if first argument is a number interpret it as a count of
 632         // objects to spawn.
 633         int count;
 634         if (isdigit(args->StringAt(0)[0]))
 635         {
 636                 count = num;
 637                 i++;
 638         }
 639         else
 640         {
 641                 count = 1;
 642         }
 643
 644         // reconstitute the arguments into the name of the object
 645         // to be spawned.
 646         DString objName;
 647         int starti = i;
 648         for(;;i++)
 649         {
 650                 if (!args->StringAt(i)) break;
 651
 652                 if (i > starti) objName.AppendChar(' ');
 653                 objName.AppendString(args->StringAt(i));
 654         }
 655
 656         // try and get object type from the provided name
 657         int type = ObjectNameToType(objName.String());
 658         if (type == -1)
 659         {
 660                 Respond("Unknown object. See object.h for definitions.");
 661                 return;
 662         }
 663
 664         // reset console animate flags on any previously spawned objects
 665         Object *o;
 666         FOREACH_OBJECT(o)
 667         {
 668                 o->nxflags &= ~NXFLAG_CONSOLE_ANIMATE;
 669         }
 670
 671         // get starting spawn position and spacing
 672         int x = player->x + ((player->dir==RIGHT) ? (24 << CSF) : -(24 << CSF));
 673         int y = player->y - (16 << CSF);
 674         int w = (sprites[objprop[type].sprite].w + 4) << CSF;
 675
 676         // create 'em
 677         for(i=0;i<count;i++)
 678         {
 679                 Object *o = CreateObject(x, y, type);
 680
 681                 o->dir = player->dir;
 682                 o->nxflags |= NXFLAG_CONSOLE_ANIMATE;
 683                 x += w;
 684         }
 685
 686         if (count != 1)
 687                 Respond("%s x%d", DescribeObjectType(type), count);
 688         else
 689                 Respond("%s", DescribeObjectType(type));
 690 }
 691
 692 static void __animate(StringList *args, int num)
 693 {
 694         Object *o;
 695
 696         if (args->CountItems() == 2)
 697         {       // specifying explicitly by id2
 698                 o = FindObjectByID2(atoi(args->StringAt(0)));
 699                 if (o)
 700                         o->state = atoi(args->StringAt(1));
 701                 else
 702                         Respond("Object not found.");
 703
 704                 return;
 705         }
 706
 707         // animating implicitly from last spawn command
 708         bool found = false;
 709         FOREACH_OBJECT(o)
 710         {
 711                 if (o->nxflags & NXFLAG_CONSOLE_ANIMATE)
 712                 {
 713                         o->state = num;
 714                         found = true;
 715                 }
 716         }
 717
 718         if (!found)
 719                 Respond("No objects found.");
 720 }
 721
 722 static void __infinitedamage(StringList *args, int num)
 723 {
 724         if (args->CountItems() > 0)
 725                 game.debug.infinite_damage = num;
 726         else
 727                 game.debug.infinite_damage ^= 1;
 728
 729         Respond(game.debug.infinite_damage ? "My, oh my..." : "Back to normal.");
 730 }
 731
 732 static void __killall(StringList *args, int num)
 733 {
 734         for(int i=0;i<nOnscreenObjects;i++)
 735         {
 736                 Object *o = onscreen_objects[i];
 737                 if (o->flags & FLAG_SHOOTABLE)
 738                 {
 739                         o->flags &= ~FLAG_INVULNERABLE;
 740                         o->DealDamage(999);
 741                 }
 742         }
 743 }
 744
 745 static void __movemode(StringList *args, int num)
 746 {
 747         player->movementmode = num;
 748 }
 749
 750 static void __flag(StringList *args, int num)
 751 {
 752         game.flags[num] ^= 1;
 753         Respond("Flag %04d: %s", num, game.flags[num] ? "SET":"CLEARED");
 754 }
 755
 756 static void __clearflags(StringList *args, int num)
 757 {
 758         memset(game.flags, 0, sizeof(game.flags));
 759         Respond("Warning- all game flags cleared");
 760 }
 761
 762 static void __equip(StringList *args, int num)
 763 {
 764 static const char *equiplist[] =
 765 {
 766         "booster08",
 767         "map",
 768         "armsbarrier",
 769         "turbocharge",
 770         "airtank",
 771         "booster20",
 772         "mimigamask",
 773         "whimstar",
 774         "nikumaru",
 775         NULL
 776 };
 777 int i, mask;
 778
 779         const char *item = args->StringAt(0);
 780         bool enable = args->StringAt(1) ? atoi(args->StringAt(1)) : true;
 781
 782         mask = 0x01;
 783         for(i=0;equiplist[i];i++)
 784         {
 785                 if (!strcasecmp(equiplist[i], item))
 786                 {
 787                         // allow only booster 08 or booster 20 at a time
 788                         if (mask & (EQUIP_BOOSTER08 | EQUIP_BOOSTER20))
 789                                 player->equipmask &= ~(EQUIP_BOOSTER08 | EQUIP_BOOSTER20);
 790
 791                         if (enable)
 792                                 player->equipmask |= mask;
 793                         else
 794                                 player->equipmask &= ~mask;
 795
 796                         Respond("Item %s (0x%04x) %sequipped.",
 797                                 equiplist[i], mask, enable ? "" : "un-");
 798                         return;
 799                 }
 800
 801                 mask <<= 1;
 802         }
 803
 804         Respond("Unknown item");
 805 }
 806
 807 static void __giveitem(StringList *args, int num)
 808 {
 809         if (FindInventory(num) == -1)
 810         {
 811                 AddInventory(num);
 812                 Respond("Added item %d to your inventory.", num);
 813         }
 814         else
 815         {
 816                 Respond("You already have item %d in your inventory.", num);
 817         }
 818 }
 819
 820 static void __takeitem(StringList *args, int num)
 821 {
 822         if (FindInventory(num) != -1)
 823         {
 824                 DelInventory(num);
 825                 Respond("Removed item %d from your inventory.", num);
 826         }
 827         else
 828         {
 829                 Respond("You don't have item %d in your inventory.", num);
 830         }
 831 }
 832
 833 static void __qua(StringList *args, int num)
 834 {
 835         if (args->CountItems() > 0)
 836                 megaquake(50);
 837         else
 838                 quake(50);
 839 }
 840
 841 static void __boa(StringList *args, int num)
 842 {
 843         game.stageboss.SetState(num);
 844 }
 845
 846 // skip to good ending sequence
 847 static void __cre(StringList *args, int num)
 848 {
 849         game.reset();
 850         game.pause(0);
 851         game.setmode(GM_NORMAL);
 852
 853         game.flags[1341] = true;
 854         game.switchstage.mapno = 70;
 855         game.switchstage.playerx = 16;
 856         game.switchstage.playery = 16;
 857         game.switchstage.eventonentry = 400;
 858 }
 859
 860 static void __reset(StringList *args, int num)
 861 {
 862         game.reset();
 863 }
 864
 865 static void __fps(StringList *args, int num)
 866 {
 867 extern int fps;
 868
 869         settings->show_fps ^= 1;
 870         settings_save();
 871         fps = 0;
 872 }
 873
 874 /*
 875 void c------------------------------() {}
 876 */
 877
 878 static void __set_iquit(StringList *args, int num)
 879 {
 880         settings->instant_quit = num;
 881         settings_save();
 882         Respond("instant quit: %s", settings->instant_quit ? "enabled":"disabled");
 883 }
 884
 885 static void __set_noquake(StringList *args, int num)
 886 {
 887         settings->no_quake_in_hell = num;
 888         settings_save();
 889         Respond("no quake in hell: %s", settings->no_quake_in_hell ? "enabled":"disabled");
 890 }
 891
 892 static void __inhibit_fullscreen(StringList *args, int num)
 893 {
 894         settings->inhibit_fullscreen = num;
 895         settings_save();
 896         Respond("inhibit fullscreen: %s", settings->inhibit_fullscreen ? "enabled":"disabled");
 897 }
 898
 899 static void __emulate_bugs(StringList *args, int num)
 900 {
 901         settings->emulate_bugs = num;
 902         settings_save();
 903         Respond("emulate bugs: %s", settings->emulate_bugs ? "enabled":"disabled");
 904 }
 905
 906 static void __displayformat(StringList *args, int num)
 907 {
 908         settings->displayformat = num;
 909         settings_save();
 910         Graphics::FlushAll();
 911         Respond("SDL_DisplayFormat: %s", settings->displayformat ? "on":"off");
 912 }
 913
 914 static void __skip_intro(StringList *args, int num)
 915 {
 916         settings->skip_intro = num;
 917         settings_save();
 918         Respond("skip_intro: %s", settings->skip_intro ? "enabled":"disabled");
 919 }
 920
 921 /*
 922 void c------------------------------() {}
 923 */
 924
 925 static void __hello(StringList *args, int num)
 926 {
 927         Respond("I'm a computer, you ninny. Go get a real friend.");
 928 }
 929
 930 /*
 931 void c------------------------------() {}
 932 */
 933
 934 static void __player_hide(StringList *args, int num)
 935 {
 936         player->hide = num;
 937 }
 938
 939 static void __player_inputs_locked(StringList *args, int num)
 940 {
 941         player->inputs_locked = num;
 942 }
 943
 944 static void __game_frozen(StringList *args, int num)
 945 {
 946         game.frozen = num;
 947 }
 948
 949 static void __textbox_setvisible(StringList *args, int num)
 950 {
 951         textbox.SetVisible(num);
 952 }
 953