/* Emacs style mode select   -*- C++ -*- */
/*----------------------------------------------------------------------------- */
/* */
/* $Id:$ */
/* */
/* Copyright (C) 1993-1996 by id Software, Inc. */
/* */
/* 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. */
/* */
/* $Log:$ */
/* */
/* DESCRIPTION: */
/*	Status bar code. */
/*	Does the face/direction indicator animatin. */
/*	Does palette indicators as well (red pain/berserk, bright pickup) */
/* */
/*----------------------------------------------------------------------------- */

static const char
        rcsid[] = "$Id: st_stuff.c,v 1.6 1997/02/03 22:45:13 b1 Exp $";


#include <stdio.h>

#include "i_system.h"
#include "i_video.h"
#include "z_zone.h"
#include "m_random.h"
#include "w_wad.h"

#include "doomdef.h"

#include "g_game.h"

#include "st_stuff.h"
#include "st_lib.h"
#include "r_local.h"

#include "p_local.h"
#include "p_inter.h"

#include "am_map.h"
#include "m_cheat.h"

#include "s_sound.h"

/* Needs access to LFB. */
#include "v_video.h"

/* State. */
#include "doomstat.h"

/* Data. */
#include "dstrings.h"
#include "sounds.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

/* N/256*100% probability */
/*  that the normal face state will change */
#define ST_FACEPROBABILITY              96

/* For Responder */
#define ST_TOGGLECHAT           KEY_ENTER

/* Location of status bar */
#define ST_X                            0
#define ST_X2                           104

#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)

#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? */

/* AMMO number pos. */
#define ST_AMMOWIDTH            3
#define ST_AMMOX                        44
#define ST_AMMOY                        171

/* HEALTH number pos. */
#define ST_HEALTHWIDTH          3
#define ST_HEALTHX                      90
#define ST_HEALTHY                      171

/* Weapon pos. */
#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. */
#define ST_FRAGSX                       138
#define ST_FRAGSY                       171
#define ST_FRAGSWIDTH           2

/* ARMOR number pos. */
#define ST_ARMORWIDTH           3
#define ST_ARMORX                       221
#define ST_ARMORY                       171

/* Key icon positions. */
#define ST_KEY0WIDTH            8
#define ST_KEY0HEIGHT           5
#define ST_KEY0X                        239
#define ST_KEY0Y                        171
#define ST_KEY1WIDTH            ST_KEY0WIDTH
#define ST_KEY1X                        239
#define ST_KEY1Y                        181
#define ST_KEY2WIDTH            ST_KEY0WIDTH
#define ST_KEY2X                        239
#define ST_KEY2Y                        191

/* Ammunition counter. */
#define ST_AMMO0WIDTH           3
#define ST_AMMO0HEIGHT          6
#define ST_AMMO0X                       288
#define ST_AMMO0Y                       173
#define ST_AMMO1WIDTH           ST_AMMO0WIDTH
#define ST_AMMO1X                       288
#define ST_AMMO1Y                       179
#define ST_AMMO2WIDTH           ST_AMMO0WIDTH
#define ST_AMMO2X                       288
#define ST_AMMO2Y                       191
#define ST_AMMO3WIDTH           ST_AMMO0WIDTH
#define ST_AMMO3X                       288
#define ST_AMMO3Y                       185

/* Indicate maximum ammunition. */
/* Only needed because backpack exists. */
#define ST_MAXAMMO0WIDTH                3
#define ST_MAXAMMO0HEIGHT               5
#define ST_MAXAMMO0X            314
#define ST_MAXAMMO0Y            173
#define ST_MAXAMMO1WIDTH                ST_MAXAMMO0WIDTH
#define ST_MAXAMMO1X            314
#define ST_MAXAMMO1Y            179
#define ST_MAXAMMO2WIDTH                ST_MAXAMMO0WIDTH
#define ST_MAXAMMO2X            314
#define ST_MAXAMMO2Y            191
#define ST_MAXAMMO3WIDTH                ST_MAXAMMO0WIDTH
#define ST_MAXAMMO3X            314
#define ST_MAXAMMO3Y            185

/* pistol */
#define ST_WEAPON0X                     110
#define ST_WEAPON0Y                     172

/* shotgun */
#define ST_WEAPON1X                     122
#define ST_WEAPON1Y                     172

/* chain gun */
#define ST_WEAPON2X                     134
#define ST_WEAPON2Y                     172

/* missile launcher */
#define ST_WEAPON3X                     110
#define ST_WEAPON3Y                     181

/* plasma gun */
#define ST_WEAPON4X                     122
#define ST_WEAPON4Y                     181

