Patch #2969 - Doom! Currently only working on the H300.

git-svn-id: svn://svn.rockbox.org/rockbox/trunk@9312 a1c6a512-1295-4272-9138-f99709370657

1 files changed, 1153 insertions, 0 deletions

diff --git a/apps/plugins/doom/st_stuff.c b/apps/plugins/doom/st_stuff.c
new file mode 100644
index 0000000..5d9244d
--- /dev/null
+++ b/apps/plugins/doom/st_stuff.c
@@ -0,0 +1,1153 @@
+/* Emacs style mode select   -*- C++ -*-
+ *-----------------------------------------------------------------------------
+ *
+ *
+ *  PrBoom a Doom port merged with LxDoom and LSDLDoom
+ *  based on BOOM, a modified and improved DOOM engine
+ *  Copyright (C) 1999 by
+ *  id Software, Chi Hoang, Lee Killough, Jim Flynn, Rand Phares, Ty Halderman
+ *  Copyright (C) 1999-2000 by
+ *  Jess Haas, Nicolas Kalkhof, Colin Phipps, Florian Schulze
+ *
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License
+ *  as published by the Free Software Foundation; either version 2
+ *  of the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ *  02111-1307, USA.
+ *
+ * DESCRIPTION:
+ *      Status bar code.
+ *      Does the face/direction indicator animatin.
+ *      Does palette indicators as well (red pain/berserk, bright pickup)
+ *
+ *-----------------------------------------------------------------------------*/
+
+#include "doomdef.h"
+#include "doomstat.h"
+#include "m_random.h"
+#include "i_video.h"
+#include "w_wad.h"
+#include "st_stuff.h"
+#include "st_lib.h"
+#include "r_main.h"
+#include "am_map.h"
+#include "m_cheat.h"
+#include "s_sound.h"
+#include "sounds.h"
+#include "dstrings.h"
+#include "r_draw.h"
+
+//
+// STATUS BAR DATA
+//
+
+// Palette indices.
+// For damage/bonus red-/gold-shifts
+#define STARTREDPALS            1
+#define STARTBONUSPALS          9
+#define NUMREDPALS              8
+#define NUMBONUSPALS            4
+// Radiation suit, green shift.
+#define RADIATIONPAL            13
+
+// Location of status bar
+#define ST_X                    0
+#define ST_X2                   104
+
+// proff 08/18/98: Changed for high-res
+#define ST_FX                   (ST_X+143)
+#define ST_FY                   (ST_Y+1)
+//#define ST_FX                   143
+//#define ST_FY                   169
+
+// Should be set to patch width
+//  for tall numbers later on
+#define ST_TALLNUMWIDTH         (tallnum[0]->width)
+
+// Number of status faces.
+#define ST_NUMPAINFACES         5
+#define ST_NUMSTRAIGHTFACES     3
+#define ST_NUMTURNFACES         2
+#define ST_NUMSPECIALFACES      3
+
+#define ST_FACESTRIDE \
+          (ST_NUMSTRAIGHTFACES+ST_NUMTURNFACES+ST_NUMSPECIALFACES)
+
+#define ST_NUMEXTRAFACES        2
+
+#define ST_NUMFACES \
+          (ST_FACESTRIDE*ST_NUMPAINFACES+ST_NUMEXTRAFACES)
+
+#define ST_TURNOFFSET           (ST_NUMSTRAIGHTFACES)
+#define ST_OUCHOFFSET           (ST_TURNOFFSET + ST_NUMTURNFACES)
+#define ST_EVILGRINOFFSET       (ST_OUCHOFFSET + 1)
+#define ST_RAMPAGEOFFSET        (ST_EVILGRINOFFSET + 1)
+#define ST_GODFACE              (ST_NUMPAINFACES*ST_FACESTRIDE)
+#define ST_DEADFACE             (ST_GODFACE+1)
+
+// proff 08/18/98: Changed for high-res
+#define ST_FACESX               (ST_X+143)
+#define ST_FACESY               (ST_Y)
+//#define ST_FACESX               143
+//#define ST_FACESY               168
+
+#define ST_EVILGRINCOUNT        (2*TICRATE)
+#define ST_STRAIGHTFACECOUNT    (TICRATE/2)
+#define ST_TURNCOUNT            (1*TICRATE)
+#define ST_OUCHCOUNT            (1*TICRATE)
+#define ST_RAMPAGEDELAY         (2*TICRATE)
+
+#define ST_MUCHPAIN             20
+
+// Location and size of statistics,
+//  justified according to widget type.
+// Problem is, within which space? STbar? Screen?
+// Note: this could be read in by a lump.
+//       Problem is, is the stuff rendered
+//       into a buffer,
+//       or into the frame buffer?
+// I dunno, why don't you go and find out!!!  killough
+
+// AMMO number pos.
+#define ST_AMMOWIDTH            3
+// proff 08/18/98: Changed for high-res
+#define ST_AMMOX                (ST_X+44)
+#define ST_AMMOY                (ST_Y+3)
+//#define ST_AMMOX                44
+//#define ST_AMMOY                171
+
+// HEALTH number pos.
+#define ST_HEALTHWIDTH          3
+// proff 08/18/98: Changed for high-res
+#define ST_HEALTHX              (ST_X+90)
+#define ST_HEALTHY              (ST_Y+3)
+//#define ST_HEALTHX              90
+//#define ST_HEALTHY              171
+
+// Weapon pos.
+// proff 08/18/98: Changed for high-res
+#define ST_ARMSX                (ST_X+111)
+#define ST_ARMSY                (ST_Y+4)
+#define ST_ARMSBGX              (ST_X+104)
+#define ST_ARMSBGY              (ST_Y)
+//#define ST_ARMSX                111
+//#define ST_ARMSY                172
+//#define ST_ARMSBGX              104
+//#define ST_ARMSBGY              168
+#define ST_ARMSXSPACE           12
+#define ST_ARMSYSPACE           10
+
+// Frags pos.
+// proff 08/18/98: Changed for high-res
+#define ST_FRAGSX               (ST_X+138)
+#define ST_FRAGSY               (ST_Y+3)
+//#define ST_FRAGSX               138
+//#define ST_FRAGSY               171
+#define ST_FRAGSWIDTH           2
+
+// ARMOR number pos.
+#define ST_ARMORWIDTH           3
+// proff 08/18/98: Changed for high-res
+#define ST_ARMORX               (ST_X+221)
+#define ST_ARMORY               (ST_Y+3)
+//#define ST_ARMORX               221
+//#define ST_ARMORY               171
+
+// Key icon positions.
+#define ST_KEY0WIDTH            8
+#define ST_KEY0HEIGHT           5
+// proff 08/18/98: Changed for high-res
+#define ST_KEY0X                (ST_X+239)
+#define ST_KEY0Y                (ST_Y+3)
+//#define ST_KEY0X                239
+//#define ST_KEY0Y                171
+#define ST_KEY1WIDTH            ST_KEY0WIDTH
+// proff 08/18/98: Changed for high-res
+#define ST_KEY1X                (ST_X+239)
+#define ST_KEY1Y                (ST_Y+13)
+//#define ST_KEY1X                239
+//#define ST_KEY1Y                181
+#define ST_KEY2WIDTH            ST_KEY0WIDTH
+// proff 08/18/98: Changed for high-res
+#define ST_KEY2X                (ST_X+239)
+#define ST_KEY2Y                (ST_Y+23)
+//#define ST_KEY2X                239
+//#define ST_KEY2Y                191
+
+// Ammunition counter.
+#define ST_AMMO0WIDTH           3
+#define ST_AMMO0HEIGHT          6
+// proff 08/18/98: Changed for high-res
+#define ST_AMMO0X               (ST_X+288)
+#define ST_AMMO0Y               (ST_Y+5)
+//#define ST_AMMO0X               288
+//#define ST_AMMO0Y               173
+#define ST_AMMO1WIDTH           ST_AMMO0WIDTH
+// proff 08/18/98: Changed for high-res
+#define ST_AMMO1X               (ST_X+288)
+#define ST_AMMO1Y               (ST_Y+11)
+//#define ST_AMMO1X               288
+//#define ST_AMMO1Y               179
+#define ST_AMMO2WIDTH           ST_AMMO0WIDTH
+// proff 08/18/98: Changed for high-res
+#define ST_AMMO2X               (ST_X+288)
+#define ST_AMMO2Y               (ST_Y+23)
+//#define ST_AMMO2X               288
+//#define ST_AMMO2Y               191
+#define ST_AMMO3WIDTH           ST_AMMO0WIDTH
+// proff 08/18/98: Changed for high-res
+#define ST_AMMO3X               (ST_X+288)
+#define ST_AMMO3Y               (ST_Y+17)
+//#define ST_AMMO3X               288
+//#define ST_AMMO3Y               185
+
+// Indicate maximum ammunition.
+// Only needed because backpack exists.
+#define ST_MAXAMMO0WIDTH        3
+#define ST_MAXAMMO0HEIGHT       5
+// proff 08/18/98: Changed for high-res
+#define ST_MAXAMMO0X            (ST_X+314)
+#define ST_MAXAMMO0Y            (ST_Y+5)
+//#define ST_MAXAMMO0X            314
+//#define ST_MAXAMMO0Y            173
+#define ST_MAXAMMO1WIDTH        ST_MAXAMMO0WIDTH
+// proff 08/18/98: Changed for high-res
+#define ST_MAXAMMO1X            (ST_X+314)
+#define ST_MAXAMMO1Y            (ST_Y+11)
+//#define ST_MAXAMMO1X            314
+//#define ST_MAXAMMO1Y            179
+#define ST_MAXAMMO2WIDTH        ST_MAXAMMO0WIDTH
+// proff 08/18/98: Changed for high-res
+#define ST_MAXAMMO2X            (ST_X+314)
+#define ST_MAXAMMO2Y            (ST_Y+23)
+//#define ST_MAXAMMO2X            314
+//#define ST_MAXAMMO2Y            191
+#define ST_MAXAMMO3WIDTH        ST_MAXAMMO0WIDTH
+// proff 08/18/98: Changed for high-res
+#define ST_MAXAMMO3X            (ST_X+314)
+#define ST_MAXAMMO3Y            (ST_Y+17)
+//#define ST_MAXAMMO3X            314
+//#define ST_MAXAMMO3Y            185
+
+// killough 2/8/98: weapon info position macros UNUSED, removed here
+
+// main player in game
+static player_t *plyr;
+
+// ST_Start() has just been called
+static boolean st_firsttime;
+
+// used to execute ST_Init() only once
+static int veryfirsttime = 1;
+
+// CPhipps - no longer do direct PLAYPAL handling here
+
+// used for timing
+static unsigned int st_clock;
+
+// used for making messages go away
+static int st_msgcounter=0;
+
+// used when in chat
+static st_chatstateenum_t st_chatstate;
+
+// whether in automap or first-person
+static st_stateenum_t st_gamestate;
+
+// whether left-side main status bar is active
+static boolean st_statusbaron;
+
+// whether status bar chat is active
+static boolean st_chat;
+
+// value of st_chat before message popped up
+static boolean st_oldchat;
+
+// whether chat window has the cursor on
+static boolean st_cursoron;
+
+// !deathmatch
+static boolean st_notdeathmatch;
+
+// !deathmatch && st_statusbaron
+static boolean st_armson;
+
+// !deathmatch
+static boolean st_fragson;
+
+// main bar left
+// CPhipps - convert to a bitmap
+static byte *sbar;
+static unsigned short sbar_width, sbar_height;
+
+// 0-9, tall numbers
+static patchnum_t tallnum[10];
+
+// tall % sign
+static patchnum_t tallpercent;
+
+// 0-9, short, yellow (,different!) numbers
+static patchnum_t shortnum[10];
+
+// 3 key-cards, 3 skulls, 3 card/skull combos
+// jff 2/24/98 extend number of patches by three skull/card combos
+static patchnum_t keys[NUMCARDS+3];
+
+// face status patches
+static patchnum_t faces[ST_NUMFACES];
+
+// face background
+static patchnum_t faceback; // CPhipps - single background, translated for different players
+
+// main bar right
+static patchnum_t armsbg;
+
+// weapon ownership patches
+static patchnum_t arms[6][2];
+
+// ready-weapon widget
+static st_number_t w_ready;
+
+//jff 2/16/98 status color change levels
+int ammo_red;      // ammo percent less than which status is red
+int ammo_yellow;   // ammo percent less is yellow more green
+int health_red;    // health amount less than which status is red
+int health_yellow; // health amount less than which status is yellow
+int health_green;  // health amount above is blue, below is green
+int armor_red;     // armor amount less than which status is red
+int armor_yellow;  // armor amount less than which status is yellow
+int armor_green;   // armor amount above is blue, below is green
+
+// in deathmatch only, summary of frags stats
+static st_number_t w_frags;
+
+// health widget
+static st_percent_t w_health;
+
+// arms background
+static st_binicon_t  w_armsbg;
+
+// weapon ownership widgets
+static st_multicon_t w_arms[6];
+
+// face status widget
+static st_multicon_t w_faces;
+
+// keycard widgets
+static st_multicon_t w_keyboxes[3];
+
+// armor widget
+static st_percent_t  w_armor;
+
+// ammo widgets
+static st_number_t   w_ammo[4];
+
+// max ammo widgets
+static st_number_t   w_maxammo[4];
+
+// number of frags so far in deathmatch
+static int      st_fragscount;
+
+// used to use appopriately pained face
+static int      st_oldhealth = -1;
+
+// used for evil grin
+static boolean  oldweaponsowned[NUMWEAPONS];
+
+// count until face changes
+static int      st_facecount = 0;
+
+// current face index, used by w_faces
+static int      st_faceindex = 0;
+
+// holds key-type for each key box on bar
+static int      keyboxes[3];
+
+// a random number per tick
+static int      st_randomnumber;
+
+extern char     *mapnames[];
+
+
+//
+// STATUS BAR CODE
+//
+void ST_Stop(void);
+
+void ST_refreshBackground(void)
+{
+   int y=0;
+   int screen=BG;
+
+   if (st_statusbaron)
+   {
+      V_DrawNamePatch(ST_X, y, screen, "STBAR", CR_DEFAULT, VPT_STRETCH);
+
+      // killough 3/7/98: make face background change with displayplayer
+      if (netgame)
+      {
+         V_DrawNumPatch(ST_FX, y, BG, faceback.lumpnum,
+                        displayplayer ? CR_LIMIT+displayplayer : CR_DEFAULT,
+                        displayplayer ? (VPT_TRANS | VPT_STRETCH) : VPT_STRETCH);
+      }
+
+      V_CopyRect(ST_X, y, screen, ST_SCALED_WIDTH, ST_SCALED_HEIGHT, ST_X, ST_SCALED_Y, FG, VPT_NONE);
+   }
+}
+
+
+// Respond to keyboard input events,
+//  intercept cheats.
+boolean ST_Responder(event_t *ev)
+{
+   // Filter automap on/off.
+   if (ev->type == ev_keyup && (ev->data1 & 0xffff0000) == AM_MSGHEADER)
+   {
+      switch(ev->data1)
+      {
+      case AM_MSGENTERED:
+         st_gamestate = AutomapState;
+         st_firsttime = true;
+         break;
+
+      case AM_MSGEXITED:
+         st_gamestate = FirstPersonState;
+         break;
+      }
+   }
+//   else  // if a user keypress...
+//      if (ev->type == ev_keydown)       // Try cheat responder in m_cheat.c
+//         return M_FindCheats(ev->data1); // killough 4/17/98, 5/2/98
+   return false;
+}
+
+int ST_calcPainOffset(void)
+{
+   static int lastcalc;
+   static int oldhealth = -1;
+   int health = plyr->health > 100 ? 100 : plyr->health;
+
+   if (health != oldhealth)
+   {
+      lastcalc = ST_FACESTRIDE * (((100 - health) * ST_NUMPAINFACES) / 101);
+      oldhealth = health;
+   }
+   return lastcalc;
+}
+
+
+//
+// This is a not-very-pretty routine which handles
+//  the face states and their timing.
+// the precedence of expressions is:
+//  dead > evil grin > turned head > straight ahead
+//
+
+void ST_updateFaceWidget(void)
+{
+   int         i;
+   angle_t     badguyangle;
+   angle_t     diffang;
+   static int  lastattackdown = -1;
+   static int  priority = 0;
+   boolean     doevilgrin;
+
+   if (priority < 10)
+   {
+      // dead
+      if (!plyr->health)
+      {
+         priority = 9;
+         st_faceindex = ST_DEADFACE;
+         st_facecount = 1;
+      }
+   }
+
+   if (priority < 9)
+   {
+      if (plyr->bonuscount)
+      {
+         // picking up bonus
+         doevilgrin = false;
+
+         for (i=0;i<NUMWEAPONS;i++)
+         {
+            if (oldweaponsowned[i] != plyr->weaponowned[i])
+            {
+               doevilgrin = true;
+               oldweaponsowned[i] = plyr->weaponowned[i];
+            }
+         }
+         if (doevilgrin)
+         {
+            // evil grin if just picked up weapon
+            priority = 8;
+            st_facecount = ST_EVILGRINCOUNT;
+            st_faceindex = ST_calcPainOffset() + ST_EVILGRINOFFSET;
+         }
+      }
+
+   }
+
+   if (priority < 8)
+   {
+      if (plyr->damagecount && plyr->attacker && plyr->attacker != plyr->mo)
+      {
+         // being attacked
+         priority = 7;
+
+         if (plyr->health - st_oldhealth > ST_MUCHPAIN)
+         {
+            st_facecount = ST_TURNCOUNT;
+            st_faceindex = ST_calcPainOffset() + ST_OUCHOFFSET;
+         }
+         else
+         {
+            badguyangle = R_PointToAngle2(plyr->mo->x,
+                                          plyr->mo->y,
+                                          plyr->attacker->x,
+                                          plyr->attacker->y);
+
+            if (badguyangle > plyr->mo->angle)
+            {
+               // whether right or left
+               diffang = badguyangle - plyr->mo->angle;
+               i = diffang > ANG180;
+            }
+            else
+            {
+               // whether left or right
+               diffang = plyr->mo->angle - badguyangle;
+               i = diffang <= ANG180;
+            } // confusing, aint it?
+
+
+            st_facecount = ST_TURNCOUNT;
+            st_faceindex = ST_calcPainOffset();
+
+            if (diffang < ANG45)
+            {
+               // head-on
+               st_faceindex += ST_RAMPAGEOFFSET;
+            }
+            else if (i)
+            {
+               // turn face right
+               st_faceindex += ST_TURNOFFSET;
+            }
+            else
+            {
+               // turn face left
+               st_faceindex += ST_TURNOFFSET+1;
+            }
+         }
+      }
+   }
+
+   if (priority < 7)
+   {
+      // getting hurt because of your own damn stupidity
+      if (plyr->damagecount)
+      {
+         if (plyr->health - st_oldhealth > ST_MUCHPAIN)
+         {
+            priority = 7;
+            st_facecount = ST_TURNCOUNT;
+            st_faceindex = ST_calcPainOffset() + ST_OUCHOFFSET;
+         }
+         else
+         {
+            priority = 6;
+            st_facecount = ST_TURNCOUNT;
+            st_faceindex = ST_calcPainOffset() + ST_RAMPAGEOFFSET;
+         }
+
+      }
+
+   }
+
+   if (priority < 6)
+   {
+      // rapid firing
+      if (plyr->attackdown)
+      {
+         if (lastattackdown==-1)
+            lastattackdown = ST_RAMPAGEDELAY;
+         else if (!--lastattackdown)
+         {
+            priority = 5;
+            st_faceindex = ST_calcPainOffset() + ST_RAMPAGEOFFSET;
+            st_facecount = 1;
+            lastattackdown = 1;
+         }
+      }
+      else
+         lastattackdown = -1;
+
+   }
+
+   if (priority < 5)
+   {
+      // invulnerability
+      if ((plyr->cheats & CF_GODMODE)
+            || plyr->powers[pw_invulnerability])
+      {
+         priority = 4;
+
+         st_faceindex = ST_GODFACE;
+         st_facecount = 1;
+
+      }
+
+   }
+
+   // look left or look right if the facecount has timed out
+   if (!st_facecount)
+   {
+      st_faceindex = ST_calcPainOffset() + (st_randomnumber % 3);
+      st_facecount = ST_STRAIGHTFACECOUNT;
+      priority = 0;
+   }
+
+   st_facecount--;
+
+}
+
+int sts_traditional_keys; // killough 2/28/98: traditional status bar keys
+
+void ST_updateWidgets(void)
+{
+   static int  largeammo = 1994; // means "n/a"
+   int         i;
+
+   // must redirect the pointer if the ready weapon has changed.
+   //  if (w_ready.data != plyr->readyweapon)
+   //  {
+   if (weaponinfo[plyr->readyweapon].ammo == am_noammo)
+      w_ready.num = &largeammo;
+   else
+      w_ready.num = &plyr->ammo[weaponinfo[plyr->readyweapon].ammo];
+   //{
+   // static int tic=0;
+   // static int dir=-1;
+   // if (!(tic&15))
+   //   plyr->ammo[weaponinfo[plyr->readyweapon].ammo]+=dir;
+   // if (plyr->ammo[weaponinfo[plyr->readyweapon].ammo] == -100)
+   //   dir = 1;
+   // tic++;
+   // }
+   w_ready.data = plyr->readyweapon;
+
+   // if (*w_ready.on)
+   //  STlib_updateNum(&w_ready, true);
+   // refresh weapon change
+   //  }
+
+   // update keycard multiple widgets
+   for (i=0;i<3;i++)
+   {
+      keyboxes[i] = plyr->cards[i] ? i : -1;
+
+      //jff 2/24/98 select double key
+      //killough 2/28/98: preserve traditional keys by config option
+
+      if (plyr->cards[i+3])
+         keyboxes[i] = keyboxes[i]==-1 || sts_traditional_keys ? i+3 : i+6;
+   }
+
+   // refresh everything if this is him coming back to life
+   ST_updateFaceWidget();
+
+   // used by the w_armsbg widget
+   st_notdeathmatch = !deathmatch;
+
+   // used by w_arms[] widgets
+   st_armson = st_statusbaron && !deathmatch;
+
+   // used by w_frags widget
+   st_fragson = deathmatch && st_statusbaron;
+   st_fragscount = 0;
+
+   for (i=0 ; i<MAXPLAYERS ; i++)
+   {
+      if (i != displayplayer)            // killough 3/7/98
+         st_fragscount += plyr->frags[i];
+      else
+         st_fragscount -= plyr->frags[i];
+   }
+
+   // get rid of chat window if up because of message
+   if (!--st_msgcounter)
+      st_chat = st_oldchat;
+
+}
+
+void ST_Ticker (void)
+{
+   st_clock++;
+   st_randomnumber = M_Random();
+   ST_updateWidgets();
+   st_oldhealth = plyr->health;
+}
+
+static int st_palette = 0;
+
+void ST_doPaletteStuff(void)
+{
+   int         palette;
+   int cnt = plyr->damagecount;
+
+   if (plyr->powers[pw_strength])
+   {
+      // slowly fade the berzerk out
+      int bzc = 12 - (plyr->powers[pw_strength]>>6);
+      if (bzc > cnt)
+         cnt = bzc;
+   }
+
+   if (cnt)
+   {
+      palette = (cnt+7)>>3;
+      if (palette >= NUMREDPALS)
+         palette = NUMREDPALS-1;
+      palette += STARTREDPALS;
+   }
+   else
+      if (plyr->bonuscount)
+      {
+         palette = (plyr->bonuscount+7)>>3;
+         if (palette >= NUMBONUSPALS)
+            palette = NUMBONUSPALS-1;
+         palette += STARTBONUSPALS;
+      }
+      else
+         if (plyr->powers[pw_ironfeet] > 4*32 || plyr->powers[pw_ironfeet] & 8)
+            palette = RADIATIONPAL;
+         else
+            palette = 0;
+
+   if (palette != st_palette)
+      V_SetPalette(st_palette = palette); // CPhipps - use new palette function
+}
+
+void ST_drawWidgets(boolean refresh)
+{
+   int  i;
+
+   // used by w_arms[] widgets
+   st_armson = st_statusbaron && !deathmatch;
+
+   // used by w_frags widget
+   st_fragson = deathmatch && st_statusbaron;
+
+   //jff 2/16/98 make color of ammo depend on amount
+   if (*w_ready.num*100 < ammo_red*plyr->maxammo[weaponinfo[w_ready.data].ammo])
+      STlib_updateNum(&w_ready, CR_RED, refresh);
+   else
+      if (*w_ready.num*100 <
+            ammo_yellow*plyr->maxammo[weaponinfo[w_ready.data].ammo])
+         STlib_updateNum(&w_ready, CR_GOLD, refresh);
+      else
+         STlib_updateNum(&w_ready, CR_GREEN, refresh);
+
+   for (i=0;i<4;i++)
+   {
+      STlib_updateNum(&w_ammo[i], CR_DEFAULT, refresh);
+      STlib_updateNum(&w_maxammo[i], CR_DEFAULT, refresh);
+   }
+
+   //jff 2/16/98 make color of health depend on amount
+   if (*w_health.n.num<health_red)
+      STlib_updatePercent(&w_health, CR_RED, refresh);
+   else if (*w_health.n.num<health_yellow)
+      STlib_updatePercent(&w_health, CR_GOLD, refresh);
+   else if (*w_health.n.num<=health_green)
+      STlib_updatePercent(&w_health, CR_GREEN, refresh);
+   else
+      STlib_updatePercent(&w_health, CR_BLUE2, refresh); //killough 2/28/98
+
+   //jff 2/16/98 make color of armor depend on amount
+   if (*w_armor.n.num<armor_red)
+      STlib_updatePercent(&w_armor, CR_RED, refresh);
+   else if (*w_armor.n.num<armor_yellow)
+      STlib_updatePercent(&w_armor, CR_GOLD, refresh);
+   else if (*w_armor.n.num<=armor_green)
+      STlib_updatePercent(&w_armor, CR_GREEN, refresh);
+   else
+      STlib_updatePercent(&w_armor, CR_BLUE2, refresh); //killough 2/28/98
+
+   STlib_updateBinIcon(&w_armsbg, refresh);
+
+   for (i=0;i<6;i++)
+      STlib_updateMultIcon(&w_arms[i], refresh);
+
+   STlib_updateMultIcon(&w_faces, refresh);
+
+   for (i=0;i<3;i++)
+      STlib_updateMultIcon(&w_keyboxes[i], refresh);
+
+   STlib_updateNum(&w_frags, CR_DEFAULT, refresh);
+
+}
+
+void ST_doRefresh(void)
+{
+
+   st_firsttime = false;
+
+   // draw status bar background to off-screen buff
+   ST_refreshBackground();
+
+   // and refresh all widgets
+   ST_drawWidgets(true);
+
+}
+
+void ST_diffDraw(void)
+{
+   // update all widgets
+   ST_drawWidgets(false);
+}
+
+void ST_Drawer(boolean st_statusbaron, boolean refresh)
+{
+   /* cph - let status bar on be controlled
+    * completely by the call from D_Display
+    * proff - really do it
+    */
+   st_firsttime = st_firsttime || refresh;
+
+   ST_doPaletteStuff();  // Do red-/gold-shifts from damage/items
+
+   if (st_statusbaron) {
+      if (st_firsttime)
+         ST_doRefresh();     /* If just after ST_Start(), refresh all */
+      else
+         ST_diffDraw();      /* Otherwise, update as little as possible */
+   }
+}
+
+//
+// ST_loadGraphics
+//
+// CPhipps - Loads graphics needed for status bar if doload is true,
+//  unloads them otherwise
+//
+static void ST_loadGraphics(boolean doload)
+{
+
+   int  i,facenum;
+
+   char namebuf[9];
+   // cph - macro that either acquires a pointer and lock for a lump, or
+   // unlocks it. var is referenced exactly once in either case, so ++ in arg works
+   /*
+   #define LOADORFREE(var,name) \
+   if (!doload) { W_UnlockLumpName(name); var = NULL; } \
+   else var = (const patch_t*)W_CacheLumpName(name)
+   */
+
+   // Load the numbers, tall and short
+   for (i=0;i<10;i++)
+   {
+      snprintf(namebuf, sizeof(namebuf),"STTNUM%d", i);
+      R_SetPatchNum(&tallnum[i],namebuf);
+
+      snprintf(namebuf, sizeof(namebuf),"STYSNUM%d", i);
+      R_SetPatchNum(&shortnum[i],namebuf);
+   }
+
+   // Load percent key.
+   R_SetPatchNum(&tallpercent,"STTPRCNT");
+
+   // key cards
+   for (i=0;i<NUMCARDS+3;i++)  //jff 2/23/98 show both keys too
+   {
+      snprintf(namebuf, sizeof(namebuf), "STKEYS%d", i);
+      R_SetPatchNum(&keys[i], namebuf);
+   }
+
+   // arms background
+   R_SetPatchNum(&armsbg, "STARMS");
+
+   // arms ownership widgets
+   for (i=0;i<6;i++)
+   {
+      snprintf(namebuf, sizeof(namebuf),"STGNUM%d", i+2);
+      // gray #
+      R_SetPatchNum(&arms[i][0], namebuf);
+
+      // yellow #
+      arms[i][1] = shortnum[i+2];
+   }
+
+   // face backgrounds for different color players
+   // killough 3/7/98: add better support for spy mode by loading all
+   // player face backgrounds and using displayplayer to choose them:
+   R_SetPatchNum(&faceback, "STFB0");
+
+   // status bar background bits
+   if (doload)
+      sbar = V_PatchToBlock("STBAR", CR_DEFAULT, VPT_NONE,
+                            &sbar_width, &sbar_height);
+   else {
+      free(sbar); sbar=NULL;
+   }
+
+   // face states
+   facenum = 0;
+   for (i=0;i<ST_NUMPAINFACES;i++)
+   {
+      int j;
+      for (j=0;j<ST_NUMSTRAIGHTFACES;j++)
+      {
+         snprintf(namebuf, sizeof(namebuf), "STFST%d%d", i, j);
+         R_SetPatchNum(&faces[facenum++], namebuf);
+      }
+      snprintf(namebuf, sizeof(namebuf), "STFTR%d0", i);        // turn right
+      R_SetPatchNum(&faces[facenum++], namebuf);
+      snprintf(namebuf, sizeof(namebuf), "STFTL%d0", i);        // turn left
+      R_SetPatchNum(&faces[facenum++], namebuf);
+      snprintf(namebuf, sizeof(namebuf), "STFOUCH%d", i);       // ouch!
+      R_SetPatchNum(&faces[facenum++], namebuf);
+      snprintf(namebuf, sizeof(namebuf), "STFEVL%d", i);        // evil grin ;)
+      R_SetPatchNum(&faces[facenum++], namebuf);
+      snprintf(namebuf, sizeof(namebuf), "STFKILL%d", i);       // pissed off
+      R_SetPatchNum(&faces[facenum++], namebuf);
+   }
+   R_SetPatchNum(&faces[facenum++], "STFGOD0");
+   R_SetPatchNum(&faces[facenum++], "STFDEAD0");
+}
+
+void ST_loadData(void)
+{
+   ST_loadGraphics(true);
+}
+
+void ST_unloadData(void)
+{
+   ST_loadGraphics(false);
+}
+
+void ST_initData(void)
+{
+   int i;
+
+   st_firsttime = true;
+   plyr = &players[displayplayer];            // killough 3/7/98
+
+   st_clock = 0;
+   st_chatstate = StartChatState;
+   st_gamestate = FirstPersonState;
+
+   st_statusbaron = true;
+   st_oldchat = st_chat = false;
+   st_cursoron = false;
+
+   st_faceindex = 0;
+   st_palette = -1;
+
+   st_oldhealth = -1;
+
+   for (i=0;i<NUMWEAPONS;i++)
+      oldweaponsowned[i] = plyr->weaponowned[i];
+
+   for (i=0;i<3;i++)
+      keyboxes[i] = -1;
+
+   STlib_init();
+}
+
+void ST_createWidgets(void)
+{
+   int i;
+
+   // ready weapon ammo
+   STlib_initNum(&w_ready,
+                 ST_AMMOX,
+                 ST_AMMOY,
+                 tallnum,
+                 &plyr->ammo[weaponinfo[plyr->readyweapon].ammo],
+                 &st_statusbaron,
+                 ST_AMMOWIDTH );
+
+   // the last weapon type
+   w_ready.data = plyr->readyweapon;
+
+   // health percentage
+   STlib_initPercent(&w_health,
+                     ST_HEALTHX,
+                     ST_HEALTHY,
+                     tallnum,
+                     &plyr->health,
+                     &st_statusbaron,
+                     &tallpercent);
+
+   // arms background
+   STlib_initBinIcon(&w_armsbg,
+                     ST_ARMSBGX,
+                     ST_ARMSBGY,
+                     &armsbg,
+                     &st_notdeathmatch,
+                     &st_statusbaron);
+
+   // weapons owned
+   for(i=0;i<6;i++)
+   {
+      STlib_initMultIcon(&w_arms[i],
+                         ST_ARMSX+(i%3)*ST_ARMSXSPACE,
+                         ST_ARMSY+(i/3)*ST_ARMSYSPACE,
+                         arms[i], (int *) &plyr->weaponowned[i+1],
+                         &st_armson);
+   }
+
+   // frags sum
+   STlib_initNum(&w_frags,
+                 ST_FRAGSX,
+                 ST_FRAGSY,
+                 tallnum,
+                 &st_fragscount,
+                 &st_fragson,
+                 ST_FRAGSWIDTH);
+
+   // faces
+   STlib_initMultIcon(&w_faces,
+                      ST_FACESX,
+                      ST_FACESY,
+                      faces,
+                      &st_faceindex,
+                      &st_statusbaron);
+
+   // armor percentage - should be colored later
+   STlib_initPercent(&w_armor,
+                     ST_ARMORX,
+                     ST_ARMORY,
+                     tallnum,
+                     &plyr->armorpoints,
+                     &st_statusbaron, &tallpercent);
+
+   // keyboxes 0-2
+   STlib_initMultIcon(&w_keyboxes[0],
+                      ST_KEY0X,
+                      ST_KEY0Y,
+                      keys,
+                      &keyboxes[0],
+                      &st_statusbaron);
+
+   STlib_initMultIcon(&w_keyboxes[1],
+                      ST_KEY1X,
+                      ST_KEY1Y,
+                      keys,
+                      &keyboxes[1],
+                      &st_statusbaron);
+
+   STlib_initMultIcon(&w_keyboxes[2],
+                      ST_KEY2X,
+                      ST_KEY2Y,
+                      keys,
+                      &keyboxes[2],
+                      &st_statusbaron);
+
+   // ammo count (all four kinds)
+   STlib_initNum(&w_ammo[0],
+                 ST_AMMO0X,
+                 ST_AMMO0Y,
+                 shortnum,
+                 &plyr->ammo[0],
+                 &st_statusbaron,
+                 ST_AMMO0WIDTH);
+
+   STlib_initNum(&w_ammo[1],
+                 ST_AMMO1X,
+                 ST_AMMO1Y,
+                 shortnum,
+                 &plyr->ammo[1],
+                 &st_statusbaron,
+                 ST_AMMO1WIDTH);
+
+   STlib_initNum(&w_ammo[2],
+                 ST_AMMO2X,
+                 ST_AMMO2Y,
+                 shortnum,
+                 &plyr->ammo[2],
+                 &st_statusbaron,
+                 ST_AMMO2WIDTH);
+
+   STlib_initNum(&w_ammo[3],
+                 ST_AMMO3X,
+                 ST_AMMO3Y,
+                 shortnum,
+                 &plyr->ammo[3],
+                 &st_statusbaron,
+                 ST_AMMO3WIDTH);
+
+   // max ammo count (all four kinds)
+   STlib_initNum(&w_maxammo[0],
+                 ST_MAXAMMO0X,
+                 ST_MAXAMMO0Y,
+                 shortnum,
+                 &plyr->maxammo[0],
+                 &st_statusbaron,
+                 ST_MAXAMMO0WIDTH);
+
+   STlib_initNum(&w_maxammo[1],
+                 ST_MAXAMMO1X,
+                 ST_MAXAMMO1Y,
+                 shortnum,
+                 &plyr->maxammo[1],
+                 &st_statusbaron,
+                 ST_MAXAMMO1WIDTH);
+
+   STlib_initNum(&w_maxammo[2],
+                 ST_MAXAMMO2X,
+                 ST_MAXAMMO2Y,
+                 shortnum,
+                 &plyr->maxammo[2],
+                 &st_statusbaron,
+                 ST_MAXAMMO2WIDTH);
+
+   STlib_initNum(&w_maxammo[3],
+                 ST_MAXAMMO3X,
+                 ST_MAXAMMO3Y,
+                 shortnum,
+                 &plyr->maxammo[3],
+                 &st_statusbaron,
+                 ST_MAXAMMO3WIDTH);
+}
+
+static boolean st_stopped = true;
+
+void ST_Start(void)
+{
+   if (!st_stopped)
+      ST_Stop();
+   ST_initData();
+   ST_createWidgets();
+   st_stopped = false;
+}
+
+void ST_Stop(void)
+{
+   if (st_stopped)
+      return;
+   V_SetPalette(0);
+   st_stopped = true;
+}
+
+void ST_Init(void)
+{
+   veryfirsttime = 0;
+   ST_loadData();
+   // proff 08/18/98: Changed for high-res
+   screens[4] = Z_Malloc(SCREENWIDTH*(ST_SCALED_HEIGHT+1), PU_STATIC, 0);
+   //  screens[4] = Z_Malloc(ST_WIDTH*ST_HEIGHT, PU_STATIC, 0);
+}