base/sb_bar.c

   1
   2 //**************************************************************************
   3 //**
   4 //** sb_bar.c : Heretic 2 : Raven Software, Corp.
   5 //**
   6 //** $RCSfile$
   7 //** $Revision$
   8 //** $Date$
   9 //** $Author$
  10 //**
  11 //**************************************************************************
  12
  13 // HEADER FILES ------------------------------------------------------------
  14
  15 #include "h2def.h"
  16 #include "p_local.h"
  17 #include "soundst.h"
  18 #include "i_cdmus.h" /* jim for CD track cheat */
  19
  20 #ifdef RENDER3D
  21 #include "ogl_def.h"
  22 #define PATCH_REF       int
  23 #define INVALID_PATCH   0
  24 #define W_CacheLumpName(a,b)        W_GetNumForName(a)
  25 #define WR_CacheLumpNum(a,b)        a
  26 #define V_DrawPatch(x,y,p)          OGL_DrawPatch(x,y,p)
  27 #define V_DrawFuzzPatch(x,y,p)      OGL_DrawFuzzPatch(x,y,p)
  28 #define V_DrawAltFuzzPatch(x,y,p)   OGL_DrawAltFuzzPatch(x,y,p)
  29 #else
  30 #define PATCH_REF       patch_t*
  31 #define INVALID_PATCH   0
  32 #define WR_CacheLumpNum(a,b)        W_CacheLumpNum(a,b)
  33 #endif
  34
  35
  36 // MACROS ------------------------------------------------------------------
  37
  38 #define CHEAT_ENCRYPT(a) \
  39         ((((a)&1)<<2)+ \
  40         (((a)&2)>>1)+ \
  41         (((a)&4)<<5)+ \
  42         (((a)&8)<<2)+ \
  43         (((a)&16)>>3)+ \
  44         (((a)&32)<<1)+ \
  45         (((a)&64)>>3)+ \
  46         (((a)&128)>>3))
  47
  48 // TYPES -------------------------------------------------------------------
  49
  50 typedef struct Cheat_s
  51 {
  52         void (*func)(player_t *player, struct Cheat_s *cheat);
  53         byte *sequence;
  54         byte *pos;
  55         int args[2];
  56         int currentArg;
  57 } Cheat_t;
  58
  59 // EXTERNAL FUNCTION PROTOTYPES --------------------------------------------
  60
  61 // PUBLIC FUNCTION PROTOTYPES ----------------------------------------------
  62
  63 void SB_PaletteFlash(boolean forceChange);
  64
  65 // PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
  66
  67 static void DrawSoundInfo(void);
  68 static void DrINumber(signed int val, int x, int y);
  69 static void DrRedINumber(signed int val, int x, int y);
  70 static void DrBNumber(signed int val, int x, int y);
  71 static void DrawCommonBar(void);
  72 static void DrawMainBar(void);
  73 static void DrawInventoryBar(void);
  74 static void DrawKeyBar(void);
  75 static void DrawWeaponPieces(void);
  76 static void DrawFullScreenStuff(void);
  77 static void DrawAnimatedIcons(void);
  78 static boolean HandleCheats(byte key);
  79 static boolean CheatAddKey(Cheat_t *cheat, byte key, boolean *eat);
  80 static void CheatGodFunc(player_t *player, Cheat_t *cheat);
  81 static void CheatNoClipFunc(player_t *player, Cheat_t *cheat);
  82 static void CheatWeaponsFunc(player_t *player, Cheat_t *cheat);
  83 static void CheatHealthFunc(player_t *player, Cheat_t *cheat);
  84 static void CheatKeysFunc(player_t *player, Cheat_t *cheat);
  85 static void CheatSoundFunc(player_t *player, Cheat_t *cheat);
  86 static void CheatTickerFunc(player_t *player, Cheat_t *cheat);
  87 static void CheatArtifactAllFunc(player_t *player, Cheat_t *cheat);
  88 static void CheatPuzzleFunc(player_t *player, Cheat_t *cheat);
  89 static void CheatWarpFunc(player_t *player, Cheat_t *cheat);
  90 static void CheatPigFunc(player_t *player, Cheat_t *cheat);
  91 static void CheatMassacreFunc(player_t *player, Cheat_t *cheat);
  92 static void CheatIDKFAFunc(player_t *player, Cheat_t *cheat);
  93 static void CheatQuickenFunc1(player_t *player, Cheat_t *cheat);
  94 static void CheatQuickenFunc2(player_t *player, Cheat_t *cheat);
  95 static void CheatQuickenFunc3(player_t *player, Cheat_t *cheat);
  96 static void CheatClassFunc1(player_t *player, Cheat_t *cheat);
  97 static void CheatClassFunc2(player_t *player, Cheat_t *cheat);
  98 static void CheatInitFunc(player_t *player, Cheat_t *cheat);
  99 static void CheatInitFunc(player_t *player, Cheat_t *cheat);
 100 static void CheatVersionFunc(player_t *player, Cheat_t *cheat);
 101 static void CheatDebugFunc(player_t *player, Cheat_t *cheat);
 102 static void CheatScriptFunc1(player_t *player, Cheat_t *cheat);
 103 static void CheatScriptFunc2(player_t *player, Cheat_t *cheat);
 104 static void CheatScriptFunc3(player_t *player, Cheat_t *cheat);
 105 static void CheatRevealFunc(player_t *player, Cheat_t *cheat);
 106 static void CheatTrackFunc1(player_t *player, Cheat_t *cheat);
 107 static void CheatTrackFunc2(player_t *player, Cheat_t *cheat);
 108
 109 // EXTERNAL DATA DECLARATIONS ----------------------------------------------
 110
 111 extern byte *screen;
 112 extern int ArmorIncrement[NUMCLASSES][NUMARMOR];
 113 extern int AutoArmorSave[NUMCLASSES];
 114
 115
 116 extern boolean i_CDMusic;
 117 extern int i_CDMusicLength;
 118 extern int i_CDTrack;
 119 extern int i_CDCurrentTrack;
 120 extern int oldTic;
 121
 122 // PUBLIC DATA DECLARATIONS ------------------------------------------------
 123
 124 boolean DebugSound; // Debug flag for displaying sound info
 125 boolean inventory;
 126 int curpos;
 127 int inv_ptr;
 128 int ArtifactFlash;
 129
 130 boolean i_CDMusic; // in Watcom, defined in i_ibm
 131
 132
 133 // PRIVATE DATA DEFINITIONS ------------------------------------------------
 134
 135 static byte CheatLookup[256];
 136 static int HealthMarker;
 137 //static int ChainWiggle;
 138 static player_t *CPlayer;
 139 static int SpinFlylump;
 140 static int SpinMinotaurLump;
 141 static int SpinSpeedLump;
 142 static int SpinDefenseLump;
 143
 144 static int FontBNumBase;
 145 static int PlayPalette;
 146
 147 static PATCH_REF PatchH2BAR;
 148 static PATCH_REF PatchH2TOP;
 149 static PATCH_REF PatchLFEDGE;
 150 static PATCH_REF PatchRTEDGE;
 151 static PATCH_REF PatchARMCLEAR;
 152 static PATCH_REF PatchARTICLEAR;
 153 static PATCH_REF PatchMANACLEAR;
 154 static PATCH_REF PatchKILLS;
 155 static PATCH_REF PatchMANAVIAL1;
 156 static PATCH_REF PatchMANAVIAL2;
 157 static PATCH_REF PatchMANAVIALDIM1;
 158 static PATCH_REF PatchMANAVIALDIM2;
 159 static PATCH_REF PatchMANADIM1;
 160 static PATCH_REF PatchMANADIM2;
 161 static PATCH_REF PatchMANABRIGHT1;
 162 static PATCH_REF PatchMANABRIGHT2;
 163 static PATCH_REF PatchCHAIN;
 164 static PATCH_REF PatchSTATBAR;
 165 static PATCH_REF PatchKEYBAR;
 166 static PATCH_REF PatchLIFEGEM;
 167 static PATCH_REF PatchSELECTBOX;
 168 static PATCH_REF PatchINumbers[10];
 169 static PATCH_REF PatchNEGATIVE;
 170 static PATCH_REF PatchSmNumbers[10];
 171 static PATCH_REF PatchINVBAR;
 172 static PATCH_REF PatchWEAPONSLOT;
 173 static PATCH_REF PatchWEAPONFULL;
 174 static PATCH_REF PatchPIECE1;
 175 static PATCH_REF PatchPIECE2;
 176 static PATCH_REF PatchPIECE3;
 177 static PATCH_REF PatchINVLFGEM1;
 178 static PATCH_REF PatchINVLFGEM2;
 179 static PATCH_REF PatchINVRTGEM1;
 180 static PATCH_REF PatchINVRTGEM2;
 181
 182 // Toggle god mode
 183 static byte CheatGodSeq[] =
 184 {
 185         CHEAT_ENCRYPT('s'),
 186         CHEAT_ENCRYPT('a'),
 187         CHEAT_ENCRYPT('t'),
 188         CHEAT_ENCRYPT('a'),
 189         CHEAT_ENCRYPT('n'),
 190         0xff
 191 };
 192
 193 // Toggle no clipping mode
 194 static byte CheatNoClipSeq[] =
 195 {
 196         CHEAT_ENCRYPT('c'),
 197         CHEAT_ENCRYPT('a'),
 198         CHEAT_ENCRYPT('s'),
 199         CHEAT_ENCRYPT('p'),
 200         CHEAT_ENCRYPT('e'),
 201         CHEAT_ENCRYPT('r'),
 202         0xff
 203 };
 204
 205 // Get all weapons and mana
 206 static byte CheatWeaponsSeq[] =
 207 {
 208         CHEAT_ENCRYPT('n'),
 209         CHEAT_ENCRYPT('r'),
 210         CHEAT_ENCRYPT('a'),
 211         0xff
 212 };
 213
 214 // Get full health
 215 static byte CheatHealthSeq[] =
 216 {
 217         CHEAT_ENCRYPT('c'),
 218         CHEAT_ENCRYPT('l'),
 219         CHEAT_ENCRYPT('u'),
 220         CHEAT_ENCRYPT('b'),
 221         CHEAT_ENCRYPT('m'),
 222         CHEAT_ENCRYPT('e'),
 223         CHEAT_ENCRYPT('d'),
 224         0xff
 225 };
 226
 227 // Get all keys
 228 static byte CheatKeysSeq[] =
 229 {
 230         CHEAT_ENCRYPT('l'),
 231         CHEAT_ENCRYPT('o'),
 232         CHEAT_ENCRYPT('c'),
 233         CHEAT_ENCRYPT('k'),
 234         CHEAT_ENCRYPT('s'),
 235         CHEAT_ENCRYPT('m'),
 236         CHEAT_ENCRYPT('i'),
 237         CHEAT_ENCRYPT('t'),
 238         CHEAT_ENCRYPT('h'),
 239         0xff, 0
 240 };
 241
 242 // Toggle sound debug info
 243 static byte CheatSoundSeq[] =
 244 {
 245         CHEAT_ENCRYPT('n'),
 246         CHEAT_ENCRYPT('o'),
 247         CHEAT_ENCRYPT('i'),
 248         CHEAT_ENCRYPT('s'),
 249         CHEAT_ENCRYPT('e'),
 250         0xff
 251 };
 252
 253 // Toggle ticker
 254 static byte CheatTickerSeq[] =
 255 {
 256         CHEAT_ENCRYPT('t'),
 257         CHEAT_ENCRYPT('i'),
 258         CHEAT_ENCRYPT('c'),
 259         CHEAT_ENCRYPT('k'),
 260         CHEAT_ENCRYPT('e'),
 261         CHEAT_ENCRYPT('r'),
 262         0xff, 0
 263 };
 264
 265 // Get all artifacts
 266 static byte CheatArtifactAllSeq[] =
 267 {
 268         CHEAT_ENCRYPT('i'),
 269         CHEAT_ENCRYPT('n'),
 270         CHEAT_ENCRYPT('d'),
 271         CHEAT_ENCRYPT('i'),
 272         CHEAT_ENCRYPT('a'),
 273         CHEAT_ENCRYPT('n'),
 274         CHEAT_ENCRYPT('a'),
 275         0xff, 0
 276 };
 277
 278 // Get all puzzle pieces
 279 static byte CheatPuzzleSeq[] =
 280 {
 281         CHEAT_ENCRYPT('s'),
 282         CHEAT_ENCRYPT('h'),
 283         CHEAT_ENCRYPT('e'),
 284         CHEAT_ENCRYPT('r'),
 285         CHEAT_ENCRYPT('l'),
 286         CHEAT_ENCRYPT('o'),
 287         CHEAT_ENCRYPT('c'),
 288         CHEAT_ENCRYPT('k'),
 289         0xff, 0
 290 };
 291
 292 // Warp to new level
 293 static byte CheatWarpSeq[] =
 294 {
 295         CHEAT_ENCRYPT('v'),
 296         CHEAT_ENCRYPT('i'),
 297         CHEAT_ENCRYPT('s'),
 298         CHEAT_ENCRYPT('i'),
 299         CHEAT_ENCRYPT('t'),
 300         0, 0, 0xff, 0
 301 };
 302
 303 // Become a pig
 304 static byte CheatPigSeq[] =
 305 {
 306         CHEAT_ENCRYPT('d'),
 307         CHEAT_ENCRYPT('e'),
 308         CHEAT_ENCRYPT('l'),
 309         CHEAT_ENCRYPT('i'),
 310         CHEAT_ENCRYPT('v'),
 311         CHEAT_ENCRYPT('e'),
 312         CHEAT_ENCRYPT('r'),
 313         CHEAT_ENCRYPT('a'),
 314         CHEAT_ENCRYPT('n'),
 315         CHEAT_ENCRYPT('c'),
 316         CHEAT_ENCRYPT('e'),
 317         0xff, 0
 318 };
 319
 320 // Kill all monsters
 321 static byte CheatMassacreSeq[] =
 322 {
 323         CHEAT_ENCRYPT('b'),
 324         CHEAT_ENCRYPT('u'),
 325         CHEAT_ENCRYPT('t'),
 326         CHEAT_ENCRYPT('c'),
 327         CHEAT_ENCRYPT('h'),
 328         CHEAT_ENCRYPT('e'),
 329         CHEAT_ENCRYPT('r'),
 330         0xff, 0
 331 };
 332
 333 static byte CheatIDKFASeq[] =
 334 {
 335         CHEAT_ENCRYPT('c'),
 336         CHEAT_ENCRYPT('o'),
 337         CHEAT_ENCRYPT('n'),
 338         CHEAT_ENCRYPT('a'),
 339         CHEAT_ENCRYPT('n'),
 340         0xff, 0
 341 };
 342
 343 static byte CheatQuickenSeq1[] =
 344 {
 345         CHEAT_ENCRYPT('m'),
 346         CHEAT_ENCRYPT('a'),
 347         CHEAT_ENCRYPT('r'),
 348         CHEAT_ENCRYPT('t'),
 349         CHEAT_ENCRYPT('e'),
 350         CHEAT_ENCRYPT('k'),
 351         0xff, 0
 352 };
 353
 354 static byte CheatQuickenSeq2[] =
 355 {
 356         CHEAT_ENCRYPT('m'),
 357         CHEAT_ENCRYPT('a'),
 358         CHEAT_ENCRYPT('r'),
 359         CHEAT_ENCRYPT('t'),
 360         CHEAT_ENCRYPT('e'),
 361         CHEAT_ENCRYPT('k'),
 362         CHEAT_ENCRYPT('m'),
 363         CHEAT_ENCRYPT('a'),
 364         CHEAT_ENCRYPT('r'),
 365         CHEAT_ENCRYPT('t'),
 366         CHEAT_ENCRYPT('e'),
 367         CHEAT_ENCRYPT('k'),
 368         0xff, 0
 369 };
 370
 371 static byte CheatQuickenSeq3[] =
 372 {
 373         CHEAT_ENCRYPT('m'),
 374         CHEAT_ENCRYPT('a'),
 375         CHEAT_ENCRYPT('r'),
 376         CHEAT_ENCRYPT('t'),
 377         CHEAT_ENCRYPT('e'),
 378         CHEAT_ENCRYPT('k'),
 379         CHEAT_ENCRYPT('m'),
 380         CHEAT_ENCRYPT('a'),
 381         CHEAT_ENCRYPT('r'),
 382         CHEAT_ENCRYPT('t'),
 383         CHEAT_ENCRYPT('e'),
 384         CHEAT_ENCRYPT('k'),
 385         CHEAT_ENCRYPT('m'),
 386         CHEAT_ENCRYPT('a'),
 387         CHEAT_ENCRYPT('r'),
 388         CHEAT_ENCRYPT('t'),
 389         CHEAT_ENCRYPT('e'),
 390         CHEAT_ENCRYPT('k'),
 391         0xff, 0
 392 };
 393
 394 // New class
 395 static byte CheatClass1Seq[] =
 396 {
 397         CHEAT_ENCRYPT('s'),
 398         CHEAT_ENCRYPT('h'),
 399         CHEAT_ENCRYPT('a'),
 400         CHEAT_ENCRYPT('d'),
 401         CHEAT_ENCRYPT('o'),
 402         CHEAT_ENCRYPT('w'),
 403         CHEAT_ENCRYPT('c'),
 404         CHEAT_ENCRYPT('a'),
 405         CHEAT_ENCRYPT('s'),
 406         CHEAT_ENCRYPT('t'),
 407         CHEAT_ENCRYPT('e'),
 408         CHEAT_ENCRYPT('r'),
 409         0xff, 0
 410 };
 411
 412 static byte CheatClass2Seq[] =
 413 {
 414         CHEAT_ENCRYPT('s'),
 415         CHEAT_ENCRYPT('h'),
 416         CHEAT_ENCRYPT('a'),
 417         CHEAT_ENCRYPT('d'),
 418         CHEAT_ENCRYPT('o'),
 419         CHEAT_ENCRYPT('w'),
 420         CHEAT_ENCRYPT('c'),
 421         CHEAT_ENCRYPT('a'),
 422         CHEAT_ENCRYPT('s'),
 423         CHEAT_ENCRYPT('t'),
 424         CHEAT_ENCRYPT('e'),
 425         CHEAT_ENCRYPT('r'),
 426         0, 0xff, 0
 427 };
 428
 429 static byte CheatInitSeq[] =
 430 {
 431         CHEAT_ENCRYPT('i'),
 432         CHEAT_ENCRYPT('n'),
 433         CHEAT_ENCRYPT('i'),
 434         CHEAT_ENCRYPT('t'),
 435         0xff, 0
 436 };
 437
 438 static byte CheatVersionSeq[] =
 439 {
 440         CHEAT_ENCRYPT('m'),
 441         CHEAT_ENCRYPT('r'),
 442         CHEAT_ENCRYPT('j'),
 443         CHEAT_ENCRYPT('o'),
 444         CHEAT_ENCRYPT('n'),
 445         CHEAT_ENCRYPT('e'),
 446         CHEAT_ENCRYPT('s'),
 447         0xff, 0
 448 };
 449
 450 static byte CheatDebugSeq[] =
 451 {
 452         CHEAT_ENCRYPT('w'),
 453         CHEAT_ENCRYPT('h'),
 454         CHEAT_ENCRYPT('e'),
 455         CHEAT_ENCRYPT('r'),
 456         CHEAT_ENCRYPT('e'),
 457         0xff, 0
 458 };
 459
 460 static byte CheatScriptSeq1[] =
 461 {
 462         CHEAT_ENCRYPT('p'),
 463         CHEAT_ENCRYPT('u'),
 464         CHEAT_ENCRYPT('k'),
 465         CHEAT_ENCRYPT('e'),
 466         0xff, 0
 467 };
 468
 469 static byte CheatScriptSeq2[] =
 470 {
 471         CHEAT_ENCRYPT('p'),
 472         CHEAT_ENCRYPT('u'),
 473         CHEAT_ENCRYPT('k'),
 474         CHEAT_ENCRYPT('e'),
 475         0, 0xff, 0
 476 };
 477
 478 static byte CheatScriptSeq3[] =
 479 {
 480         CHEAT_ENCRYPT('p'),
 481         CHEAT_ENCRYPT('u'),
 482         CHEAT_ENCRYPT('k'),
 483         CHEAT_ENCRYPT('e'),
 484         0, 0, 0xff,
 485 };
 486
 487 static byte CheatRevealSeq[] =
 488 {
 489         CHEAT_ENCRYPT('m'),
 490         CHEAT_ENCRYPT('a'),
 491         CHEAT_ENCRYPT('p'),
 492         CHEAT_ENCRYPT('s'),
 493         CHEAT_ENCRYPT('c'),
 494         CHEAT_ENCRYPT('o'),
 495         0xff, 0
 496 };
 497
 498 static byte CheatTrackSeq1[] =
 499 {
 500         CHEAT_ENCRYPT('`'),
 501         0xff, 0
 502 };
 503
 504 static byte CheatTrackSeq2[] =
 505 {
 506         CHEAT_ENCRYPT('`'),
 507         0, 0, 0xff, 0
 508 };
 509
 510 /* jim added {} around args field (aren't keyboard macros great?) */
 511 static Cheat_t Cheats[] =
 512 {
 513         { CheatTrackFunc1, CheatTrackSeq1, NULL, {0, 0}, 0 },
 514         { CheatTrackFunc2, CheatTrackSeq2, NULL, {0, 0}, 0 },
 515         { CheatGodFunc, CheatGodSeq, NULL, {0, 0}, 0 },
 516         { CheatNoClipFunc, CheatNoClipSeq, NULL, {0, 0}, 0 },
 517         { CheatWeaponsFunc, CheatWeaponsSeq, NULL, {0, 0}, 0 },
 518         { CheatHealthFunc, CheatHealthSeq, NULL, {0, 0}, 0 },
 519         { CheatKeysFunc, CheatKeysSeq, NULL, {0, 0}, 0 },
 520         { CheatSoundFunc, CheatSoundSeq, NULL, {0, 0}, 0 },
 521         { CheatTickerFunc, CheatTickerSeq, NULL, {0, 0}, 0 },
 522         { CheatArtifactAllFunc, CheatArtifactAllSeq, NULL, {0, 0}, 0 },
 523         { CheatPuzzleFunc, CheatPuzzleSeq, NULL, {0, 0}, 0 },
 524         { CheatWarpFunc, CheatWarpSeq, NULL, {0, 0}, 0 },
 525         { CheatPigFunc, CheatPigSeq, NULL, {0, 0}, 0 },
 526         { CheatMassacreFunc, CheatMassacreSeq, NULL, {0, 0}, 0 },
 527         { CheatIDKFAFunc, CheatIDKFASeq, NULL, {0, 0}, 0 },
 528         { CheatQuickenFunc1, CheatQuickenSeq1, NULL, {0, 0}, 0 },
 529         { CheatQuickenFunc2, CheatQuickenSeq2, NULL, {0, 0}, 0 },
 530         { CheatQuickenFunc3, CheatQuickenSeq3, NULL, {0, 0}, 0 },
 531         { CheatClassFunc1, CheatClass1Seq, NULL, {0, 0}, 0 },
 532         { CheatClassFunc2, CheatClass2Seq, NULL, {0, 0}, 0 },
 533         { CheatInitFunc, CheatInitSeq, NULL, {0, 0}, 0 },
 534         { CheatVersionFunc, CheatVersionSeq, NULL, {0, 0}, 0 },
 535         { CheatDebugFunc, CheatDebugSeq, NULL, {0, 0}, 0 },
 536         { CheatScriptFunc1, CheatScriptSeq1, NULL, {0, 0}, 0 },
 537         { CheatScriptFunc2, CheatScriptSeq2, NULL, {0, 0}, 0 },
 538         { CheatScriptFunc3, CheatScriptSeq3, NULL, {0, 0}, 0 },
 539         { CheatRevealFunc, CheatRevealSeq, NULL, {0, 0}, 0 },
 540         { NULL, NULL, NULL, {0, 0}, 0 } // Terminator
 541 };
 542
 543 // CODE --------------------------------------------------------------------
 544
 545 //==========================================================================
 546 //
 547 // SB_Init
 548 //
 549 //==========================================================================
 550
 551 void SB_Init(void)
 552 {
 553         int i;
 554         int startLump;
 555
 556         PatchH2BAR = W_CacheLumpName("H2BAR", PU_STATIC);
 557         PatchH2TOP = W_CacheLumpName("H2TOP", PU_STATIC);
 558         PatchINVBAR = W_CacheLumpName("INVBAR", PU_STATIC);
 559         PatchLFEDGE     = W_CacheLumpName("LFEDGE", PU_STATIC);
 560         PatchRTEDGE     = W_CacheLumpName("RTEDGE", PU_STATIC);
 561         PatchSTATBAR = W_CacheLumpName("STATBAR", PU_STATIC);
 562         PatchKEYBAR = W_CacheLumpName("KEYBAR", PU_STATIC);
 563         PatchSELECTBOX = W_CacheLumpName("SELECTBOX", PU_STATIC);
 564         PatchARTICLEAR = W_CacheLumpName("ARTICLS", PU_STATIC);
 565         PatchARMCLEAR = W_CacheLumpName("ARMCLS", PU_STATIC);
 566         PatchMANACLEAR = W_CacheLumpName("MANACLS", PU_STATIC);
 567         PatchMANAVIAL1 = W_CacheLumpName("MANAVL1", PU_STATIC);
 568         PatchMANAVIAL2 = W_CacheLumpName("MANAVL2", PU_STATIC);
 569         PatchMANAVIALDIM1 = W_CacheLumpName("MANAVL1D", PU_STATIC);
 570         PatchMANAVIALDIM2 = W_CacheLumpName("MANAVL2D", PU_STATIC);
 571         PatchMANADIM1 = W_CacheLumpName("MANADIM1", PU_STATIC);
 572         PatchMANADIM2 = W_CacheLumpName("MANADIM2", PU_STATIC);
 573         PatchMANABRIGHT1 = W_CacheLumpName("MANABRT1", PU_STATIC);
 574         PatchMANABRIGHT2 = W_CacheLumpName("MANABRT2", PU_STATIC);
 575         PatchINVLFGEM1 = W_CacheLumpName("invgeml1", PU_STATIC);
 576         PatchINVLFGEM2 = W_CacheLumpName("invgeml2", PU_STATIC);
 577         PatchINVRTGEM1 = W_CacheLumpName("invgemr1", PU_STATIC);
 578         PatchINVRTGEM2 = W_CacheLumpName("invgemr2", PU_STATIC);
 579
 580 //      PatchCHAINBACK = W_CacheLumpName("CHAINBACK", PU_STATIC);
 581         startLump = W_GetNumForName("IN0");
 582         for(i = 0; i < 10; i++)
 583         {
 584                 PatchINumbers[i] = WR_CacheLumpNum(startLump+i, PU_STATIC);
 585         }
 586         PatchNEGATIVE = W_CacheLumpName("NEGNUM", PU_STATIC);
 587         FontBNumBase = W_GetNumForName("FONTB16");
 588         startLump = W_GetNumForName("SMALLIN0");
 589         for(i = 0; i < 10; i++)
 590         {
 591                 PatchSmNumbers[i] = WR_CacheLumpNum(startLump+i, PU_STATIC);
 592         }
 593         PlayPalette = W_GetNumForName("PLAYPAL");
 594         SpinFlylump = W_GetNumForName("SPFLY0");
 595         SpinMinotaurLump = W_GetNumForName("SPMINO0");
 596         SpinSpeedLump = W_GetNumForName("SPBOOT0");
 597         SpinDefenseLump = W_GetNumForName("SPSHLD0");
 598
 599         for(i = 0; i < 256; i++)
 600         {
 601                 CheatLookup[i] = CHEAT_ENCRYPT(i);
 602         }
 603
 604         if(deathmatch)
 605         {
 606                 PatchKILLS = W_CacheLumpName("KILLS", PU_STATIC);
 607         }
 608         SB_SetClassData();
 609 }
 610
 611 //==========================================================================
 612 //
 613 // SB_SetClassData
 614 //
 615 //==========================================================================
 616
 617 void SB_SetClassData(void)
 618 {
 619         int class;
 620         if(PlayerClass[consoleplayer] != PCLASS_ASS)
 621         class = PlayerClass[consoleplayer]; // original player class (not pig)
 622         else
 623         class = 0; // Use FIghter chain and gem for now
 624         PatchWEAPONSLOT = WR_CacheLumpNum(W_GetNumForName("wpslot0")
 625                 +class, PU_STATIC);
 626         PatchWEAPONFULL = WR_CacheLumpNum(W_GetNumForName("wpfull0")
 627                 +class, PU_STATIC);
 628         PatchPIECE1     = WR_CacheLumpNum(W_GetNumForName("wpiecef1")
 629                 +class, PU_STATIC);
 630         PatchPIECE2     = WR_CacheLumpNum(W_GetNumForName("wpiecef2")
 631                 +class, PU_STATIC);
 632         PatchPIECE3     = WR_CacheLumpNum(W_GetNumForName("wpiecef3")
 633                 +class, PU_STATIC);
 634         PatchCHAIN = WR_CacheLumpNum(W_GetNumForName("chain")
 635                 +class, PU_STATIC);
 636         if(!netgame)
 637         { // single player game uses red life gem (the second gem)
 638                 PatchLIFEGEM = WR_CacheLumpNum(W_GetNumForName("lifegem")
 639                         +4*class+1, PU_STATIC);
 640         }
 641         else
 642         {
 643                 PatchLIFEGEM = WR_CacheLumpNum(W_GetNumForName("lifegem")
 644                         +MAXPLAYERS*class+consoleplayer, PU_STATIC);
 645         }
 646         SB_state = -1;
 647         UpdateState |= I_FULLSCRN;
 648 }
 649
 650 //==========================================================================
 651 //
 652 // SB_Ticker
 653 //
 654 //==========================================================================
 655
 656 void SB_Ticker(void)
 657 {
 658         int delta;
 659         int curHealth;
 660
 661         curHealth = players[consoleplayer].mo->health;
 662         if(curHealth < 0)
 663         {
 664                 curHealth = 0;
 665         }
 666         if(curHealth < HealthMarker)
 667         {
 668                 delta = (HealthMarker-curHealth)>>2;
 669                 if(delta < 1)
 670                 {
 671                         delta = 1;
 672                 }
 673                 else if(delta > 6)
 674                 {
 675                         delta = 6;
 676                 }
 677                 HealthMarker -= delta;
 678         }
 679         else if(curHealth > HealthMarker)
 680         {
 681                 delta = (curHealth-HealthMarker)>>2;
 682                 if(delta < 1)
 683                 {
 684                         delta = 1;
 685                 }
 686                 else if(delta > 6)
 687                 {
 688                         delta = 6;
 689                 }
 690                 HealthMarker += delta;
 691         }
 692 }
 693
 694 //==========================================================================
 695 //
 696 // DrINumber
 697 //
 698 // Draws a three digit number.
 699 //
 700 //==========================================================================
 701
 702 static void DrINumber(signed int val, int x, int y)
 703 {
 704         PATCH_REF patch;
 705         int oldval;
 706
 707         oldval = val;
 708         if(val < 0)
 709         {
 710                 val = -val;
 711                 if(val > 99)
 712                 {
 713                         val = 99;
 714                 }
 715                 if(val > 9)
 716                 {
 717                         patch = PatchINumbers[val/10];
 718                         V_DrawPatch(x+8, y, patch);
 719                         V_DrawPatch(x, y, PatchNEGATIVE);
 720                 }
 721                 else
 722                 {
 723                         V_DrawPatch(x+8, y, PatchNEGATIVE);
 724                 }
 725                 val = val%10;
 726                 patch = PatchINumbers[val];
 727                 V_DrawPatch(x+16, y, patch);
 728                 return;
 729         }
 730         if(val > 99)
 731         {
 732                 patch = PatchINumbers[val/100];
 733                 V_DrawPatch(x, y, patch);
 734         }
 735         val = val%100;
 736         if(val > 9 || oldval > 99)
 737         {
 738                 patch = PatchINumbers[val/10];
 739                 V_DrawPatch(x+8, y, patch);
 740         }
 741         val = val%10;
 742         patch = PatchINumbers[val];
 743         V_DrawPatch(x+16, y, patch);
 744 }
 745
 746 //==========================================================================
 747 //
 748 // DrRedINumber
 749 //
 750 // Draws a three digit number using the red font
 751 //
 752 //==========================================================================
 753
 754 static void DrRedINumber(signed int val, int x, int y)
 755 {
 756         PATCH_REF patch;
 757         int oldval;
 758
 759         oldval = val;
 760         if(val < 0)
 761         {
 762                 val = 0;
 763         }
 764         if(val > 99)
 765         {
 766                 patch = WR_CacheLumpNum(W_GetNumForName("inred0")+val/100, PU_CACHE);
 767                 V_DrawPatch(x, y, patch);
 768         }
 769         val = val%100;
 770         if(val > 9 || oldval > 99)
 771         {
 772                 patch = WR_CacheLumpNum(W_GetNumForName("inred0")+val/10, PU_CACHE);
 773                 V_DrawPatch(x+8, y, patch);
 774         }
 775         val = val%10;
 776         patch = WR_CacheLumpNum(W_GetNumForName("inred0")+val, PU_CACHE);
 777         V_DrawPatch(x+16, y, patch);
 778 }
 779
 780 //==========================================================================
 781 //
 782 // DrBNumber
 783 //
 784 // Draws a three digit number using FontB
 785 //
 786 //==========================================================================
 787
 788 static void DrBNumber(signed int val, int x, int y)
 789 {
 790         patch_t* patch;
 791         int xpos;
 792         int oldval;
 793
 794         oldval = val;
 795         xpos = x;
 796         if(val < 0)
 797         {
 798                 val = 0;
 799         }
 800         if(val > 99)
 801         {
 802                 patch = W_CacheLumpNum(FontBNumBase+val/100, PU_CACHE);
 803 #ifdef RENDER3D
 804         OGL_DrawShadowedPatch(xpos+6-patch->width/2, y, FontBNumBase+val/100);
 805 #else
 806                 V_DrawShadowedPatch(xpos+6-patch->width/2, y, patch);
 807 #endif
 808         }
 809         val = val%100;
 810         xpos += 12;
 811         if(val > 9 || oldval > 99)
 812         {
 813                 patch = W_CacheLumpNum(FontBNumBase+val/10, PU_CACHE);
 814 #ifdef RENDER3D
 815         OGL_DrawShadowedPatch(xpos+6-patch->width/2, y, FontBNumBase+val/10);
 816 #else
 817                 V_DrawShadowedPatch(xpos+6-patch->width/2, y, patch);
 818 #endif
 819         }
 820         val = val%10;
 821         xpos += 12;
 822         patch = W_CacheLumpNum(FontBNumBase+val, PU_CACHE);
 823 #ifdef RENDER3D
 824     OGL_DrawShadowedPatch(xpos+6-patch->width/2, y, FontBNumBase+val/1);
 825 #else
 826         V_DrawShadowedPatch(xpos+6-patch->width/2, y, patch);
 827 #endif
 828 }
 829
 830 //==========================================================================
 831 //
 832 // DrSmallNumber
 833 //
 834 // Draws a small two digit number.
 835 //
 836 //==========================================================================
 837
 838 static void DrSmallNumber(int val, int x, int y)
 839 {
 840         PATCH_REF patch;
 841
 842         if(val <= 0)
 843         {
 844                 return;
 845         }
 846         if(val > 999)
 847         {
 848                 val %= 1000;
 849         }
 850         if(val > 99)
 851         {
 852                 patch = PatchSmNumbers[val/100];
 853                 V_DrawPatch(x, y, patch);
 854                 patch = PatchSmNumbers[(val%100)/10];
 855                 V_DrawPatch(x+4, y, patch);
 856         }
 857         else if(val > 9)
 858         {
 859                 patch = PatchSmNumbers[val/10];
 860                 V_DrawPatch(x+4, y, patch);
 861         }
 862         val %= 10;
 863         patch = PatchSmNumbers[val];
 864         V_DrawPatch(x+8, y, patch);
 865 }
 866
 867 /*
 868 //==========================================================================
 869 //
 870 // ShadeLine
 871 //
 872 //==========================================================================
 873
 874 static void ShadeLine(int x, int y, int height, int shade)
 875 {
 876         byte *dest;
 877         byte *shades;
 878
 879         shades = colormaps+9*256+shade*2*256;
 880         dest = screen+y*SCREENWIDTH+x;
 881         while(height--)
 882         {
 883                 *(dest) = *(shades+*dest);
 884                 dest += SCREENWIDTH;
 885         }
 886 }
 887
 888 //==========================================================================
 889 //
 890 // ShadeChain
 891 //
 892 //==========================================================================
 893
 894 static void ShadeChain(void)
 895 {
 896         int i;
 897
 898         for(i = 0; i < 16; i++)
 899         {
 900                 ShadeLine(277+i, 190, 10, i/2);
 901                 ShadeLine(19+i, 190, 10, 7-(i/2));
 902         }
 903 }
 904 */
 905
 906 //==========================================================================
 907 //
 908 // DrawSoundInfo
 909 //
 910 // Displays sound debugging information.
 911 //
 912 //==========================================================================
 913
 914 static void DrawSoundInfo(void)
 915 {
 916         int i;
 917         SoundInfo_t s;
 918         ChanInfo_t *c;
 919         char text[32];
 920         int x;
 921         int y;
 922         int xPos[7] = {1, 75, 112, 156, 200, 230, 260};
 923
 924         if(leveltime&16)
 925         {
 926                 MN_DrTextA("*** SOUND DEBUG INFO ***", xPos[0], 20);
 927         }
 928         S_GetChannelInfo(&s);
 929         if(s.channelCount == 0)
 930         {
 931                 return;
 932         }
 933         x = 0;
 934         MN_DrTextA("NAME", xPos[x++], 30);
 935         MN_DrTextA("MO.T", xPos[x++], 30);
 936         MN_DrTextA("MO.X", xPos[x++], 30);
 937         MN_DrTextA("MO.Y", xPos[x++], 30);
 938         MN_DrTextA("ID", xPos[x++], 30);
 939         MN_DrTextA("PRI", xPos[x++], 30);
 940         MN_DrTextA("DIST", xPos[x++], 30);
 941         for(i = 0; i < s.channelCount; i++)
 942         {
 943                 c = &s.chan[i];
 944                 x = 0;
 945                 y = 40+i*10;
 946                 if(c->mo == NULL)
 947                 { // Channel is unused
 948                         MN_DrTextA("------", xPos[0], y);
 949                         continue;
 950                 }
 951                 sprintf(text, "%s", c->name);
 952                 M_ForceUppercase(text);
 953                 MN_DrTextA(text, xPos[x++], y);
 954                 sprintf(text, "%d", c->mo->type);
 955                 MN_DrTextA(text, xPos[x++], y);
 956                 sprintf(text, "%d", c->mo->x>>FRACBITS);
 957                 MN_DrTextA(text, xPos[x++], y);
 958                 sprintf(text, "%d", c->mo->y>>FRACBITS);
 959                 MN_DrTextA(text, xPos[x++], y);
 960                 sprintf(text, "%ld", c->id);    /* jim added 'l' */
 961                 MN_DrTextA(text, xPos[x++], y);
 962                 sprintf(text, "%d", c->priority);
 963                 MN_DrTextA(text, xPos[x++], y);
 964                 sprintf(text, "%d", c->distance);
 965                 MN_DrTextA(text, xPos[x++], y);
 966         }
 967         UpdateState |= I_FULLSCRN;
 968         BorderNeedRefresh = true;
 969 }
 970
 971 //==========================================================================
 972 //
 973 // SB_Drawer
 974 //
 975 //==========================================================================
 976
 977 char patcharti[][10] =
 978 {
 979         { "ARTIBOX" },          // none
 980         { "ARTIINVU" },         // invulnerability
 981         { "ARTIPTN2" },         // health
 982         { "ARTISPHL" },         // superhealth
 983         { "ARTIHRAD" },         // healing radius
 984         { "ARTISUMN" },         // summon maulator
 985         { "ARTITRCH" },         // torch
 986         { "ARTIPORK" },         // egg
 987         { "ARTISOAR" },         // fly
 988         { "ARTIBLST" },         // blast radius
 989         { "ARTIPSBG" },         // poison bag
 990         { "ARTITELO" },         // teleport other
 991         { "ARTISPED" },         // speed
 992         { "ARTIBMAN" },         // boost mana
 993         { "ARTIBRAC" },         // boost armor
 994         { "ARTIATLP" },         // teleport
 995         { "ARTISKLL" },         // arti_puzzskull
 996         { "ARTIBGEM" },         // arti_puzzgembig
 997         { "ARTIGEMR" },         // arti_puzzgemred
 998         { "ARTIGEMG" },         // arti_puzzgemgreen1
 999         { "ARTIGMG2" },         // arti_puzzgemgreen2
1000         { "ARTIGEMB" },         // arti_puzzgemblue1
1001         { "ARTIGMB2" },         // arti_puzzgemblue2
1002         { "ARTIBOK1" },         // arti_puzzbook1
1003         { "ARTIBOK2" },         // arti_puzzbook2
1004         { "ARTISKL2" },         // arti_puzzskull2
1005         { "ARTIFWEP" },         // arti_puzzfweapon
1006         { "ARTICWEP" },         // arti_puzzcweapon
1007         { "ARTIMWEP" },         // arti_puzzmweapon
1008         { "ARTIGEAR" },         // arti_puzzgear1
1009         { "ARTIGER2" },         // arti_puzzgear2
1010         { "ARTIGER3" },         // arti_puzzgear3
1011         { "ARTIGER4" },         // arti_puzzgear4
1012 };
1013
1014 int SB_state = -1;
1015 #ifndef RENDER3D
1016 static int oldfrags = -9999;
1017 static int oldmana1 = -1;
1018 static int oldmana2 = -1;
1019 static int oldhealth = -1;
1020 static int oldlife = -1;
1021 static int oldpieces = -1;
1022 static int oldweapon = -1;
1023 #endif
1024 static int oldarti = 0;
1025 static int oldartiCount = 0;
1026 static int oldkeys = -1;
1027 static int oldarmor = -1;
1028
1029 extern boolean automapactive;
1030
1031 void SB_Drawer(void)
1032 {
1033         // Sound info debug stuff
1034         if(DebugSound == true)
1035         {
1036                 DrawSoundInfo();
1037         }
1038         CPlayer = &players[consoleplayer];
1039         if(viewheight == SCREENHEIGHT && !automapactive)
1040         {
1041                 DrawFullScreenStuff();
1042                 SB_state = -1;
1043         }
1044         else
1045         {
1046 #ifndef RENDER3D
1047                 if(SB_state == -1)
1048                 {
1049 #endif
1050                         V_DrawPatch(0, 134, PatchH2BAR);
1051 #ifndef RENDER3D
1052                         oldhealth = -1;
1053                 }
1054 #endif
1055                 DrawCommonBar();
1056
1057                 if(!inventory)
1058                 {
1059 #ifndef RENDER3D
1060                         if(SB_state != 0)
1061                         {
1062 #endif
1063                                 // Main interface
1064                                 if(!automapactive)
1065                                 {
1066                                         V_DrawPatch(38, 162, PatchSTATBAR);
1067                                 }
1068                                 else
1069                                 {
1070                                         V_DrawPatch(38, 162, PatchKEYBAR);
1071                                 }
1072 #ifndef RENDER3D
1073                                 oldarti = 0;
1074                                 oldmana1 = -1;
1075                                 oldmana2 = -1;
1076                                 oldarmor = -1;
1077                                 oldpieces = -1;
1078                                 oldfrags = -9999; //can't use -1, 'cuz of negative frags
1079                                 oldlife = -1;
1080                                 oldweapon = -1;
1081                                 oldkeys = -1;
1082                         }
1083 #endif
1084                         if(!automapactive)
1085                         {
1086                                 DrawMainBar();
1087                         }
1088                         else
1089                         {
1090                                 DrawKeyBar();
1091                         }
1092                         SB_state = 0;
1093                 }
1094                 else
1095                 {
1096                         DrawInventoryBar();
1097                         SB_state = 1;
1098                 }
1099         }
1100         SB_PaletteFlash(false);
1101         DrawAnimatedIcons();
1102 }
1103
1104 //==========================================================================
1105 //
1106 // DrawAnimatedIcons
1107 //
1108 //==========================================================================
1109
1110 static void DrawAnimatedIcons(void)
1111 {
1112         int frame;
1113         static boolean hitCenterFrame;
1114
1115         // Wings of wrath
1116         if(CPlayer->powers[pw_flight])
1117         {
1118                 if(CPlayer->powers[pw_flight] > BLINKTHRESHOLD
1119                         || !(CPlayer->powers[pw_flight]&16))
1120                 {
1121                         frame = (leveltime/3)&15;
1122                         if(CPlayer->mo->flags2&MF2_FLY)
1123                         {
1124                                 if(hitCenterFrame && (frame != 15 && frame != 0))
1125                                 {
1126                                         V_DrawPatch(20, 19, WR_CacheLumpNum(SpinFlylump+15,
1127                                                 PU_CACHE));
1128                                 }
1129                                 else
1130                                 {
1131                                         V_DrawPatch(20, 19, WR_CacheLumpNum(SpinFlylump+frame,
1132                                                 PU_CACHE));
1133                                         hitCenterFrame = false;
1134                                 }
1135                         }
1136                         else
1137                         {
1138                                 if(!hitCenterFrame && (frame != 15 && frame != 0))
1139                                 {
1140                                         V_DrawPatch(20, 19, WR_CacheLumpNum(SpinFlylump+frame,
1141                                                 PU_CACHE));
1142                                         hitCenterFrame = false;
1143                                 }
1144                                 else
1145                                 {
1146                                         V_DrawPatch(20, 19, WR_CacheLumpNum(SpinFlylump+15,
1147                                                 PU_CACHE));
1148                                         hitCenterFrame = true;
1149                                 }
1150                         }
1151                 }
1152                 BorderTopRefresh = true;
1153                 UpdateState |= I_MESSAGES;
1154         }
1155
1156         // Speed Boots
1157         if(CPlayer->powers[pw_speed])
1158         {
1159                 if(CPlayer->powers[pw_speed] > BLINKTHRESHOLD
1160                         || !(CPlayer->powers[pw_speed]&16))
1161                 {
1162                         frame = (leveltime/3)&15;
1163                         V_DrawPatch(60, 19, WR_CacheLumpNum(SpinSpeedLump+frame,
1164                                 PU_CACHE));
1165                 }
1166                 BorderTopRefresh = true;
1167                 UpdateState |= I_MESSAGES;
1168         }
1169
1170         // Defensive power
1171         if(CPlayer->powers[pw_invulnerability])
1172         {
1173                 if(CPlayer->powers[pw_invulnerability] > BLINKTHRESHOLD
1174                         || !(CPlayer->powers[pw_invulnerability]&16))
1175                 {
1176                         frame = (leveltime/3)&15;
1177                         V_DrawPatch(260, 19, WR_CacheLumpNum(SpinDefenseLump+frame,
1178                                 PU_CACHE));
1179                 }
1180                 BorderTopRefresh = true;
1181                 UpdateState |= I_MESSAGES;
1182         }
1183
1184         // Minotaur Active
1185         if(CPlayer->powers[pw_minotaur])
1186         {
1187                 if(CPlayer->powers[pw_minotaur] > BLINKTHRESHOLD
1188                         || !(CPlayer->powers[pw_minotaur]&16))
1189                 {
1190                         frame = (leveltime/3)&15;
1191                         V_DrawPatch(300, 19, WR_CacheLumpNum(SpinMinotaurLump+frame,
1192                                 PU_CACHE));
1193                 }
1194                 BorderTopRefresh = true;
1195                 UpdateState |= I_MESSAGES;
1196         }
1197 }
1198
1199 //==========================================================================
1200 //
1201 // SB_PaletteFlash
1202 //
1203 // Sets the new palette based upon the current values of
1204 // consoleplayer->damagecount and consoleplayer->bonuscount.
1205 //
1206 //==========================================================================
1207
1208 void SB_PaletteFlash(boolean forceChange)
1209 {
1210         static int sb_palette = 0;
1211         int palette;
1212
1213 #ifndef RENDER3D
1214         byte *pal;
1215 #endif
1216         if(forceChange)
1217         {
1218                 sb_palette = -1;
1219         }
1220         if(gamestate == GS_LEVEL)
1221         {
1222                 CPlayer = &players[consoleplayer];
1223                 if(CPlayer->poisoncount)
1224                 {
1225                         palette = 0;
1226                         palette = (CPlayer->poisoncount+7)>>3;
1227                         if(palette >= NUMPOISONPALS)
1228                         {
1229                                 palette = NUMPOISONPALS-1;
1230                         }
1231                         palette += STARTPOISONPALS;
1232                 }
1233                 else if(CPlayer->damagecount)
1234                 {
1235                         palette = (CPlayer->damagecount+7)>>3;
1236                         if(palette >= NUMREDPALS)
1237                         {
1238                                 palette = NUMREDPALS-1;
1239                         }
1240                         palette += STARTREDPALS;
1241                 }
1242                 else if(CPlayer->bonuscount)
1243                 {
1244                         palette = (CPlayer->bonuscount+7)>>3;
1245                         if(palette >= NUMBONUSPALS)
1246                         {
1247                                 palette = NUMBONUSPALS-1;
1248                         }
1249                         palette += STARTBONUSPALS;
1250                 }
1251                 else if(CPlayer->mo->flags2&MF2_ICEDAMAGE)
1252                 { // Frozen player
1253                         palette = STARTICEPAL;
1254                 }
1255                 else
1256                 {
1257                         palette = 0;
1258                 }
1259         }
1260         else
1261         {
1262                 palette = 0;
1263         }
1264         if(palette != sb_palette)
1265         {
1266                 sb_palette = palette;
1267 #ifdef RENDER3D
1268         OGL_SetFilter( palette );
1269 #else
1270                 pal = (byte *)WR_CacheLumpNum(PlayPalette, PU_CACHE)+palette*768;
1271                 I_SetPalette(pal);
1272 #endif
1273         }
1274 }
1275
1276 //==========================================================================
1277 //
1278 // DrawCommonBar
1279 //
1280 //==========================================================================
1281
1282 void DrawCommonBar(void)
1283 {
1284         int healthPos;
1285
1286 #ifndef RENDER3D
1287         V_DrawPatch(0, 134, PatchH2TOP);
1288
1289         if(oldhealth != HealthMarker)
1290         {
1291                 oldhealth = HealthMarker;
1292 #endif
1293                 healthPos = HealthMarker;
1294                 if(healthPos < 0)
1295                 {
1296                         healthPos = 0;
1297                 }
1298                 if(healthPos > 100)
1299                 {
1300                         healthPos = 100;
1301                 }
1302                 V_DrawPatch(28+(((healthPos*196)/100)%9), 193, PatchCHAIN);
1303                 V_DrawPatch(7+((healthPos*11)/5), 193, PatchLIFEGEM);
1304                 V_DrawPatch(0, 193, PatchLFEDGE);
1305                 V_DrawPatch(277, 193, PatchRTEDGE);
1306 //              ShadeChain();
1307 #ifndef RENDER3D
1308                 UpdateState |= I_STATBAR;
1309         }
1310 #endif
1311 }
1312
1313 //==========================================================================
1314 //
1315 // DrawMainBar
1316 //
1317 //==========================================================================
1318
1319 void DrawMainBar(void)
1320 {
1321         int i;
1322         int temp;
1323         PATCH_REF manaPatch1;
1324         PATCH_REF manaPatch2;
1325         PATCH_REF manaVialPatch1;
1326         PATCH_REF manaVialPatch2;
1327
1328         manaPatch1 = INVALID_PATCH;
1329         manaPatch2 = INVALID_PATCH;
1330         manaVialPatch1 = INVALID_PATCH;
1331         manaVialPatch2 = INVALID_PATCH;
1332
1333         // Ready artifact
1334         if(ArtifactFlash)
1335         {
1336 #ifndef RENDER3D
1337                 V_DrawPatch(144, 160, PatchARTICLEAR);
1338 #endif
1339                 V_DrawPatch(148, 164, WR_CacheLumpNum(W_GetNumForName("useartia")
1340                         + ArtifactFlash - 1, PU_CACHE));
1341                 ArtifactFlash--;
1342                 oldarti = -1; // so that the correct artifact fills in after the flash
1343                 UpdateState |= I_STATBAR;
1344         }
1345         else if(oldarti != CPlayer->readyArtifact
1346                 || oldartiCount != CPlayer->inventory[inv_ptr].count)
1347         {
1348 #ifndef RENDER3D
1349                 V_DrawPatch(144, 160, PatchARTICLEAR);
1350 #endif
1351                 if(CPlayer->readyArtifact > 0)
1352                 {
1353                         V_DrawPatch(143, 163,
1354                                 W_CacheLumpName(patcharti[CPlayer->readyArtifact], PU_CACHE));
1355                         if(CPlayer->inventory[inv_ptr].count > 1)
1356                         {
1357                                 DrSmallNumber(CPlayer->inventory[inv_ptr].count, 162, 184);
1358                         }
1359                 }
1360 #ifndef RENDER3D
1361                 oldarti = CPlayer->readyArtifact;
1362                 oldartiCount = CPlayer->inventory[inv_ptr].count;
1363                 UpdateState |= I_STATBAR;
1364 #endif
1365         }
1366
1367         // Frags
1368         if(deathmatch)
1369         {
1370                 temp = 0;
1371                 for(i = 0; i < MAXPLAYERS; i++)
1372                 {
1373                         temp += CPlayer->frags[i];
1374                 }
1375 #ifndef RENDER3D
1376                 if(temp != oldfrags)
1377                 {
1378 #endif
1379                         V_DrawPatch(38, 162, PatchKILLS);
1380                         DrINumber(temp, 40, 176);
1381 #ifndef RENDER3D
1382                         oldfrags = temp;
1383                         UpdateState |= I_STATBAR;
1384                 }
1385 #endif
1386         }
1387         else
1388         {
1389                 temp = HealthMarker;
1390                 if(temp < 0)
1391                 {
1392                         temp = 0;
1393                 }
1394                 else if(temp > 100)
1395                 {
1396                         temp = 100;
1397                 }
1398 #ifndef RENDER3D
1399                 if(oldlife != temp)
1400                 {
1401                         oldlife = temp;
1402 #endif
1403                         V_DrawPatch(41, 178, PatchARMCLEAR);
1404                         if(temp >= 25)
1405                         {
1406                                 DrINumber(temp, 40, 176);
1407                         }
1408                         else
1409                         {
1410                                 DrRedINumber(temp, 40, 176);
1411                         }
1412 #ifndef RENDER3D
1413                         UpdateState |= I_STATBAR;
1414                 }
1415 #endif
1416         }
1417         // Mana
1418         temp = CPlayer->mana[0];
1419 #ifndef RENDER3D
1420         if(oldmana1 != temp)
1421         {
1422 #endif
1423                 V_DrawPatch(77, 178, PatchMANACLEAR);
1424                 DrSmallNumber(temp, 79, 181);
1425 #ifndef RENDER3D
1426                 manaVialPatch1 = (patch_t *)1; // force a vial update
1427 #endif
1428                 if(temp == 0)
1429                 { // Draw Dim Mana icon
1430                         manaPatch1 = PatchMANADIM1;
1431                 }
1432 #ifndef RENDER3D
1433                 else if(oldmana1 == 0)
1434                 {
1435                         manaPatch1 = PatchMANABRIGHT1;
1436                 }
1437                 oldmana1 = temp;
1438                 UpdateState |= I_STATBAR;
1439         }
1440 #endif
1441         temp = CPlayer->mana[1];
1442 #ifndef RENDER3D
1443         if(oldmana2 != temp)
1444         {
1445 #endif
1446                 V_DrawPatch(109, 178, PatchMANACLEAR);
1447                 DrSmallNumber(temp, 111, 181);
1448 #ifndef RENDER3D
1449                 manaVialPatch1 = (patch_t *)1; // force a vial update
1450 #endif
1451                 if(temp == 0)
1452                 { // Draw Dim Mana icon
1453                         manaPatch2 = PatchMANADIM2;
1454                 }
1455 #ifndef RENDER3D
1456                 else if(oldmana2 == 0)
1457                 {
1458                         manaPatch2 = PatchMANABRIGHT2;
1459                 }
1460                 oldmana2 = temp;
1461                 UpdateState |= I_STATBAR;
1462         }
1463 #endif
1464 #ifndef RENDER3D
1465         if(oldweapon != CPlayer->readyweapon || manaPatch1 || manaPatch2
1466                 || manaVialPatch1)
1467         { // Update mana graphics based upon mana count/weapon type
1468 #endif
1469                 if(CPlayer->readyweapon == WP_FIRST)
1470                 {
1471                         manaPatch1 = PatchMANADIM1;
1472                         manaPatch2 = PatchMANADIM2;
1473                         manaVialPatch1 = PatchMANAVIALDIM1;
1474                         manaVialPatch2 = PatchMANAVIALDIM2;
1475                 }
1476                 else if(CPlayer->readyweapon == WP_SECOND)
1477                 {
1478                         if(!manaPatch1)
1479                         {
1480                                 manaPatch1 = PatchMANABRIGHT1;
1481                         }
1482                         manaVialPatch1 = PatchMANAVIAL1;
1483                         manaPatch2 = PatchMANADIM2;
1484                         manaVialPatch2 = PatchMANAVIALDIM2;
1485                 }
1486                 else if(CPlayer->readyweapon == WP_THIRD)
1487                 {
1488                         manaPatch1 = PatchMANADIM1;
1489                         manaVialPatch1 = PatchMANAVIALDIM1;
1490                         if(!manaPatch2)
1491                         {
1492                                 manaPatch2 = PatchMANABRIGHT2;
1493                         }
1494                         manaVialPatch2 = PatchMANAVIAL2;
1495                 }
1496                 else
1497                 {
1498                         manaVialPatch1 = PatchMANAVIAL1;
1499                         manaVialPatch2 = PatchMANAVIAL2;
1500                         if(!manaPatch1)
1501                         {
1502                                 manaPatch1 = PatchMANABRIGHT1;
1503                         }
1504                         if(!manaPatch2)
1505                         {
1506                                 manaPatch2 = PatchMANABRIGHT2;
1507                         }
1508                 }
1509                 V_DrawPatch(77, 164, manaPatch1);
1510                 V_DrawPatch(110, 164, manaPatch2);
1511                 V_DrawPatch(94, 164, manaVialPatch1);
1512 #ifndef RENDER3D
1513                 for(i = 165; i < 187-(22*CPlayer->mana[0])/MAX_MANA; i++)
1514                 {
1515                         screen[i*SCREENWIDTH+95] = 0;
1516                         screen[i*SCREENWIDTH+96] = 0;
1517                         screen[i*SCREENWIDTH+97] = 0;
1518                 }
1519 #endif
1520                 V_DrawPatch(102, 164, manaVialPatch2);
1521 #ifndef RENDER3D
1522                 for(i = 165; i < 187-(22*CPlayer->mana[1])/MAX_MANA; i++)
1523                 {
1524                         screen[i*SCREENWIDTH+103] = 0;
1525                         screen[i*SCREENWIDTH+104] = 0;
1526                         screen[i*SCREENWIDTH+105] = 0;
1527                 }
1528                 oldweapon = CPlayer->readyweapon;
1529                 UpdateState |= I_STATBAR;
1530         }
1531 #endif
1532
1533         // Armor
1534         temp = AutoArmorSave[CPlayer->class]
1535                 +CPlayer->armorpoints[ARMOR_ARMOR]+CPlayer->armorpoints[ARMOR_SHIELD]
1536                 +CPlayer->armorpoints[ARMOR_HELMET]+CPlayer->armorpoints[ARMOR_AMULET];
1537 #ifndef RENDER3D
1538         if(oldarmor != temp)
1539         {
1540                 oldarmor = temp;
1541 #endif
1542                 V_DrawPatch(255, 178, PatchARMCLEAR);
1543                 DrINumber(FixedDiv(temp, 5*FRACUNIT)>>FRACBITS, 250, 176);
1544 #ifndef RENDER3D
1545                 UpdateState |= I_STATBAR;
1546         }
1547 #endif
1548
1549         // Weapon Pieces
1550 #ifndef RENDER3D
1551         if(oldpieces != CPlayer->pieces)
1552         {
1553 #endif
1554                 DrawWeaponPieces();
1555 #ifndef RENDER3D
1556                 oldpieces = CPlayer->pieces;
1557                 UpdateState |= I_STATBAR;
1558         }
1559 #endif
1560 }
1561
1562 //==========================================================================
1563 //
1564 // DrawInventoryBar
1565 //
1566 //==========================================================================
1567
1568 void DrawInventoryBar(void)
1569 {
1570         int i;
1571         int x;
1572
1573         x = inv_ptr-curpos;
1574         UpdateState |= I_STATBAR;
1575         V_DrawPatch(38, 162, PatchINVBAR);
1576         for(i = 0; i < 7; i++)
1577         {
1578                 //V_DrawPatch(50+i*31, 160, W_CacheLumpName("ARTIBOX", PU_CACHE));
1579                 if(CPlayer->inventorySlotNum > x+i
1580                         && CPlayer->inventory[x+i].type != arti_none)
1581                 {
1582                         V_DrawPatch(50+i*31, 163, W_CacheLumpName(
1583                                 patcharti[CPlayer->inventory[x+i].type], PU_CACHE));
1584                         if(CPlayer->inventory[x+i].count > 1)
1585                         {
1586                                 DrSmallNumber(CPlayer->inventory[x+i].count, 68+i*31, 185);
1587                         }
1588                 }
1589         }
1590         V_DrawPatch(50+curpos*31, 163, PatchSELECTBOX);
1591         if(x != 0)
1592         {
1593                 V_DrawPatch(42, 163, !(leveltime&4) ? PatchINVLFGEM1 :
1594                         PatchINVLFGEM2);
1595         }
1596         if(CPlayer->inventorySlotNum-x > 7)
1597         {
1598                 V_DrawPatch(269, 163, !(leveltime&4) ? PatchINVRTGEM1 :
1599                         PatchINVRTGEM2);
1600         }
1601 }
1602
1603 //==========================================================================
1604 //
1605 // DrawKeyBar
1606 //
1607 //==========================================================================
1608
1609 void DrawKeyBar(void)
1610 {
1611         int i;
1612         int xPosition;
1613         int temp;
1614
1615 #ifdef RENDER3D
1616         if(oldkeys != CPlayer->keys)
1617         {
1618 #endif
1619                 xPosition = 46;
1620                 for(i = 0; i < NUMKEYS && xPosition <= 126; i++)
1621                 {
1622                         if(CPlayer->keys&(1<<i))
1623                         {
1624                                 V_DrawPatch(xPosition, 164,
1625                                         WR_CacheLumpNum(W_GetNumForName("keyslot1")+i, PU_CACHE));
1626                                 xPosition += 20;
1627                         }
1628                 }
1629 #ifdef RENDER3D
1630                 oldkeys = CPlayer->keys;
1631                 UpdateState |= I_STATBAR;
1632         }
1633 #endif
1634         temp = AutoArmorSave[CPlayer->class]
1635                 +CPlayer->armorpoints[ARMOR_ARMOR]+CPlayer->armorpoints[ARMOR_SHIELD]
1636                 +CPlayer->armorpoints[ARMOR_HELMET]+CPlayer->armorpoints[ARMOR_AMULET];
1637 #ifdef RENDER3D
1638         if(oldarmor != temp)
1639         {
1640 #endif
1641                 for(i = 0; i < NUMARMOR; i++)
1642                 {
1643                         if(!CPlayer->armorpoints[i])
1644                         {
1645                                 continue;
1646                         }
1647                         if(CPlayer->armorpoints[i] <=
1648                                 (ArmorIncrement[CPlayer->class][i]>>2))
1649                         {
1650                                 V_DrawFuzzPatch(150+31*i, 164,
1651                                         WR_CacheLumpNum(W_GetNumForName("armslot1")+i, PU_CACHE));
1652                         }
1653                         else if(CPlayer->armorpoints[i] <=
1654                                 (ArmorIncrement[CPlayer->class][i]>>1))
1655                         {
1656                                 V_DrawAltFuzzPatch(150+31*i, 164,
1657                                         WR_CacheLumpNum(W_GetNumForName("armslot1")+i, PU_CACHE));
1658                         }
1659                         else
1660                         {
1661                                 V_DrawPatch(150+31*i, 164,
1662                                         WR_CacheLumpNum(W_GetNumForName("armslot1")+i, PU_CACHE));
1663                         }
1664                 }
1665 #ifdef RENDER3D
1666                 oldarmor = temp;
1667                 UpdateState |= I_STATBAR;
1668         }
1669 #endif
1670 }
1671
1672 //==========================================================================
1673 //
1674 // DrawWeaponPieces
1675 //
1676 //==========================================================================
1677
1678 static int PieceX[NUMCLASSES][3] =
1679 {
1680         { 190, 225, 234 },
1681         { 190, 212, 225 },
1682         { 190, 205, 224 },
1683         { 190, 205, 224 },              // Use mage xpositions for now
1684         { 0, 0, 0 }                     // Pig is never used
1685 };
1686
1687 static void DrawWeaponPieces(void)
1688 {
1689         if(CPlayer->pieces == 7)
1690         {
1691                 V_DrawPatch(190, 162, PatchWEAPONFULL);
1692                 return;
1693         }
1694         V_DrawPatch(190, 162, PatchWEAPONSLOT);
1695         if(CPlayer->pieces&WPIECE1)
1696         {
1697                 V_DrawPatch(PieceX[PlayerClass[consoleplayer]][0], 162, PatchPIECE1);
1698         }
1699         if(CPlayer->pieces&WPIECE2)
1700         {
1701                 V_DrawPatch(PieceX[PlayerClass[consoleplayer]][1], 162, PatchPIECE2);
1702         }
1703         if(CPlayer->pieces&WPIECE3)
1704         {
1705                 V_DrawPatch(PieceX[PlayerClass[consoleplayer]][2], 162, PatchPIECE3);
1706         }
1707 }
1708
1709 //==========================================================================
1710 //
1711 // DrawFullScreenStuff
1712 //
1713 //==========================================================================
1714
1715 void DrawFullScreenStuff(void)
1716 {
1717         int i;
1718         int x;
1719         int temp;
1720
1721         UpdateState |= I_FULLSCRN;
1722         if(CPlayer->mo->health > 0)
1723         {
1724                 DrBNumber(CPlayer->mo->health, 5, 180);
1725         }
1726         else
1727         {
1728                 DrBNumber(0, 5, 180);
1729         }
1730         if(deathmatch)
1731         {
1732                 temp = 0;
1733                 for(i=0; i<MAXPLAYERS; i++)
1734                 {
1735                         if(playeringame[i])
1736                         {
1737                                 temp += CPlayer->frags[i];
1738                         }
1739                 }
1740                 DrINumber(temp, 45, 185);
1741         }
1742         if(!inventory)
1743         {
1744                 if(CPlayer->readyArtifact > 0)
1745                 {
1746                         V_DrawFuzzPatch(286, 170, W_CacheLumpName("ARTIBOX",
1747                                 PU_CACHE));
1748                         V_DrawPatch(284, 169,
1749                                 W_CacheLumpName(patcharti[CPlayer->readyArtifact], PU_CACHE));
1750                         if(CPlayer->inventory[inv_ptr].count > 1)
1751                         {
1752                                 DrSmallNumber(CPlayer->inventory[inv_ptr].count, 302, 192);
1753                         }
1754                 }
1755         }
1756         else
1757         {
1758                 x = inv_ptr-curpos;
1759                 for(i = 0; i < 7; i++)
1760                 {
1761                         V_DrawFuzzPatch(50+i*31, 168, W_CacheLumpName("ARTIBOX",
1762                                 PU_CACHE));
1763                         if(CPlayer->inventorySlotNum > x+i
1764                                 && CPlayer->inventory[x+i].type != arti_none)
1765                         {
1766                                 V_DrawPatch(49+i*31, 167, W_CacheLumpName(
1767                                         patcharti[CPlayer->inventory[x+i].type], PU_CACHE));
1768                                 if(CPlayer->inventory[x+i].count > 1)
1769                                 {
1770                                         DrSmallNumber(CPlayer->inventory[x+i].count, 66+i*31,
1771                                                 188);
1772                                 }
1773                         }
1774                 }
1775                 V_DrawPatch(50+curpos*31, 167, PatchSELECTBOX);
1776                 if(x != 0)
1777                 {
1778                         V_DrawPatch(40, 167, !(leveltime&4) ? PatchINVLFGEM1 :
1779                                 PatchINVLFGEM2);
1780                 }
1781                 if(CPlayer->inventorySlotNum-x > 7)
1782                 {
1783                         V_DrawPatch(268, 167, !(leveltime&4) ?
1784                                 PatchINVRTGEM1 : PatchINVRTGEM2);
1785                 }
1786         }
1787 }
1788
1789
1790 //==========================================================================
1791 //
1792 // Draw_TeleportIcon
1793 //
1794 //==========================================================================
1795 void Draw_TeleportIcon(void)
1796 {
1797         PATCH_REF patch;
1798         patch = WR_CacheLumpNum(W_GetNumForName("teleicon"), PU_CACHE);
1799         V_DrawPatch(100, 68, patch);
1800         UpdateState |= I_FULLSCRN;
1801         I_Update();
1802         UpdateState |= I_FULLSCRN;
1803 }
1804
1805 //==========================================================================
1806 //
1807 // Draw_SaveIcon
1808 //
1809 //==========================================================================
1810 void Draw_SaveIcon(void)
1811 {
1812         PATCH_REF patch;
1813         patch = WR_CacheLumpNum(W_GetNumForName("saveicon"), PU_CACHE);
1814         V_DrawPatch(100, 68, patch);
1815         UpdateState |= I_FULLSCRN;
1816         I_Update();
1817         UpdateState |= I_FULLSCRN;
1818 }
1819
1820 //==========================================================================
1821 //
1822 // Draw_LoadIcon
1823 //
1824 //==========================================================================
1825 void Draw_LoadIcon(void)
1826 {
1827         PATCH_REF patch;
1828         patch = WR_CacheLumpNum(W_GetNumForName("loadicon"), PU_CACHE);
1829         V_DrawPatch(100, 68, patch);
1830         UpdateState |= I_FULLSCRN;
1831         I_Update();
1832         UpdateState |= I_FULLSCRN;
1833 }
1834
1835
1836
1837 //==========================================================================
1838 //
1839 // SB_Responder
1840 //
1841 //==========================================================================
1842
1843 boolean SB_Responder(event_t *event)
1844 {
1845         if(event->type == ev_keydown)
1846         {
1847                 if(HandleCheats(event->data1))
1848                 { // Need to eat the key
1849                         return(true);
1850                 }
1851         }
1852         return(false);
1853 }
1854
1855 //==========================================================================
1856 //
1857 // HandleCheats
1858 //
1859 // Returns true if the caller should eat the key.
1860 //
1861 //==========================================================================
1862
1863 static boolean HandleCheats(byte key)
1864 {
1865         int i;
1866         boolean eat;
1867
1868         if(gameskill == sk_nightmare)
1869         { // Can't cheat in nightmare mode
1870                 return(false);
1871         }
1872         else if(netgame)
1873         { // change CD track is the only cheat available in deathmatch
1874                 eat = false;
1875                 if(i_CDMusic)
1876                 {
1877                         if(CheatAddKey(&Cheats[0], key, &eat))
1878                         {
1879                                 Cheats[0].func(&players[consoleplayer], &Cheats[0]);
1880                                 S_StartSound(NULL, SFX_PLATFORM_STOP);
1881                         }
1882                         if(CheatAddKey(&Cheats[1], key, &eat))
1883                         {
1884                                 Cheats[1].func(&players[consoleplayer], &Cheats[1]);
1885                                 S_StartSound(NULL, SFX_PLATFORM_STOP);
1886                         }
1887                 }
1888                 return eat;
1889         }
1890         if(players[consoleplayer].health <= 0)
1891         { // Dead players can't cheat
1892                 return(false);
1893         }
1894         eat = false;
1895         for(i = 0; Cheats[i].func != NULL; i++)
1896         {
1897                 if(CheatAddKey(&Cheats[i], key, &eat))
1898                 {
1899                         Cheats[i].func(&players[consoleplayer], &Cheats[i]);
1900                         S_StartSound(NULL, SFX_PLATFORM_STOP);
1901                 }
1902         }
1903         return(eat);
1904 }
1905
1906 //==========================================================================
1907 //
1908 // CheatAddkey
1909 //
1910 // Returns true if the added key completed the cheat, false otherwise.
1911 //
1912 //==========================================================================
1913
1914 static boolean CheatAddKey(Cheat_t *cheat, byte key, boolean *eat)
1915 {
1916         if(!cheat->pos)
1917         {
1918                 cheat->pos = cheat->sequence;
1919                 cheat->currentArg = 0;
1920         }
1921         if(*cheat->pos == 0)
1922         {
1923                 *eat = true;
1924                 cheat->args[cheat->currentArg++] = key;
1925                 cheat->pos++;
1926         }
1927         else if(CheatLookup[key] == *cheat->pos)
1928         {
1929                 cheat->pos++;
1930         }
1931         else
1932         {
1933                 cheat->pos = cheat->sequence;
1934                 cheat->currentArg = 0;
1935         }
1936         if(*cheat->pos == 0xff)
1937         {
1938                 cheat->pos = cheat->sequence;
1939                 cheat->currentArg = 0;
1940                 return(true);
1941         }
1942         return(false);
1943 }
1944
1945 //==========================================================================
1946 //
1947 // CHEAT FUNCTIONS
1948 //
1949 //==========================================================================
1950
1951 static void CheatGodFunc(player_t *player, Cheat_t *cheat)
1952 {
1953         player->cheats ^= CF_GODMODE;
1954         if(player->cheats&CF_GODMODE)
1955         {
1956                 P_SetMessage(player, TXT_CHEATGODON, true);
1957         }
1958         else
1959         {
1960                 P_SetMessage(player, TXT_CHEATGODOFF, true);
1961         }
1962         SB_state = -1;
1963 }
1964
1965 static void CheatNoClipFunc(player_t *player, Cheat_t *cheat)
1966 {
1967         player->cheats ^= CF_NOCLIP;
1968         if(player->cheats&CF_NOCLIP)
1969         {
1970                 P_SetMessage(player, TXT_CHEATNOCLIPON, true);
1971         }
1972         else
1973         {
1974                 P_SetMessage(player, TXT_CHEATNOCLIPOFF, true);
1975         }
1976 }
1977
1978 static void CheatWeaponsFunc(player_t *player, Cheat_t *cheat)
1979 {
1980         int i;
1981         //extern boolean *WeaponInShareware;
1982
1983         for(i = 0; i < NUMARMOR; i++)
1984         {
1985                 player->armorpoints[i] = ArmorIncrement[player->class][i];
1986         }
1987         for(i = 0; i < NUMWEAPONS; i++)
1988         {
1989                 player->weaponowned[i] = true;
1990         }
1991         for(i = 0; i < NUMMANA; i++)
1992         {
1993                 player->mana[i] = MAX_MANA;
1994         }
1995         P_SetMessage(player, TXT_CHEATWEAPONS, true);
1996 }
1997
1998 static void CheatHealthFunc(player_t *player, Cheat_t *cheat)
1999 {
2000         if(player->morphTics)
2001         {
2002                 player->health = player->mo->health = MAXMORPHHEALTH;
2003         }
2004         else
2005         {
2006                 player->health = player->mo->health = MAXHEALTH;
2007         }
2008         P_SetMessage(player, TXT_CHEATHEALTH, true);
2009 }
2010
2011 static void CheatKeysFunc(player_t *player, Cheat_t *cheat)
2012 {
2013         player->keys = 2047;
2014         P_SetMessage(player, TXT_CHEATKEYS, true);
2015 }
2016
2017 static void CheatSoundFunc(player_t *player, Cheat_t *cheat)
2018 {
2019         DebugSound = !DebugSound;
2020         if(DebugSound)
2021         {
2022                 P_SetMessage(player, TXT_CHEATSOUNDON, true);
2023         }
2024         else
2025         {
2026                 P_SetMessage(player, TXT_CHEATSOUNDOFF, true);
2027         }
2028 }
2029
2030 static void CheatTickerFunc(player_t *player, Cheat_t *cheat)
2031 {
2032         extern int DisplayTicker;
2033
2034         DisplayTicker = !DisplayTicker;
2035         if(DisplayTicker)
2036         {
2037                 P_SetMessage(player, TXT_CHEATTICKERON, true);
2038         }
2039         else
2040         {
2041                 P_SetMessage(player, TXT_CHEATTICKEROFF, true);
2042         }
2043 }
2044
2045 static void CheatArtifactAllFunc(player_t *player, Cheat_t *cheat)
2046 {
2047         int i;
2048         int j;
2049
2050         for(i = arti_none+1; i < arti_firstpuzzitem; i++)
2051         {
2052                 for(j = 0; j < 25; j++)
2053                 {
2054                         P_GiveArtifact(player, i, NULL);
2055                 }
2056         }
2057         P_SetMessage(player, TXT_CHEATARTIFACTS3, true);
2058 }
2059
2060 static void CheatPuzzleFunc(player_t *player, Cheat_t *cheat)
2061 {
2062         int i;
2063
2064         for(i = arti_firstpuzzitem; i < NUMARTIFACTS; i++)
2065         {
2066                 P_GiveArtifact(player, i, NULL);
2067         }
2068         P_SetMessage(player, TXT_CHEATARTIFACTS3, true);
2069 }
2070
2071 static void CheatInitFunc(player_t *player, Cheat_t *cheat)
2072 {
2073         G_DeferedInitNew(gameskill, gameepisode, gamemap);
2074         P_SetMessage(player, TXT_CHEATWARP, true);
2075 }
2076
2077 static void CheatWarpFunc(player_t *player, Cheat_t *cheat)
2078 {
2079         int tens;
2080         int ones;
2081         int map;
2082         char mapName[9];
2083         char auxName[128];
2084         FILE *fp;
2085
2086         tens = cheat->args[0]-'0';
2087         ones = cheat->args[1]-'0';
2088         if(tens < 0 || tens > 9 || ones < 0 || ones > 9)
2089         { // Bad map
2090                 P_SetMessage(player, TXT_CHEATBADINPUT, true);
2091                 return;
2092         }
2093         map = P_TranslateMap((cheat->args[0]-'0')*10+cheat->args[1]-'0');
2094         if(map == -1)
2095         { // Not found
2096                 P_SetMessage(player, TXT_CHEATNOMAP, true);
2097                 return;
2098         }
2099         if(map == gamemap)
2100         { // Don't try to teleport to current map
2101                 P_SetMessage(player, TXT_CHEATBADINPUT, true);
2102                 return;
2103         }
2104         if(DevMaps)
2105         { // Search map development directory
2106                 sprintf(auxName, "%sMAP%02d.WAD", DevMapsDir, map);
2107                 fp = fopen(auxName, "rb");
2108                 if(fp)
2109                 {
2110                         fclose(fp);
2111                 }
2112                 else
2113                 { // Can't find
2114                         P_SetMessage(player, TXT_CHEATNOMAP, true);
2115                         return;
2116                 }
2117         }
2118         else
2119         { // Search primary lumps
2120                 sprintf(mapName, "MAP%02d", map);
2121                 if(W_CheckNumForName(mapName) == -1)
2122                 { // Can't find
2123                         P_SetMessage(player, TXT_CHEATNOMAP, true);
2124                         return;
2125                 }
2126         }
2127         P_SetMessage(player, TXT_CHEATWARP, true);
2128         G_TeleportNewMap(map, 0);
2129 }
2130
2131 static void CheatPigFunc(player_t *player, Cheat_t *cheat)
2132 {
2133         extern boolean P_UndoPlayerMorph(player_t *player);
2134
2135         if(player->morphTics)
2136         {
2137                 P_UndoPlayerMorph(player);
2138         }
2139         else
2140         {
2141                 P_MorphPlayer(player);
2142         }
2143         P_SetMessage(player, "SQUEAL!!", true);
2144 }
2145
2146 static void CheatMassacreFunc(player_t *player, Cheat_t *cheat)
2147 {
2148         int count;
2149         char buffer[80];
2150
2151         count = P_Massacre();
2152         sprintf(buffer, "%d MONSTERS KILLED\n", count);
2153         P_SetMessage(player, buffer, true);
2154 }
2155
2156 static void CheatIDKFAFunc(player_t *player, Cheat_t *cheat)
2157 {
2158         int i;
2159         if(player->morphTics)
2160         {
2161                 return;
2162         }
2163         for(i = 1; i < 8; i++)
2164         {
2165                 player->weaponowned[i] = false;
2166         }
2167         player->pendingweapon = WP_FIRST;
2168         P_SetMessage(player, TXT_CHEATIDKFA, true);
2169 }
2170
2171 static void CheatQuickenFunc1(player_t *player, Cheat_t *cheat)
2172 {
2173         P_SetMessage(player, "TRYING TO CHEAT?  THAT'S ONE....", true);
2174 }
2175
2176 static void CheatQuickenFunc2(player_t *player, Cheat_t *cheat)
2177 {
2178         P_SetMessage(player, "THAT'S TWO....", true);
2179 }
2180
2181 static void CheatQuickenFunc3(player_t *player, Cheat_t *cheat)
2182 {
2183         P_DamageMobj(player->mo, NULL, player->mo, 10000);
2184         P_SetMessage(player, "THAT'S THREE!  TIME TO DIE.", true);
2185 }
2186
2187 static void CheatClassFunc1(player_t *player, Cheat_t *cheat)
2188 {
2189 #ifdef ASSASSIN
2190         P_SetMessage(player, "ENTER NEW PLAYER CLASS (0 - 3)", true);
2191 #else
2192         P_SetMessage(player, "ENTER NEW PLAYER CLASS (0 - 2)", true);
2193 #endif
2194 }
2195
2196 static void CheatClassFunc2(player_t *player, Cheat_t *cheat)
2197 {
2198         int i;
2199         int class;
2200
2201         if(player->morphTics)
2202         { // don't change class if the player is morphed
2203                 return;
2204         }
2205         class = cheat->args[0]-'0';
2206 #ifdef ASSASSIN
2207         if(class > 3 || class < 0)
2208 #else
2209         if(class > 2 || class < 0)
2210 #endif
2211         {
2212                 P_SetMessage(player, "INVALID PLAYER CLASS", true);
2213                 return;
2214         }
2215         player->class = class;
2216         for(i = 0; i < NUMARMOR; i++)
2217         {
2218                 player->armorpoints[i] = 0;
2219         }
2220         PlayerClass[consoleplayer] = class;
2221         P_PostMorphWeapon(player, WP_FIRST);
2222         SB_SetClassData();
2223         SB_state = -1;
2224         UpdateState |= I_FULLSCRN;
2225 }
2226
2227 static void CheatVersionFunc(player_t *player, Cheat_t *cheat)
2228 {
2229         P_SetMessage(player, VERSIONTEXT, true);
2230 }
2231
2232 static void CheatDebugFunc(player_t *player, Cheat_t *cheat)
2233 {
2234         char textBuffer[50];
2235         sprintf(textBuffer, "MAP %d (%d)  X:%5d  Y:%5d  Z:%5d",
2236                                 P_GetMapWarpTrans(gamemap),
2237                                 gamemap,
2238                                 player->mo->x >> FRACBITS,
2239                                 player->mo->y >> FRACBITS,
2240                                 player->mo->z >> FRACBITS);
2241         P_SetMessage(player, textBuffer, true);
2242 }
2243
2244 static void CheatScriptFunc1(player_t *player, Cheat_t *cheat)
2245 {
2246         P_SetMessage(player, "RUN WHICH SCRIPT(01-99)?", true);
2247 }
2248
2249 static void CheatScriptFunc2(player_t *player, Cheat_t *cheat)
2250 {
2251         P_SetMessage(player, "RUN WHICH SCRIPT(01-99)?", true);
2252 }
2253
2254 static void CheatScriptFunc3(player_t *player, Cheat_t *cheat)
2255 {
2256         int script;
2257         byte args[3];
2258         int tens, ones;
2259         char textBuffer[40];
2260
2261         tens = cheat->args[0]-'0';
2262         ones = cheat->args[1]-'0';
2263         script = tens*10 + ones;
2264         if (script < 1) return;
2265         if (script > 99) return;
2266         args[0]=args[1]=args[2]=0;
2267
2268         if(P_StartACS(script, 0, args, player->mo, NULL, 0))
2269         {
2270                 sprintf(textBuffer, "RUNNING SCRIPT %.2d", script);
2271                 P_SetMessage(player, textBuffer, true);
2272         }
2273 }
2274
2275 extern int cheating;
2276
2277 static void CheatRevealFunc(player_t *player, Cheat_t *cheat)
2278 {
2279         cheating = (cheating+1) % 3;
2280 }
2281
2282 //===========================================================================
2283 //
2284 // CheatTrackFunc1
2285 //
2286 //===========================================================================
2287
2288 static void CheatTrackFunc1(player_t *player, Cheat_t *cheat)
2289 {
2290         char buffer[80];
2291
2292         if(!i_CDMusic)
2293         {
2294                 return;
2295         }
2296         if(I_CDMusInit() == -1)
2297         {
2298                 P_SetMessage(player, "ERROR INITIALIZING CD", true);
2299         }
2300         sprintf(buffer, "ENTER DESIRED CD TRACK (%.2d - %.2d):\n",
2301                 I_CDMusFirstTrack(), I_CDMusLastTrack());
2302         P_SetMessage(player, buffer, true);
2303 }
2304
2305 //===========================================================================
2306 //
2307 // CheatTrackFunc2
2308 //
2309 //===========================================================================
2310
2311 static void CheatTrackFunc2(player_t *player, Cheat_t *cheat)
2312 {
2313         char buffer[80];
2314         int track;
2315
2316         if(!i_CDMusic)
2317         {
2318                 return;
2319         }
2320         track = (cheat->args[0]-'0')*10+(cheat->args[1]-'0');
2321         if(track < I_CDMusFirstTrack() || track > I_CDMusLastTrack())
2322         {
2323                 P_SetMessage(player, "INVALID TRACK NUMBER\n", true);
2324                 return;
2325         }
2326         if(track == i_CDCurrentTrack)
2327         {
2328                 return;
2329         }
2330         if(I_CDMusPlay(track))
2331         {
2332                 sprintf(buffer, "ERROR WHILE TRYING TO PLAY CD TRACK: %.2d\n", track);
2333                 P_SetMessage(player, buffer, true);
2334         }
2335         else
2336         { // No error encountered while attempting to play the track
2337                 sprintf(buffer, "PLAYING TRACK: %.2d\n", track);
2338                 P_SetMessage(player, buffer, true);
2339 //              i_CDMusicLength = 35*I_CDMusTrackLength(track);
2340 //              oldTic = gametic;
2341                 i_CDTrack = track;
2342                 i_CDCurrentTrack = track;
2343         }
2344 }
2345