/* bfg */
#define ST_WEAPON5X                     134
#define ST_WEAPON5Y                     181

/* WPNS title */
#define ST_WPNSX                        109
#define ST_WPNSY                        191

/* DETH title */
#define ST_DETHX                        109
#define ST_DETHY                        191

/*Incoming messages window location */
/*UNUSED */
/* #define ST_MSGTEXTX	   (viewwindowx) */
/* #define ST_MSGTEXTY	   (viewwindowy+viewheight-18) */
#define ST_MSGTEXTX                     0
#define ST_MSGTEXTY                     0
/* Dimensions given in characters. */
#define ST_MSGWIDTH                     52
/* Or shall I say, in lines? */
#define ST_MSGHEIGHT            1

#define ST_OUTTEXTX                     0
#define ST_OUTTEXTY                     6

/* Width, in characters again. */
#define ST_OUTWIDTH                     52
/* Height, in lines. */
#define ST_OUTHEIGHT            1

#define ST_MAPWIDTH     \
	(strlen(mapnames[(gameepisode-1)*9+(gamemap-1)]))

#define ST_MAPTITLEX \
	(SCREENWIDTH - ST_MAPWIDTH * ST_CHATFONTWIDTH)

#define ST_MAPTITLEY            0
#define ST_MAPHEIGHT            1


/* 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;

/* lump number for PLAYPAL */
static int lu_palette;

/* 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 */
static patch_t*         sbar;

/* 0-9, tall numbers */
static patch_t*         tallnum[10];

/* tall % sign */
static patch_t*         tallpercent;

/* 0-9, short, yellow (,different!) numbers */
static patch_t*         shortnum[10];

/* 3 key-cards, 3 skulls */
static patch_t*         keys[NUMCARDS];

/* face status patches */
static patch_t*         faces[ST_NUMFACES];

/* face background */
static patch_t*         faceback;

/* main bar right */
static patch_t*         armsbg;

/* weapon ownership patches */
static patch_t*         arms[6][2];

/* ready-weapon widget */
static st_number_t w_ready;

/* 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;



/* Massive bunches of cheat shit */
/*  to keep it from being easy to figure them out. */
/* Yeah, right... */
unsigned char cheat_mus_seq[] =
{
	0xb2, 0x26, 0xb6, 0xae, 0xea, 1, 0, 0, 0xff
};

unsigned char cheat_choppers_seq[] =
{
	0xb2, 0x26, 0xe2, 0x32, 0xf6, 0x2a, 0x2a, 0xa6, 0x6a, 0xea, 0xff /* id... */
};

unsigned char cheat_god_seq[] =
{
	0xb2, 0x26, 0x26, 0xaa, 0x26, 0xff /* iddqd */
};

unsigned char cheat_ammo_seq[] =
{
	0xb2, 0x26, 0xf2, 0x66, 0xa2, 0xff /* idkfa */
};

unsigned char cheat_ammonokey_seq[] =
{
	0xb2, 0x26, 0x66, 0xa2, 0xff    /* idfa */
};


/* Smashing Pumpkins Into Samml Piles Of Putried Debris. */
unsigned char cheat_noclip_seq[] =
{
	0xb2, 0x26, 0xea, 0x2a, 0xb2,   /* idspispopd */
	0xea, 0x2a, 0xf6, 0x2a, 0x26, 0xff
};

/* */
unsigned char cheat_commercial_noclip_seq[] =
{
	0xb2, 0x26, 0xe2, 0x36, 0xb2, 0x2a, 0xff /* idclip */
};



unsigned char cheat_powerup_seq[7][10] =
{
	{ 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0x6e, 0xff }, /* beholdv */
	{ 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0xea, 0xff }, /* beholds */
	{ 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0xb2, 0xff }, /* beholdi */
	{ 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0x6a, 0xff }, /* beholdr */
	{ 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0xa2, 0xff }, /* beholda */
	{ 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0x36, 0xff }, /* beholdl */
	{ 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0xff }        /* behold */
};


unsigned char cheat_clev_seq[] =
{
        0xb2, 0x26,  0xe2, 0x36, 0xa6, 0x6e, 1, 0, 0, 0xff/* idclev */
};


/* my position cheat */
unsigned char cheat_mypos_seq[] =
{
        0xb2, 0x26, 0xb6, 0xba, 0x2a, 0xf6, 0xea, 0xff  /* idmypos */
};


