diff options
Diffstat (limited to 'src/st_stuff.c')
| -rw-r--r-- | src/st_stuff.c | 1474 |
1 files changed, 1474 insertions, 0 deletions
diff --git a/src/st_stuff.c b/src/st_stuff.c new file mode 100644 index 00000000..26cf044f --- /dev/null +++ b/src/st_stuff.c @@ -0,0 +1,1474 @@ +// Emacs style mode select -*- C++ -*- +//----------------------------------------------------------------------------- +// +// $Id: st_stuff.c 4 2005-07-23 16:19:41Z fraggle $ +// +// Copyright (C) 1993-1996 by id Software, Inc. +// +// This source is available for distribution and/or modification +// only under the terms of the DOOM Source Code License as +// published by id Software. All rights reserved. +// +// The source is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License +// for more details. +// +// $Log$ +// Revision 1.1 2005/07/23 16:20:07 fraggle +// Initial revision +// +// +// 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 4 2005-07-23 16:19:41Z fraggle $"; + + +#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); +} |