/* Now what? */
cheatseq_t cheat_mus = { cheat_mus_seq, 0 };
cheatseq_t cheat_god = { cheat_god_seq, 0 };
cheatseq_t cheat_ammo = { cheat_ammo_seq, 0 };
cheatseq_t cheat_ammonokey = { cheat_ammonokey_seq, 0 };
cheatseq_t cheat_noclip = { cheat_noclip_seq, 0 };
cheatseq_t cheat_commercial_noclip = { cheat_commercial_noclip_seq, 0 };

cheatseq_t cheat_powerup[7] =
{
        { cheat_powerup_seq[0], 0 },
        { cheat_powerup_seq[1], 0 },
        { cheat_powerup_seq[2], 0 },
        { cheat_powerup_seq[3], 0 },
        { cheat_powerup_seq[4], 0 },
        { cheat_powerup_seq[5], 0 },
        { cheat_powerup_seq[6], 0 }
};

cheatseq_t cheat_choppers = { cheat_choppers_seq, 0 };
cheatseq_t cheat_clev = { cheat_clev_seq, 0 };
cheatseq_t cheat_mypos = { cheat_mypos_seq, 0 };


/* */
extern char*    mapnames[];


/* */
/* STATUS BAR CODE */
/* */
void ST_Stop(void);

void ST_refreshBackground(void)
{

        if (st_statusbaron)
        {
                V_DrawPatch(ST_X, 0, BG, sbar);

                if (netgame)
			V_DrawPatch(ST_FX, 0, BG, faceback);

                V_CopyRect(ST_X, 0, BG, ST_WIDTH, ST_HEIGHT, ST_X, ST_Y, FG);
	}

}


/* Respond to keyboard input events, */
/*  intercept cheats. */
boolean
ST_Responder (event_t* ev)
{
        int i;

        /* 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:
			/*	fprintf(stderr, "AM exited\n"); */
			st_gamestate = FirstPersonState;
			break;
		}
	}

        /* if a user keypress... */
        else if (ev->type == ev_keydown)
        {
                if (!netgame)
                {
                        /* b. - enabled for more debug fun. */
                        /* if (gameskill != sk_nightmare) { */

                        /* 'dqd' cheat for toggleable god mode */
                        if (cht_CheckCheat(&cheat_god, ev->data1))
                        {
                                plyr->cheats ^= CF_GODMODE;
                                if (plyr->cheats & CF_GODMODE)
                                {
                                        if (plyr->mo)
						plyr->mo->health = 100;

                                        plyr->health = 100;
                                        plyr->message = STSTR_DQDON;
				}
                                else
					plyr->message = STSTR_DQDOFF;
			}
                        /* 'fa' cheat for killer fucking arsenal */
                        else if (cht_CheckCheat(&cheat_ammonokey, ev->data1))
                        {
                                plyr->armorpoints = 200;
                                plyr->armortype = 2;

                                for (i=0; i<NUMWEAPONS; i++)
					plyr->weaponowned[i] = true;

                                for (i=0; i<NUMAMMO; i++)
					plyr->ammo[i] = plyr->maxammo[i];

                                plyr->message = STSTR_FAADDED;
			}
                        /* 'kfa' cheat for key full ammo */
                        else if (cht_CheckCheat(&cheat_ammo, ev->data1))
                        {
                                plyr->armorpoints = 200;
                                plyr->armortype = 2;

                                for (i=0; i<NUMWEAPONS; i++)
					plyr->weaponowned[i] = true;

                                for (i=0; i<NUMAMMO; i++)
					plyr->ammo[i] = plyr->maxammo[i];

                                for (i=0; i<NUMCARDS; i++)
					plyr->cards[i] = true;

                                plyr->message = STSTR_KFAADDED;
			}
                        /* 'mus' cheat for changing music */
                        else if (cht_CheckCheat(&cheat_mus, ev->data1))
                        {

                                char buf[3];
                                int musnum;

                                plyr->message = STSTR_MUS;
                                cht_GetParam(&cheat_mus, buf);

                                if (gamemode == commercial)
                                {
                                        musnum = mus_runnin + (buf[0]-'0')*10 + buf[1]-'0' - 1;

                                        if (((buf[0]-'0')*10 + buf[1]-'0') > 35)
						plyr->message = STSTR_NOMUS;
                                        else
						S_ChangeMusic(musnum, 1);
				}
                                else
                                {
                                        musnum = mus_e1m1 + (buf[0]-'1')*9 + (buf[1]-'1');

                                        if (((buf[0]-'1')*9 + buf[1]-'1') > 31)
						plyr->message = STSTR_NOMUS;
                                        else
						S_ChangeMusic(musnum, 1);
				}
			}
                        /* Simplified, accepting both "noclip" and "idspispopd". */
                        /* no clipping mode cheat */
                        else if ( cht_CheckCheat(&cheat_noclip, ev->data1)
                                  || cht_CheckCheat(&cheat_commercial_noclip,ev->data1) )
                        {
                                plyr->cheats ^= CF_NOCLIP;

                                if (plyr->cheats & CF_NOCLIP)
					plyr->message = STSTR_NCON;
                                else
					plyr->message = STSTR_NCOFF;
			}
                        /* 'behold?' power-up cheats */
                        for (i=0; i<6; i++)
                        {
                                if (cht_CheckCheat(&cheat_powerup[i], ev->data1))
                                {
                                        if (!plyr->powers[i])
						P_GivePower( plyr, i);
                                        else if (i!=pw_strength)
						plyr->powers[i] = 1;
                                        else
						plyr->powers[i] = 0;

                                        plyr->message = STSTR_BEHOLDX;
				}
			}

                        /* 'behold' power-up menu */
                        if (cht_CheckCheat(&cheat_powerup[6], ev->data1))
                        {
                                plyr->message = STSTR_BEHOLD;
			}
                        /* 'choppers' invulnerability & chainsaw */
                        else if (cht_CheckCheat(&cheat_choppers, ev->data1))
                        {
                                plyr->weaponowned[wp_chainsaw] = true;
                                plyr->powers[pw_invulnerability] = true;
                                plyr->message = STSTR_CHOPPERS;
			}
                        /* 'mypos' for player position */
                        else if (cht_CheckCheat(&cheat_mypos, ev->data1))
                        {
                                static char buf[ST_MSGWIDTH];
                                sprintf(buf, "ang=0x%x;x,y=(0x%x,0x%x)",
                                        players[consoleplayer].mo->angle,
                                        players[consoleplayer].mo->x,
                                        players[consoleplayer].mo->y);
                                plyr->message = buf;
			}
		}

                /* 'clev' change-level cheat */
                if (cht_CheckCheat(&cheat_clev, ev->data1))
                {
                        char buf[3];
                        int epsd;
                        int map;

                        cht_GetParam(&cheat_clev, buf);

                        if (gamemode == commercial)
                        {
                                epsd = 0;
                                map = (buf[0] - '0')*10 + buf[1] - '0';
			}
                        else
                        {
                                epsd = buf[0] - '0';
                                map = buf[1] - '0';
			}

                        /* Catch invalid maps. */
                        if (epsd < 1)
				return false;

                        if (map < 1)
				return false;

                        /* Ohmygod - this is not going to work. */
                        if ((gamemode == retail)
                            && ((epsd > 4) || (map > 9)))
				return false;

                        if ((gamemode == registered)
                            && ((epsd > 3) || (map > 9)))
				return false;

                        if ((gamemode == shareware)
                            && ((epsd > 1) || (map > 9)))
				return false;

                        if ((gamemode == commercial)
                            && (( epsd > 1) || (map > 34)))
				return false;

                        /* So be it. */
                        plyr->message = STSTR_CLEV;
                        G_DeferedInitNew(gameskill, epsd, map);
		}
	}
        return false;
}



int ST_calcPainOffset(void)
{
        int health;
        static int lastcalc;
        static int oldhealth = -1;

        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--;

}

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;

                if (plyr->cards[i+3])
			keyboxes[i] = i+3;
	}

        /* 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 != consoleplayer)
			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;
        byte*       pal;
        int cnt;
        int bzc;

        cnt = plyr->damagecount;

        if (plyr->powers[pw_strength])
        {
                /* slowly fade the berzerk out */
                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)
        {
                st_palette = palette;
                pal = (byte *) W_CacheLumpNum (lu_palette, PU_CACHE)+palette*768;
                I_SetPalette (pal);
	}

}

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;

        STlib_updateNum(&w_ready, refresh);

        for (i=0; i<4; i++)
        {
                STlib_updateNum(&w_ammo[i], refresh);
                STlib_updateNum(&w_maxammo[i], refresh);
	}

        STlib_updatePercent(&w_health, refresh);
        STlib_updatePercent(&w_armor, refresh);

        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, 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 fullscreen, boolean refresh)
{

        st_statusbaron = (!fullscreen) || automapactive;
        st_firsttime = st_firsttime || refresh;

        /* Do red-/gold-shifts from damage/items */
        ST_doPaletteStuff();

        /* If just after ST_Start(), refresh all */
        if (st_firsttime) ST_doRefresh();
        /* Otherwise, update as little as possible */
        else ST_diffDraw();

}

void ST_loadGraphics(void)
{

        int i;
        int j;
        int facenum;

        char namebuf[9];

        /* Load the numbers, tall and short */
        for (i=0; i<10; i++)
        {
                sprintf(namebuf, "STTNUM%d", i);
                tallnum[i] = (patch_t *) W_CacheLumpName(namebuf, PU_STATIC);

                sprintf(namebuf, "STYSNUM%d", i);
                shortnum[i] = (patch_t *) W_CacheLumpName(namebuf, PU_STATIC);
	}

        /* Load percent key. */
        /*Note: why not load STMINUS here, too? */
        tallpercent = (patch_t *) W_CacheLumpName("STTPRCNT", PU_STATIC);

        /* key cards */
        for (i=0; i<NUMCARDS; i++)
        {
                sprintf(namebuf, "STKEYS%d", i);
                keys[i] = (patch_t *) W_CacheLumpName(namebuf, PU_STATIC);
	}

        /* arms background */
        armsbg = (patch_t *) W_CacheLumpName("STARMS", PU_STATIC);

        /* arms ownership widgets */
        for (i=0; i<6; i++)
        {
                sprintf(namebuf, "STGNUM%d", i+2);

                /* gray # */
                arms[i][0] = (patch_t *) W_CacheLumpName(namebuf, PU_STATIC);

                /* yellow # */
                arms[i][1] = shortnum[i+2];
	}

        /* face backgrounds for different color players */
        sprintf(namebuf, "STFB%d", consoleplayer);
        faceback = (patch_t *) W_CacheLumpName(namebuf, PU_STATIC);

        /* status bar background bits */
        sbar = (patch_t *) W_CacheLumpName("STBAR", PU_STATIC);

        /* face states */
        facenum = 0;
        for (i=0; i<ST_NUMPAINFACES; i++)
        {
                for (j=0; j<ST_NUMSTRAIGHTFACES; j++)
                {
                        sprintf(namebuf, "STFST%d%d", i, j);
                        faces[facenum++] = W_CacheLumpName(namebuf, PU_STATIC);
		}
                sprintf(namebuf, "STFTR%d0", i); /* turn right */
                faces[facenum++] = W_CacheLumpName(namebuf, PU_STATIC);
                sprintf(namebuf, "STFTL%d0", i); /* turn left */
                faces[facenum++] = W_CacheLumpName(namebuf, PU_STATIC);
                sprintf(namebuf, "STFOUCH%d", i); /* ouch! */
                faces[facenum++] = W_CacheLumpName(namebuf, PU_STATIC);
                sprintf(namebuf, "STFEVL%d", i); /* evil grin ;) */
                faces[facenum++] = W_CacheLumpName(namebuf, PU_STATIC);
                sprintf(namebuf, "STFKILL%d", i); /* pissed off */
                faces[facenum++] = W_CacheLumpName(namebuf, PU_STATIC);
	}
        faces[facenum++] = W_CacheLumpName("STFGOD0", PU_STATIC);
        faces[facenum++] = W_CacheLumpName("STFDEAD0", PU_STATIC);

}

void ST_loadData(void)
{
        lu_palette = W_GetNumForName ("PLAYPAL");
        ST_loadGraphics();
}

void ST_unloadGraphics(void)
{

        int i;

        /* unload the numbers, tall and short */
        for (i=0; i<10; i++)
        {
                Z_ChangeTag(tallnum[i], PU_CACHE);
                Z_ChangeTag(shortnum[i], PU_CACHE);
	}
        /* unload tall percent */
        Z_ChangeTag(tallpercent, PU_CACHE);

        /* unload arms background */
        Z_ChangeTag(armsbg, PU_CACHE);

        /* unload gray #'s */
        for (i=0; i<6; i++)
		Z_ChangeTag(arms[i][0], PU_CACHE);

        /* unload the key cards */
        for (i=0; i<NUMCARDS; i++)
		Z_ChangeTag(keys[i], PU_CACHE);

        Z_ChangeTag(sbar, PU_CACHE);
        Z_ChangeTag(faceback, PU_CACHE);

        for (i=0; i<ST_NUMFACES; i++)
		Z_ChangeTag(faces[i], PU_CACHE);

        /* Note: nobody ain't seen no unloading */
        /*   of stminus yet. Dude. */


}

void ST_unloadData(void)
{
        ST_unloadGraphics();
}

void ST_initData(void)
{

        int i;

        st_firsttime = true;
        plyr = &players[consoleplayer];

        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;

        I_SetPalette (W_CacheLumpNum (lu_palette, PU_CACHE));

        st_stopped = true;
}

void ST_Init (void)
{
        veryfirsttime = 0;
        ST_loadData();
        screens[4] = (byte *) Z_Malloc(ST_WIDTH*ST_HEIGHT, PU_STATIC, 0);
}
