mirror of
https://github.com/ZDoom/raze-gles.git
synced 2024-12-26 19:50:45 +00:00
c96ec9d440
No functional changes. git-svn-id: https://svn.eduke32.com/eduke32@7776 1a8010ca-5511-0410-912e-c29ae57300e0
1144 lines
39 KiB
C++
1144 lines
39 KiB
C++
//-------------------------------------------------------------------------
|
|
/*
|
|
Copyright (C) 2016 EDuke32 developers and contributors
|
|
|
|
This file is part of EDuke32.
|
|
|
|
EDuke32 is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License version 2
|
|
as published by the Free Software Foundation.
|
|
|
|
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
//-------------------------------------------------------------------------
|
|
|
|
#include "duke3d.h"
|
|
#include "compat.h"
|
|
#include "sbar.h"
|
|
|
|
int32_t althud_flashing = 1;
|
|
int32_t althud_numbertile = 2930;
|
|
int32_t althud_numberpal = 0;
|
|
|
|
#ifdef EDUKE32_TOUCH_DEVICES
|
|
int32_t althud_shadows = 0;
|
|
#else
|
|
int32_t althud_shadows = 1;
|
|
#endif
|
|
|
|
static int32_t sbarx(int32_t x)
|
|
{
|
|
if (ud.screen_size == 4) return sbarsc(x<<16);
|
|
return (((320<<16) - sbarsc(320<<16)) >> 1) + sbarsc(x<<16);
|
|
}
|
|
|
|
static int32_t sbarxr(int32_t x)
|
|
{
|
|
if (ud.screen_size == 4) return (320<<16) - sbarsc(x<<16);
|
|
return (((320<<16) - sbarsc(320<<16)) >> 1) + sbarsc(x<<16);
|
|
}
|
|
|
|
static int32_t sbary(int32_t y)
|
|
{
|
|
if (ud.hudontop == 1 && ud.screen_size == 4 && ud.althud == 1) return sbarsc(y << 16);
|
|
else return (200<<16) - sbarsc(200<<16) + sbarsc(y<<16);
|
|
}
|
|
|
|
int32_t sbarx16(int32_t x)
|
|
{
|
|
if (ud.screen_size == 4) return sbarsc(x);
|
|
return (((320<<16) - sbarsc(320<<16)) >> 1) + sbarsc(x);
|
|
}
|
|
|
|
#if 0 // enable if ever needed
|
|
static int32_t sbarxr16(int32_t x)
|
|
{
|
|
if (ud.screen_size == 4) return (320<<16) - sbarsc(x);
|
|
return (((320<<16) - sbarsc(320<<16)) >> 1) + sbarsc(x);
|
|
}
|
|
#endif
|
|
|
|
int32_t sbary16(int32_t y)
|
|
{
|
|
return (200<<16) - sbarsc(200<<16) + sbarsc(y);
|
|
}
|
|
|
|
static void G_PatchStatusBar(int32_t x1, int32_t y1, int32_t x2, int32_t y2)
|
|
{
|
|
int32_t const scl = sbarsc(65536);
|
|
int32_t const tx = sbarx16((160<<16) - (tilesiz[BOTTOMSTATUSBAR].x<<15)); // centered
|
|
int32_t const ty = sbary(200-tilesiz[BOTTOMSTATUSBAR].y);
|
|
|
|
int32_t const clx1 = sbarsc(scale(x1, xdim, 320)), cly1 = sbarsc(scale(y1, ydim, 200));
|
|
int32_t const clx2 = sbarsc(scale(x2, xdim, 320)), cly2 = sbarsc(scale(y2, ydim, 200));
|
|
int32_t const clofx = (xdim - sbarsc(xdim)) >> 1, clofy = (ydim - sbarsc(ydim));
|
|
|
|
rotatesprite(tx, ty, scl, 0, BOTTOMSTATUSBAR, 4, 0, 10+16+64, clx1+clofx, cly1+clofy, clx2+clofx-1, cly2+clofy-1);
|
|
}
|
|
|
|
#define POLYMOSTTRANS (1)
|
|
#define POLYMOSTTRANS2 (1|32)
|
|
|
|
// Draws inventory numbers in the HUD for both the full and mini status bars.
|
|
// yofs: in hud_scale-independent, (<<16)-scaled, 0-200-normalized y coords.
|
|
static void G_DrawInvNum(int32_t x, int32_t yofs, int32_t y, char num1, char ha, int32_t sbits)
|
|
{
|
|
char dabuf[16];
|
|
int32_t i, shd = (x < 0);
|
|
|
|
const int32_t sbscale = sbarsc(65536);
|
|
const int32_t sby = yofs+sbary(y), sbyp1 = yofs+sbary(y+1);
|
|
|
|
if (shd) x = -x;
|
|
|
|
Bsprintf(dabuf, "%d", num1);
|
|
|
|
if (num1 > 99)
|
|
{
|
|
if (shd && ud.screen_size == 4 && videoGetRenderMode() >= REND_POLYMOST && althud_shadows)
|
|
{
|
|
for (i=0; i<=2; i++)
|
|
rotatesprite_fs(sbarx(x+(-4+4*i)+1), sbyp1, sbscale, 0, THREEBYFIVE+dabuf[i]-'0',
|
|
127, 4, POLYMOSTTRANS|sbits);
|
|
}
|
|
|
|
for (i=0; i<=2; i++)
|
|
rotatesprite_fs(sbarx(x+(-4+4*i)), sby, sbscale, 0, THREEBYFIVE+dabuf[i]-'0', ha, 0, sbits);
|
|
return;
|
|
}
|
|
|
|
if (num1 > 9)
|
|
{
|
|
if (shd && ud.screen_size == 4 && videoGetRenderMode() >= REND_POLYMOST && althud_shadows)
|
|
{
|
|
rotatesprite_fs(sbarx(x+1), sbyp1, sbscale, 0, THREEBYFIVE+dabuf[0]-'0', 127, 4, POLYMOSTTRANS|sbits);
|
|
rotatesprite_fs(sbarx(x+4+1), sbyp1, sbscale, 0, THREEBYFIVE+dabuf[1]-'0', 127, 4, POLYMOSTTRANS|sbits);
|
|
}
|
|
|
|
rotatesprite_fs(sbarx(x), sby, sbscale, 0, THREEBYFIVE+dabuf[0]-'0', ha, 0, sbits);
|
|
rotatesprite_fs(sbarx(x+4), sby, sbscale, 0, THREEBYFIVE+dabuf[1]-'0', ha, 0, sbits);
|
|
return;
|
|
}
|
|
|
|
rotatesprite_fs(sbarx(x+4+1), sbyp1, sbscale, 0, THREEBYFIVE+dabuf[0]-'0', ha, 4, sbits);
|
|
rotatesprite_fs(sbarx(x+4), sby, sbscale, 0, THREEBYFIVE+dabuf[0]-'0', ha, 0, sbits);
|
|
}
|
|
|
|
static void G_DrawWeapNum(int16_t ind, int32_t x, int32_t y, int32_t num1, int32_t num2, int32_t ha)
|
|
{
|
|
char dabuf[16];
|
|
|
|
const int32_t sbscale = sbarsc(65536);
|
|
const int32_t sby = sbary(y);
|
|
|
|
rotatesprite_fs(sbarx(x-7), sby, sbscale, 0, THREEBYFIVE+ind+1, ha-10, 7, 10);
|
|
rotatesprite_fs(sbarx(x-3), sby, sbscale, 0, THREEBYFIVE+10, ha, 0, 10);
|
|
|
|
if (VOLUMEONE && (ind > HANDBOMB_WEAPON || ind < 0))
|
|
{
|
|
minitextshade(x+1, y-4, "ORDER", 20, 11, 2+8+16+ROTATESPRITE_MAX);
|
|
return;
|
|
}
|
|
|
|
rotatesprite_fs(sbarx(x+9), sby, sbscale, 0, THREEBYFIVE+11, ha, 0, 10);
|
|
|
|
if (num1 > 99) num1 = 99;
|
|
if (num2 > 99) num2 = 99;
|
|
|
|
Bsprintf(dabuf, "%d", num1);
|
|
if (num1 > 9)
|
|
{
|
|
rotatesprite_fs(sbarx(x), sby, sbscale, 0, THREEBYFIVE+dabuf[0]-'0', ha, 0, 10);
|
|
rotatesprite_fs(sbarx(x+4), sby, sbscale, 0, THREEBYFIVE+dabuf[1]-'0', ha, 0, 10);
|
|
}
|
|
else rotatesprite_fs(sbarx(x+4), sby, sbscale, 0, THREEBYFIVE+dabuf[0]-'0', ha, 0, 10);
|
|
|
|
Bsprintf(dabuf, "%d", num2);
|
|
if (num2 > 9)
|
|
{
|
|
rotatesprite_fs(sbarx(x+13), sby, sbscale, 0, THREEBYFIVE+dabuf[0]-'0', ha, 0, 10);
|
|
rotatesprite_fs(sbarx(x+17), sby, sbscale, 0, THREEBYFIVE+dabuf[1]-'0', ha, 0, 10);
|
|
return;
|
|
}
|
|
rotatesprite_fs(sbarx(x+13), sby, sbscale, 0, THREEBYFIVE+dabuf[0]-'0', ha, 0, 10);
|
|
}
|
|
|
|
static void G_DrawWeapNum2(char ind, int32_t x, int32_t y, int32_t num1, int32_t num2, char ha)
|
|
{
|
|
char dabuf[16];
|
|
|
|
const int32_t sbscale = sbarsc(65536);
|
|
const int32_t sby = sbary(y);
|
|
|
|
rotatesprite_fs(sbarx(x-7), sby, sbscale, 0, THREEBYFIVE+ind+1, ha-10, 7, 10);
|
|
rotatesprite_fs(sbarx(x-4), sby, sbscale, 0, THREEBYFIVE+10, ha, 0, 10);
|
|
rotatesprite_fs(sbarx(x+13), sby, sbscale, 0, THREEBYFIVE+11, ha, 0, 10);
|
|
|
|
Bsprintf(dabuf, "%d", num1);
|
|
if (num1 > 99)
|
|
{
|
|
rotatesprite_fs(sbarx(x), sby, sbscale, 0, THREEBYFIVE+dabuf[0]-'0', ha, 0, 10);
|
|
rotatesprite_fs(sbarx(x+4), sby, sbscale, 0, THREEBYFIVE+dabuf[1]-'0', ha, 0, 10);
|
|
rotatesprite_fs(sbarx(x+8), sby, sbscale, 0, THREEBYFIVE+dabuf[2]-'0', ha, 0, 10);
|
|
}
|
|
else if (num1 > 9)
|
|
{
|
|
rotatesprite_fs(sbarx(x+4), sby, sbscale, 0, THREEBYFIVE+dabuf[0]-'0', ha, 0, 10);
|
|
rotatesprite_fs(sbarx(x+8), sby, sbscale, 0, THREEBYFIVE+dabuf[1]-'0', ha, 0, 10);
|
|
}
|
|
else rotatesprite_fs(sbarx(x+8), sby, sbscale, 0, THREEBYFIVE+dabuf[0]-'0', ha, 0, 10);
|
|
|
|
Bsprintf(dabuf, "%d", num2);
|
|
if (num2 > 99)
|
|
{
|
|
rotatesprite_fs(sbarx(x+17), sby, sbscale, 0, THREEBYFIVE+dabuf[0]-'0', ha, 0, 10);
|
|
rotatesprite_fs(sbarx(x+21), sby, sbscale, 0, THREEBYFIVE+dabuf[1]-'0', ha, 0, 10);
|
|
rotatesprite_fs(sbarx(x+25), sby, sbscale, 0, THREEBYFIVE+dabuf[2]-'0', ha, 0, 10);
|
|
}
|
|
else if (num2 > 9)
|
|
{
|
|
rotatesprite_fs(sbarx(x+17), sby, sbscale, 0, THREEBYFIVE+dabuf[0]-'0', ha, 0, 10);
|
|
rotatesprite_fs(sbarx(x+21), sby, sbscale, 0, THREEBYFIVE+dabuf[1]-'0', ha, 0, 10);
|
|
return;
|
|
}
|
|
else
|
|
rotatesprite_fs(sbarx(x+25), sby, sbscale, 0, THREEBYFIVE+dabuf[0]-'0', ha, 0, 10);
|
|
}
|
|
|
|
static void G_DrawWeapAmounts(const DukePlayer_t *p, int32_t x, int32_t y, int32_t u)
|
|
{
|
|
int32_t cw = p->curr_weapon;
|
|
|
|
if (u&4)
|
|
{
|
|
if (u != -1) G_PatchStatusBar(88, 178, 88+37, 178+6); //original code: (96,178,96+12,178+6);
|
|
G_DrawWeapNum2(PISTOL_WEAPON, x, y,
|
|
p->ammo_amount[PISTOL_WEAPON], p->max_ammo_amount[PISTOL_WEAPON],
|
|
12-20*(cw == PISTOL_WEAPON));
|
|
}
|
|
if (u&8)
|
|
{
|
|
if (u != -1) G_PatchStatusBar(88, 184, 88+37, 184+6); //original code: (96,184,96+12,184+6);
|
|
G_DrawWeapNum2(SHOTGUN_WEAPON, x, y+6,
|
|
p->ammo_amount[SHOTGUN_WEAPON], p->max_ammo_amount[SHOTGUN_WEAPON],
|
|
(((p->gotweapon & (1<<SHOTGUN_WEAPON)) == 0)*9)+12-18*
|
|
(cw == SHOTGUN_WEAPON));
|
|
}
|
|
if (u&16)
|
|
{
|
|
if (u != -1) G_PatchStatusBar(88, 190, 88+37, 190+6); //original code: (96,190,96+12,190+6);
|
|
G_DrawWeapNum2(CHAINGUN_WEAPON, x, y+12,
|
|
p->ammo_amount[CHAINGUN_WEAPON], p->max_ammo_amount[CHAINGUN_WEAPON],
|
|
(((p->gotweapon & (1<<CHAINGUN_WEAPON)) == 0)*9)+12-18*
|
|
(cw == CHAINGUN_WEAPON));
|
|
}
|
|
if (u&32)
|
|
{
|
|
if (u != -1) G_PatchStatusBar(127, 178, 127+29, 178+6); //original code: (135,178,135+8,178+6);
|
|
G_DrawWeapNum(RPG_WEAPON, x+39, y,
|
|
p->ammo_amount[RPG_WEAPON], p->max_ammo_amount[RPG_WEAPON],
|
|
(((p->gotweapon & (1<<RPG_WEAPON)) == 0)*9)+12-19*
|
|
(cw == RPG_WEAPON));
|
|
}
|
|
if (u&64)
|
|
{
|
|
if (u != -1) G_PatchStatusBar(127, 184, 127+29, 184+6); //original code: (135,184,135+8,184+6);
|
|
G_DrawWeapNum(HANDBOMB_WEAPON, x+39, y+6,
|
|
p->ammo_amount[HANDBOMB_WEAPON], p->max_ammo_amount[HANDBOMB_WEAPON],
|
|
(((!p->ammo_amount[HANDBOMB_WEAPON])|((p->gotweapon & (1<<HANDBOMB_WEAPON)) == 0))*9)+12-19*
|
|
((cw == HANDBOMB_WEAPON) || (cw == HANDREMOTE_WEAPON)));
|
|
}
|
|
if (u&128)
|
|
{
|
|
if (u != -1) G_PatchStatusBar(127, 190, 127+29, 190+6); //original code: (135,190,135+8,190+6);
|
|
|
|
if (p->subweapon&(1<<GROW_WEAPON))
|
|
G_DrawWeapNum(SHRINKER_WEAPON, x+39, y+12,
|
|
p->ammo_amount[GROW_WEAPON], p->max_ammo_amount[GROW_WEAPON],
|
|
(((p->gotweapon & (1<<GROW_WEAPON)) == 0)*9)+12-18*
|
|
(cw == GROW_WEAPON));
|
|
else
|
|
G_DrawWeapNum(SHRINKER_WEAPON, x+39, y+12,
|
|
p->ammo_amount[SHRINKER_WEAPON], p->max_ammo_amount[SHRINKER_WEAPON],
|
|
(((p->gotweapon & (1<<SHRINKER_WEAPON)) == 0)*9)+12-18*
|
|
(cw == SHRINKER_WEAPON));
|
|
}
|
|
if (u&256)
|
|
{
|
|
if (u != -1) G_PatchStatusBar(158, 178, 162+29, 178+6); //original code: (166,178,166+8,178+6);
|
|
|
|
G_DrawWeapNum(DEVISTATOR_WEAPON, x+70, y,
|
|
p->ammo_amount[DEVISTATOR_WEAPON], p->max_ammo_amount[DEVISTATOR_WEAPON],
|
|
(((p->gotweapon & (1<<DEVISTATOR_WEAPON)) == 0)*9)+12-18*
|
|
(cw == DEVISTATOR_WEAPON));
|
|
}
|
|
if (u&512)
|
|
{
|
|
if (u != -1) G_PatchStatusBar(158, 184, 162+29, 184+6); //original code: (166,184,166+8,184+6);
|
|
|
|
G_DrawWeapNum(TRIPBOMB_WEAPON, x+70, y+6,
|
|
p->ammo_amount[TRIPBOMB_WEAPON], p->max_ammo_amount[TRIPBOMB_WEAPON],
|
|
(((p->gotweapon & (1<<TRIPBOMB_WEAPON)) == 0)*9)+12-18*
|
|
(cw == TRIPBOMB_WEAPON));
|
|
}
|
|
|
|
if (u&65536L)
|
|
{
|
|
if (u != -1) G_PatchStatusBar(158, 190, 162+29, 190+6); //original code: (166,190,166+8,190+6);
|
|
|
|
G_DrawWeapNum(-1, x+70, y+12,
|
|
p->ammo_amount[FREEZE_WEAPON], p->max_ammo_amount[FREEZE_WEAPON],
|
|
(((p->gotweapon & (1<<FREEZE_WEAPON)) == 0)*9)+12-18*
|
|
(cw == FREEZE_WEAPON));
|
|
}
|
|
}
|
|
|
|
// yofs: in hud_scale-independent, (<<16)-scaled, 0-200-normalized y coords.
|
|
static inline void G_DrawDigiNum_(int32_t x, int32_t yofs, int32_t y, int32_t n, char s, int32_t cs)
|
|
{
|
|
if (!(cs & ROTATESPRITE_FULL16))
|
|
{
|
|
x <<= 16;
|
|
y <<= 16;
|
|
}
|
|
|
|
G_DrawTXDigiNumZ(DIGITALNUM, sbarx16(x), yofs + sbary16(y), n, s, 0, cs|ROTATESPRITE_FULL16, 0, 0, xdim-1, ydim-1, sbarsc(65536L));
|
|
}
|
|
|
|
static inline void G_DrawDigiNum(int32_t x, int32_t y, int32_t n, char s, int32_t cs)
|
|
{
|
|
G_DrawDigiNum_(x, 0, y, n, s, cs);
|
|
}
|
|
|
|
void G_DrawTXDigiNumZ(int32_t starttile, int32_t x, int32_t y, int32_t n, int32_t s, int32_t pal,
|
|
int32_t cs, int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t z)
|
|
{
|
|
char b[12];
|
|
Bsprintf(b, "%d", n);
|
|
|
|
if (!(cs & ROTATESPRITE_FULL16))
|
|
{
|
|
x <<= 16;
|
|
y <<= 16;
|
|
}
|
|
|
|
G_ScreenText(starttile, x, y, z, 0, 0, b, s, pal, cs|2|ROTATESPRITE_FULL16, 0, (4<<16), (8<<16), (1<<16), 0, TEXT_XCENTER|TEXT_DIGITALNUMBER, x1, y1, x2, y2);
|
|
}
|
|
|
|
static void G_DrawAltDigiNum(int32_t x, int32_t y, int32_t n, char s, int32_t cs)
|
|
{
|
|
int32_t i, j = 0, k, p, c;
|
|
char b[12];
|
|
int32_t rev = (x < 0);
|
|
int32_t shd = (y < 0);
|
|
|
|
const int32_t sbscale = sbarsc(65536);
|
|
|
|
if (rev) x = -x;
|
|
if (shd) y = -y;
|
|
|
|
i = Bsprintf(b, "%d", n);
|
|
|
|
for (k=i-1; k>=0; k--)
|
|
{
|
|
p = althud_numbertile + b[k]-'0';
|
|
j += tilesiz[p].x+1;
|
|
}
|
|
c = x-(j>>1);
|
|
|
|
if (rev)
|
|
{
|
|
for (k=0; k<i; k++)
|
|
{
|
|
p = althud_numbertile + b[k]-'0';
|
|
if (shd && videoGetRenderMode() >= REND_POLYMOST && althud_shadows)
|
|
rotatesprite_fs(sbarxr(c+j-1), sbary(y+1), sbscale, 0, p, 127, 4, cs|POLYMOSTTRANS2);
|
|
rotatesprite_fs(sbarxr(c+j), sbary(y), sbscale, 0, p, s, althud_numberpal, cs);
|
|
j -= tilesiz[p].x+1;
|
|
}
|
|
return;
|
|
}
|
|
|
|
j = 0;
|
|
for (k=0; k<i; k++)
|
|
{
|
|
p = althud_numbertile + b[k]-'0';
|
|
if (shd && videoGetRenderMode() >= REND_POLYMOST && althud_shadows)
|
|
rotatesprite_fs(sbarx(c+j+1), sbary(y+1), sbscale, 0, p, 127, 4, cs|POLYMOSTTRANS2);
|
|
rotatesprite_fs(sbarx(c+j), sbary(y), sbscale, 0, p, s, althud_numberpal, cs);
|
|
j += tilesiz[p].x+1;
|
|
}
|
|
}
|
|
|
|
static int32_t invensc(int32_t maximum) // used to reposition the inventory icon selector as the HUD scales
|
|
{
|
|
return scale(maximum << 16, ud.statusbarscale - 36, 100 - 36);
|
|
}
|
|
|
|
void G_DrawInventory(const DukePlayer_t *p)
|
|
{
|
|
int32_t n, j = 0, x = 0, y;
|
|
|
|
n = (p->inv_amount[GET_JETPACK] > 0)<<3;
|
|
if (n&8) j++;
|
|
n |= (p->inv_amount[GET_SCUBA] > 0)<<5;
|
|
if (n&32) j++;
|
|
n |= (p->inv_amount[GET_STEROIDS] > 0)<<1;
|
|
if (n&2) j++;
|
|
n |= (p->inv_amount[GET_HOLODUKE] > 0)<<2;
|
|
if (n&4) j++;
|
|
n |= (p->inv_amount[GET_FIRSTAID] > 0);
|
|
if (n&1) j++;
|
|
n |= (p->inv_amount[GET_HEATS] > 0)<<4;
|
|
if (n&16) j++;
|
|
n |= (p->inv_amount[GET_BOOTS] > 0)<<6;
|
|
if (n&64) j++;
|
|
|
|
x = (160-(j*11))<<16; // nearly center
|
|
|
|
j = 0;
|
|
|
|
if (ud.screen_size < 8) // mini-HUDs or no HUD
|
|
{
|
|
y = 172<<16;
|
|
|
|
if (ud.screen_size == 4 && ud.althud == 1) // modern mini-HUD
|
|
y -= invensc(tilesiz[BIGALPHANUM].y+10); // slide on the y-axis
|
|
}
|
|
else // full HUD
|
|
{
|
|
y = (200<<16) - (sbarsc(tilesiz[BOTTOMSTATUSBAR].y<<16) + (12<<16) + (tilesiz[BOTTOMSTATUSBAR].y<<(16-1)));
|
|
|
|
if (!ud.statusbarmode) // original non-overlay mode
|
|
y += sbarsc(tilesiz[BOTTOMSTATUSBAR].y<<16)>>1; // account for the viewport y-size as the HUD scales
|
|
}
|
|
|
|
if (ud.screen_size == 4 && !ud.althud) // classic mini-HUD
|
|
x += invensc(ud.multimode > 1 ? 56 : 65); // slide on the x-axis
|
|
|
|
while (j <= 9)
|
|
{
|
|
if (n&(1<<j))
|
|
{
|
|
switch (n&(1<<j))
|
|
{
|
|
case 1:
|
|
rotatesprite_win(x, y, 65536L, 0, FIRSTAID_ICON, 0, 0, 2+16);
|
|
break;
|
|
case 2:
|
|
rotatesprite_win(x+(1<<16), y, 65536L, 0, STEROIDS_ICON, 0, 0, 2+16);
|
|
break;
|
|
case 4:
|
|
rotatesprite_win(x+(2<<16), y, 65536L, 0, HOLODUKE_ICON, 0, 0, 2+16);
|
|
break;
|
|
case 8:
|
|
rotatesprite_win(x, y, 65536L, 0, JETPACK_ICON, 0, 0, 2+16);
|
|
break;
|
|
case 16:
|
|
rotatesprite_win(x, y, 65536L, 0, HEAT_ICON, 0, 0, 2+16);
|
|
break;
|
|
case 32:
|
|
rotatesprite_win(x, y, 65536L, 0, AIRTANK_ICON, 0, 0, 2+16);
|
|
break;
|
|
case 64:
|
|
rotatesprite_win(x, y-(1<<16), 65536L, 0, BOOT_ICON, 0, 0, 2+16);
|
|
break;
|
|
}
|
|
|
|
x += 22<<16;
|
|
|
|
if (p->inven_icon == j+1)
|
|
rotatesprite_win(x-(2<<16), y+(19<<16), 65536L, 1024, ARROW, -32, 0, 2+16);
|
|
}
|
|
|
|
j++;
|
|
}
|
|
}
|
|
|
|
void G_DrawFrags(void)
|
|
{
|
|
if (ud.statusbarflags & STATUSBAR_NOFRAGBAR)
|
|
return;
|
|
|
|
int32_t i, j = 0;
|
|
const int32_t orient = 2+8+16+64;
|
|
|
|
for (TRAVERSE_CONNECT(i))
|
|
if (i > j)
|
|
j = i;
|
|
|
|
for (i=0; i<=(j>>2); i++)
|
|
rotatesprite_fs(0, (8*i)<<16, 65600, 0, FRAGBAR, 0, 0, orient);
|
|
|
|
for (TRAVERSE_CONNECT(i))
|
|
{
|
|
auto const ps = g_player[i].ps;
|
|
minitext(21+(73*(i&3)), 2+((i&28)<<1), g_player[i].user_name, ps->palookup, 2+8+16);
|
|
Bsprintf(tempbuf, "%d", ps->frag-ps->fraggedself);
|
|
minitext(17+50+(73*(i&3)), 2+((i&28)<<1), tempbuf, ps->palookup, 2+8+16);
|
|
}
|
|
}
|
|
|
|
static int32_t G_GetInvAmount(const DukePlayer_t *p)
|
|
{
|
|
switch (p->inven_icon)
|
|
{
|
|
case ICON_FIRSTAID:
|
|
return p->inv_amount[GET_FIRSTAID];
|
|
case ICON_STEROIDS:
|
|
return (p->inv_amount[GET_STEROIDS]+3)>>2;
|
|
case ICON_HOLODUKE:
|
|
return (p->inv_amount[GET_HOLODUKE]+15)/24;
|
|
case ICON_JETPACK:
|
|
return (p->inv_amount[GET_JETPACK]+15)>>4;
|
|
case ICON_HEATS:
|
|
return p->inv_amount[GET_HEATS]/12;
|
|
case ICON_SCUBA:
|
|
return (p->inv_amount[GET_SCUBA]+63)>>6;
|
|
case ICON_BOOTS:
|
|
return p->inv_amount[GET_BOOTS]>>1;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int32_t G_GetInvOn(const DukePlayer_t *p)
|
|
{
|
|
switch (p->inven_icon)
|
|
{
|
|
case ICON_HOLODUKE:
|
|
return p->holoduke_on;
|
|
case ICON_JETPACK:
|
|
return p->jetpack_on;
|
|
case ICON_HEATS:
|
|
return p->heat_on;
|
|
}
|
|
|
|
return 0x80000000;
|
|
}
|
|
|
|
static int32_t G_GetMorale(int32_t p_i, int32_t snum)
|
|
{
|
|
#if !defined LUNATIC
|
|
return Gv_GetVarByLabel("PLR_MORALE", -1, p_i, snum);
|
|
#else
|
|
UNREFERENCED_PARAMETER(p_i);
|
|
UNREFERENCED_PARAMETER(snum);
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
static inline void rotatesprite_althud(int32_t sx, int32_t sy, int32_t z, int16_t a, int16_t picnum, int8_t dashade, char dapalnum, int32_t dastat)
|
|
{
|
|
if (videoGetRenderMode() >= REND_POLYMOST && althud_shadows)
|
|
rotatesprite_(sbarx(sx+1), sbary(sy+1), z, a, picnum, 127, 4, dastat + POLYMOSTTRANS2, 0, 0, 0, 0, xdim - 1, ydim - 1);
|
|
rotatesprite_(sbarx(sx), sbary(sy), z, a, picnum, dashade, dapalnum, dastat, 0, 0, 0, 0, xdim - 1, ydim - 1);
|
|
}
|
|
|
|
static inline void rotatesprite_althudr(int32_t sx, int32_t sy, int32_t z, int16_t a, int16_t picnum, int8_t dashade, char dapalnum, int32_t dastat)
|
|
{
|
|
if (videoGetRenderMode() >= REND_POLYMOST && althud_shadows)
|
|
rotatesprite_(sbarxr(sx - 1), sbary(sy + 1), z, a, picnum, 127, 4, dastat + POLYMOSTTRANS2, 0, 0, 0, 0, xdim - 1, ydim - 1);
|
|
rotatesprite_(sbarxr(sx), sbary(sy), z, a, picnum, dashade, dapalnum, dastat, 0, 0, 0, 0, xdim - 1, ydim - 1);
|
|
}
|
|
|
|
void G_DrawStatusBar(int32_t snum)
|
|
{
|
|
auto const p = g_player[snum].ps;
|
|
int32_t i, j, o, u;
|
|
int32_t permbit = 0;
|
|
|
|
#ifdef SPLITSCREEN_MOD_HACKS
|
|
const int32_t ss = g_fakeMultiMode ? 4 : ud.screen_size;
|
|
const int32_t althud = g_fakeMultiMode ? 0 : ud.althud;
|
|
#else
|
|
const int32_t ss = ud.screen_size;
|
|
const int32_t althud = ud.althud;
|
|
#endif
|
|
|
|
const int32_t SBY = (200-tilesiz[BOTTOMSTATUSBAR].y);
|
|
|
|
const int32_t sb15 = sbarsc(32768), sb15h = sbarsc(49152);
|
|
const int32_t sb16 = sbarsc(65536);
|
|
|
|
static int32_t item_icons[8];
|
|
|
|
if (ss < 4)
|
|
return;
|
|
|
|
if (item_icons[0] == 0)
|
|
{
|
|
int32_t iicons[8] = { -1, FIRSTAID_ICON, STEROIDS_ICON, HOLODUKE_ICON,
|
|
JETPACK_ICON, HEAT_ICON, AIRTANK_ICON, BOOT_ICON };
|
|
Bmemcpy(item_icons, iicons, sizeof(item_icons));
|
|
}
|
|
|
|
if (videoGetRenderMode() >= REND_POLYMOST) pus = NUMPAGES; // JBF 20040101: always redraw in GL
|
|
|
|
if ((g_netServer || ud.multimode > 1) && ((g_gametypeFlags[ud.coop] & GAMETYPE_FRAGBAR)))
|
|
{
|
|
if (pus)
|
|
G_DrawFrags();
|
|
else
|
|
{
|
|
for (TRAVERSE_CONNECT(i))
|
|
if (g_player[i].ps->frag != sbar.frag[i])
|
|
{
|
|
G_DrawFrags();
|
|
break;
|
|
}
|
|
|
|
}
|
|
for (TRAVERSE_CONNECT(i))
|
|
if (i != myconnectindex)
|
|
sbar.frag[i] = g_player[i].ps->frag;
|
|
}
|
|
|
|
if (ss == 4) //DRAW MINI STATUS BAR:
|
|
{
|
|
if (althud)
|
|
{
|
|
// ALTERNATIVE STATUS BAR
|
|
|
|
int32_t hudoffset = ud.hudontop == 1 ? 32 : 200;
|
|
static int32_t ammo_sprites[MAX_WEAPONS];
|
|
|
|
if (EDUKE32_PREDICT_FALSE(ammo_sprites[0] == 0))
|
|
{
|
|
/* this looks stupid but it lets us initialize static memory to dynamic values
|
|
these values can be changed from the CONs with dynamic tile remapping
|
|
but we don't want to have to recreate the values in memory every time
|
|
the HUD is drawn */
|
|
|
|
int32_t asprites[MAX_WEAPONS] = { -1, AMMO, SHOTGUNAMMO, BATTERYAMMO,
|
|
RPGAMMO, HBOMBAMMO, CRYSTALAMMO, DEVISTATORAMMO,
|
|
TRIPBOMBSPRITE, FREEZEAMMO+1, HBOMBAMMO, GROWAMMO
|
|
};
|
|
Bmemcpy(ammo_sprites, asprites, sizeof(ammo_sprites));
|
|
}
|
|
|
|
// rotatesprite_fs(sbarx(5+1),sbary(200-25+1),sb15h,0,SIXPAK,0,4,10+16+1+32);
|
|
// rotatesprite_fs(sbarx(5),sbary(200-25),sb15h,0,SIXPAK,0,0,10+16);
|
|
rotatesprite_althud(2, hudoffset-21, sb15h, 0, COLA, 0, 0, 10+16+256);
|
|
|
|
if (sprite[p->i].pal == 1 && p->last_extra < 2)
|
|
G_DrawAltDigiNum(40, -(hudoffset-22), 1, -16, 10+16+256);
|
|
else if (!althud_flashing || p->last_extra >(p->max_player_health>>2) || totalclock&32)
|
|
{
|
|
int32_t s = -8;
|
|
if (althud_flashing && p->last_extra > p->max_player_health)
|
|
s += (sintable[(totalclock<<5)&2047]>>10);
|
|
G_DrawAltDigiNum(40, -(hudoffset-22), p->last_extra, s, 10+16+256);
|
|
}
|
|
|
|
rotatesprite_althud(62, hudoffset-25, sb15h, 0, SHIELD, 0, 0, 10+16+256);
|
|
|
|
{
|
|
int32_t lAmount = G_GetMorale(p->i, snum);
|
|
if (lAmount == -1)
|
|
lAmount = p->inv_amount[GET_SHIELD];
|
|
G_DrawAltDigiNum(105, -(hudoffset-22), lAmount, -16, 10+16+256);
|
|
}
|
|
|
|
if (ammo_sprites[p->curr_weapon] >= 0)
|
|
{
|
|
i = (tilesiz[ammo_sprites[p->curr_weapon]].y >= 50) ? 16384 : 32768;
|
|
rotatesprite_althudr(57, hudoffset-15, sbarsc(i), 0, ammo_sprites[p->curr_weapon], 0, 0, 10+512);
|
|
}
|
|
|
|
if (PWEAPON(snum, p->curr_weapon, WorksLike) == HANDREMOTE_WEAPON) i = HANDBOMB_WEAPON;
|
|
else i = p->curr_weapon;
|
|
|
|
if (PWEAPON(snum, p->curr_weapon, WorksLike) != KNEE_WEAPON &&
|
|
(!althud_flashing || totalclock&32 || p->ammo_amount[i] > (p->max_ammo_amount[i]/10)))
|
|
G_DrawAltDigiNum(-20, -(hudoffset-22), p->ammo_amount[i], -16, 10+16+512);
|
|
|
|
o = 102;
|
|
permbit = 0;
|
|
|
|
if (p->inven_icon)
|
|
{
|
|
const int32_t orient = 10+16+permbit+256;
|
|
|
|
i = ((unsigned) p->inven_icon < ICON_MAX) ? item_icons[p->inven_icon] : -1;
|
|
|
|
if (i >= 0)
|
|
rotatesprite_althud(231-o, hudoffset-21-2, sb16, 0, i, 0, 0, orient);
|
|
|
|
if (videoGetRenderMode() >= REND_POLYMOST && althud_shadows)
|
|
minitextshade(292-30-o+1, hudoffset-10-3+1, "%", 127, 4, POLYMOSTTRANS+orient+ROTATESPRITE_MAX);
|
|
minitext(292-30-o, hudoffset-10-3, "%", 6, orient+ROTATESPRITE_MAX);
|
|
|
|
i = G_GetInvAmount(p);
|
|
j = G_GetInvOn(p);
|
|
|
|
G_DrawInvNum(-(284-30-o), 0, hudoffset-6-3, (uint8_t) i, 0, 10+permbit+256);
|
|
|
|
if (j > 0)
|
|
{
|
|
if (videoGetRenderMode() >= REND_POLYMOST && althud_shadows)
|
|
minitextshade(288-30-o+1, hudoffset-20-3+1, "On", 127, 4, POLYMOSTTRANS+orient+ROTATESPRITE_MAX);
|
|
minitext(288-30-o, hudoffset-20-3, "On", 0, orient+ROTATESPRITE_MAX);
|
|
}
|
|
else if ((uint32_t) j != 0x80000000)
|
|
{
|
|
if (videoGetRenderMode() >= REND_POLYMOST && althud_shadows)
|
|
minitextshade(284-30-o+1, hudoffset-20-3+1, "Off", 127, 4, POLYMOSTTRANS+orient+ROTATESPRITE_MAX);
|
|
minitext(284-30-o, hudoffset-20-3, "Off", 2, orient+ROTATESPRITE_MAX);
|
|
}
|
|
|
|
if (p->inven_icon >= ICON_SCUBA)
|
|
{
|
|
if (videoGetRenderMode() >= REND_POLYMOST && althud_shadows)
|
|
minitextshade(284-35-o+1, hudoffset-20-3+1, "Auto", 127, 4, POLYMOSTTRANS+orient+ROTATESPRITE_MAX);
|
|
minitext(284-35-o, hudoffset-20-3, "Auto", 2, orient+ROTATESPRITE_MAX);
|
|
}
|
|
}
|
|
|
|
if (ud.hudontop == 1)
|
|
hudoffset += 40;
|
|
|
|
if (p->got_access&1) rotatesprite_althudr(39, hudoffset-43, sb15, 0, ACCESSCARD, 0, 0, 10+16+512);
|
|
if (p->got_access&4) rotatesprite_althudr(34, hudoffset-41, sb15, 0, ACCESSCARD, 0, 23, 10+16+512);
|
|
if (p->got_access&2) rotatesprite_althudr(29, hudoffset-39, sb15, 0, ACCESSCARD, 0, 21, 10+16+512);
|
|
}
|
|
else
|
|
{
|
|
// ORIGINAL MINI STATUS BAR
|
|
int32_t orient = 2+8+16+256, yofssh=0;
|
|
|
|
#ifdef SPLITSCREEN_MOD_HACKS
|
|
int32_t yofs=0;
|
|
|
|
if (g_fakeMultiMode)
|
|
{
|
|
const int32_t sidebyside = (ud.screen_size!=0);
|
|
|
|
if (sidebyside && snum==1)
|
|
{
|
|
orient |= RS_CENTERORIGIN;
|
|
}
|
|
else if (!sidebyside && snum==0)
|
|
{
|
|
yofs = -100;
|
|
yofssh = yofs<<16;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
rotatesprite_fs(sbarx(5), yofssh+sbary(200-28), sb16, 0, HEALTHBOX, 0, 21, orient);
|
|
if (p->inven_icon)
|
|
rotatesprite_fs(sbarx(69), yofssh+sbary(200-30), sb16, 0, INVENTORYBOX, 0, 21, orient);
|
|
|
|
// health
|
|
{
|
|
int32_t health = (sprite[p->i].pal == 1 && p->last_extra < 2) ? 1 : p->last_extra;
|
|
G_DrawDigiNum_(20, yofssh, 200-17, health, -16, orient);
|
|
}
|
|
|
|
rotatesprite_fs(sbarx(37), yofssh+sbary(200-28), sb16, 0, AMMOBOX, 0, 21, orient);
|
|
|
|
if (PWEAPON(snum, p->curr_weapon, WorksLike) == HANDREMOTE_WEAPON)
|
|
i = HANDBOMB_WEAPON;
|
|
else
|
|
i = p->curr_weapon;
|
|
G_DrawDigiNum_(53, yofssh, 200-17, p->ammo_amount[i], -16, orient);
|
|
|
|
o = 158;
|
|
permbit = 0;
|
|
if (p->inven_icon)
|
|
{
|
|
// orient |= permbit;
|
|
|
|
i = ((unsigned) p->inven_icon < ICON_MAX) ? item_icons[p->inven_icon] : -1;
|
|
if (i >= 0)
|
|
rotatesprite_fs(sbarx(231-o), yofssh+sbary(200-21), sb16, 0, i, 0, 0, orient);
|
|
|
|
// scale by status bar size
|
|
orient |= ROTATESPRITE_MAX;
|
|
|
|
minitext_yofs = yofssh;
|
|
minitext(292-30-o, 190, "%", 6, orient);
|
|
|
|
i = G_GetInvAmount(p);
|
|
j = G_GetInvOn(p);
|
|
|
|
G_DrawInvNum(284-30-o, yofssh, 200-6, (uint8_t) i, 0, orient&~16);
|
|
|
|
if (!WW2GI)
|
|
{
|
|
if (j > 0)
|
|
minitext(288-30-o, 180, "On", 0, orient);
|
|
else if ((uint32_t) j != 0x80000000)
|
|
minitext(284-30-o, 180, "Off", 2, orient);
|
|
}
|
|
|
|
if (p->inven_icon >= ICON_SCUBA)
|
|
minitext(284-35-o, 180, "Auto", 2, orient);
|
|
|
|
minitext_yofs = 0;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//DRAW/UPDATE FULL STATUS BAR:
|
|
|
|
if (pus)
|
|
{
|
|
pus = 0;
|
|
u = -1;
|
|
}
|
|
else u = 0;
|
|
|
|
if (sbar.frag[myconnectindex] != p->frag)
|
|
{
|
|
sbar.frag[myconnectindex] = p->frag;
|
|
u |= 32768;
|
|
}
|
|
if (sbar.got_access != p->got_access)
|
|
{
|
|
sbar.got_access = p->got_access;
|
|
u |= 16384;
|
|
}
|
|
|
|
if (sbar.last_extra != p->last_extra)
|
|
{
|
|
sbar.last_extra = p->last_extra;
|
|
u |= 1;
|
|
}
|
|
|
|
{
|
|
int32_t lAmount = G_GetMorale(p->i, snum);
|
|
if (lAmount == -1)
|
|
lAmount = p->inv_amount[GET_SHIELD];
|
|
if (sbar.inv_amount[GET_SHIELD] != lAmount)
|
|
{
|
|
sbar.inv_amount[GET_SHIELD] = lAmount;
|
|
u |= 2;
|
|
}
|
|
}
|
|
|
|
if (sbar.curr_weapon != p->curr_weapon)
|
|
{
|
|
sbar.curr_weapon = p->curr_weapon;
|
|
u |= (4+8+16+32+64+128+256+512+1024+65536L);
|
|
}
|
|
|
|
for (i=1; i<MAX_WEAPONS; i++)
|
|
{
|
|
if (sbar.ammo_amount[i] != p->ammo_amount[i])
|
|
{
|
|
sbar.ammo_amount[i] = p->ammo_amount[i];
|
|
if (i < 9)
|
|
u |= ((2<<i)+1024);
|
|
else if (WW2GI && i == 11)
|
|
u |= 1024 + 128;
|
|
else
|
|
u |= 65536L+1024;
|
|
}
|
|
|
|
if ((sbar.gotweapon & (1<<i)) != (p->gotweapon & (1<<i)))
|
|
{
|
|
if (p->gotweapon & (1<<i))
|
|
sbar.gotweapon |= 1<<i;
|
|
else sbar.gotweapon &= ~(1<<i);
|
|
|
|
if (i < 9)
|
|
u |= ((2<<i)+1024);
|
|
else
|
|
u |= 65536L+1024;
|
|
}
|
|
}
|
|
|
|
if (sbar.inven_icon != p->inven_icon)
|
|
{
|
|
sbar.inven_icon = p->inven_icon;
|
|
u |= (2048+4096+8192);
|
|
}
|
|
if (sbar.holoduke_on != p->holoduke_on)
|
|
{
|
|
sbar.holoduke_on = p->holoduke_on;
|
|
u |= (4096+8192);
|
|
}
|
|
if (sbar.jetpack_on != p->jetpack_on)
|
|
{
|
|
sbar.jetpack_on = p->jetpack_on;
|
|
u |= (4096+8192);
|
|
}
|
|
if (sbar.heat_on != p->heat_on)
|
|
{
|
|
sbar.heat_on = p->heat_on;
|
|
u |= (4096+8192);
|
|
}
|
|
|
|
{
|
|
static const int32_t check_items [] = {
|
|
GET_FIRSTAID, GET_STEROIDS, GET_HOLODUKE, GET_JETPACK,
|
|
GET_HEATS, GET_SCUBA, GET_BOOTS
|
|
};
|
|
|
|
for (i=0; i<(int32_t)sizeof(check_items)/(int32_t)sizeof(check_items[0]); i++)
|
|
{
|
|
int32_t item = check_items[i];
|
|
|
|
if (sbar.inv_amount[item] != p->inv_amount[item])
|
|
{
|
|
sbar.inv_amount[item] = p->inv_amount[item];
|
|
u |= 8192;
|
|
}
|
|
}
|
|
}
|
|
#if 0
|
|
if (u == 0)
|
|
return;
|
|
#else
|
|
// FIXME: full status bar draws rectangles in the wrong places when it's
|
|
// updated partially.
|
|
u = -1;
|
|
#endif
|
|
|
|
//0 - update health
|
|
//1 - update armor
|
|
//2 - update PISTOL_WEAPON ammo
|
|
//3 - update SHOTGUN_WEAPON ammo
|
|
//4 - update CHAINGUN_WEAPON ammo
|
|
//5 - update RPG_WEAPON ammo
|
|
//6 - update HANDBOMB_WEAPON ammo
|
|
//7 - update SHRINKER_WEAPON ammo
|
|
//8 - update DEVISTATOR_WEAPON ammo
|
|
//9 - update TRIPBOMB_WEAPON ammo
|
|
//10 - update ammo display
|
|
//11 - update inventory icon
|
|
//12 - update inventory on/off
|
|
//13 - update inventory %
|
|
//14 - update keys
|
|
//15 - update kills
|
|
//16 - update FREEZE_WEAPON ammo
|
|
|
|
if (u == -1)
|
|
{
|
|
G_PatchStatusBar(0, 0, 320, 200);
|
|
if ((g_netServer || ud.multimode > 1) && (g_gametypeFlags[ud.coop] & GAMETYPE_FRAGBAR))
|
|
rotatesprite_fs(sbarx(277+1), sbary(SBY+7-1), sb16, 0, KILLSICON, 0, 0, 10+16);
|
|
}
|
|
|
|
if ((g_netServer || ud.multimode > 1) && (g_gametypeFlags[ud.coop] & GAMETYPE_FRAGBAR))
|
|
{
|
|
if (u&32768)
|
|
{
|
|
if (u != -1) G_PatchStatusBar(276, SBY+17, 299, SBY+17+10);
|
|
G_DrawDigiNum(287, SBY+17, max(p->frag-p->fraggedself, 0), -16, 10+16);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (u&16384)
|
|
{
|
|
if (u != -1) G_PatchStatusBar(275, SBY+18, 299, SBY+18+12);
|
|
if (p->got_access&4) rotatesprite_fs(sbarx(275), sbary(SBY+16), sb16, 0, ACCESS_ICON, 0, 23, 10+16);
|
|
if (p->got_access&2) rotatesprite_fs(sbarx(288), sbary(SBY+16), sb16, 0, ACCESS_ICON, 0, 21, 10+16);
|
|
if (p->got_access&1) rotatesprite_fs(sbarx(281), sbary(SBY+23), sb16, 0, ACCESS_ICON, 0, 0, 10+16);
|
|
}
|
|
}
|
|
|
|
if (u&(4+8+16+32+64+128+256+512+65536L))
|
|
G_DrawWeapAmounts(p, 96, SBY+16, u);
|
|
|
|
if (u&1)
|
|
{
|
|
if (u != -1) G_PatchStatusBar(20, SBY+17, 43, SBY+17+11);
|
|
if (sprite[p->i].pal == 1 && p->last_extra < 2)
|
|
G_DrawDigiNum(32, SBY+17, 1, -16, 10+16);
|
|
else G_DrawDigiNum(32, SBY+17, p->last_extra, -16, 10+16);
|
|
}
|
|
if (u&2)
|
|
{
|
|
int32_t lAmount = G_GetMorale(p->i, snum);
|
|
|
|
if (u != -1)
|
|
G_PatchStatusBar(52, SBY+17, 75, SBY+17+11);
|
|
|
|
if (lAmount == -1)
|
|
G_DrawDigiNum(64, SBY+17, p->inv_amount[GET_SHIELD], -16, 10+16);
|
|
else
|
|
G_DrawDigiNum(64, SBY+17, lAmount, -16, 10+16);
|
|
}
|
|
|
|
if (u&1024)
|
|
{
|
|
if (u != -1) G_PatchStatusBar(196, SBY+17, 219, SBY+17+11);
|
|
if (PWEAPON(snum, p->curr_weapon, WorksLike) != KNEE_WEAPON)
|
|
{
|
|
if (PWEAPON(snum, p->curr_weapon, WorksLike) == HANDREMOTE_WEAPON) i = HANDBOMB_WEAPON;
|
|
else i = p->curr_weapon;
|
|
G_DrawDigiNum(230-22, SBY+17, p->ammo_amount[i], -16, 10+16);
|
|
}
|
|
}
|
|
|
|
if (u&(2048+4096+8192))
|
|
{
|
|
if (u != -1)
|
|
{
|
|
if (u&(2048+4096))
|
|
G_PatchStatusBar(231, SBY+13, 265, SBY+13+18);
|
|
else
|
|
G_PatchStatusBar(250, SBY+24, 261, SBY+24+6);
|
|
}
|
|
|
|
if (p->inven_icon)
|
|
{
|
|
o = 0;
|
|
// permbit = 128;
|
|
|
|
if (u&(2048+4096))
|
|
{
|
|
i = ((unsigned) p->inven_icon < ICON_MAX) ? item_icons[p->inven_icon] : -1;
|
|
// XXX: i < 0?
|
|
rotatesprite_fs(sbarx(231-o), sbary(SBY+13), sb16, 0, i, 0, 0, 10+16+permbit);
|
|
minitext(292-30-o, SBY+24, "%", 6, 10+16+permbit + ROTATESPRITE_MAX);
|
|
if (p->inven_icon >= ICON_SCUBA) minitext(284-35-o, SBY+14, "Auto", 2, 10+16+permbit + ROTATESPRITE_MAX);
|
|
}
|
|
|
|
if (u&(2048+4096) && !WW2GI)
|
|
{
|
|
j = G_GetInvOn(p);
|
|
|
|
if (j > 0) minitext(288-30-o, SBY+14, "On", 0, 10+16+permbit + ROTATESPRITE_MAX);
|
|
else if ((uint32_t) j != 0x80000000) minitext(284-30-o, SBY+14, "Off", 2, 10+16+permbit + ROTATESPRITE_MAX);
|
|
}
|
|
|
|
if (u&8192)
|
|
{
|
|
i = G_GetInvAmount(p);
|
|
G_DrawInvNum(284-30-o, 0, SBY+28, (uint8_t) i, 0, 10+permbit);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void G_DrawBackground(void)
|
|
{
|
|
int32_t x, y, x1, x2;
|
|
|
|
renderFlushPerms();
|
|
|
|
int32_t y1=0, y2=ydim;
|
|
|
|
if ((g_player[myconnectindex].ps->gm&MODE_GAME) == 0 && ud.recstat != 2)
|
|
{
|
|
const int32_t MENUTILE = MENUSCREEN;//(videoGetRenderMode() == REND_CLASSIC ? MENUSCREEN : LOADSCREEN);
|
|
const int32_t fstilep = tilesiz[MENUTILE].x>=320 && tilesiz[MENUTILE].y==200;
|
|
int32_t bgtile = (fstilep ? MENUTILE : BIGHOLE);
|
|
|
|
videoClearScreen(0);
|
|
|
|
// when not rendering a game, fullscreen wipe
|
|
// Gv_SetVar(g_iReturnVarID,tilesizx[MENUTILE]==320&&tilesizy[MENUTILE]==200?MENUTILE:BIGHOLE, -1, -1);
|
|
bgtile = VM_OnEventWithReturn(EVENT_GETMENUTILE, g_player[screenpeek].ps->i, screenpeek, bgtile);
|
|
// MENU_TILE: is the menu tile tileable?
|
|
#if !defined LUNATIC
|
|
if (Gv_GetVarByLabel("MENU_TILE", !fstilep, -1, -1))
|
|
#else
|
|
if (!fstilep)
|
|
#endif
|
|
{
|
|
if ((unsigned) bgtile < MAXTILES)
|
|
for (y=y1; y<y2; y+=tilesiz[bgtile].y)
|
|
for (x=0; x<xdim; x+=tilesiz[bgtile].x)
|
|
rotatesprite_fs(x<<16, y<<16, 65536L, 0, bgtile, 8, 0, 8+16+64);
|
|
}
|
|
else rotatesprite_fs(160<<16, 100<<16, 65536L, 0, bgtile, 16, 0, 2+8+64+BGSTRETCH);
|
|
|
|
return;
|
|
}
|
|
|
|
int32_t const dapicnum = VM_OnEventWithReturn(EVENT_DISPLAYBORDER, g_player[screenpeek].ps->i, screenpeek, BIGHOLE);
|
|
|
|
// XXX: if dapicnum is not available, this might leave the menu background
|
|
// not drawn, leading to "HOM".
|
|
if ((dapicnum >= 0 && tilesiz[dapicnum].x == 0) || (dapicnum >= 0 && tilesiz[dapicnum].y == 0) ||
|
|
(windowxy1.x-1 <= 0 && windowxy2.x >= xdim-1 && windowxy1.y-1 <= 0 && windowxy2.y >= ydim-1) ||
|
|
dapicnum < 0)
|
|
{
|
|
pus = pub = NUMPAGES;
|
|
return;
|
|
}
|
|
|
|
y1 = fragbarheight();
|
|
if (y1 != 0)
|
|
{
|
|
y1 = scale(ydim, y1, 200);
|
|
y1 -= ((tilesiz[dapicnum].y / y1) +1) * tilesiz[dapicnum].y;
|
|
}
|
|
|
|
if (windowxy1.y > 0)
|
|
{
|
|
for (y=y1; y<windowxy1.y; y+=tilesiz[dapicnum].y)
|
|
for (x=0; x<xdim; x+=tilesiz[dapicnum].x)
|
|
rotatesprite(x<<16, y<<16, 65536L, 0, dapicnum, 8, 0, 8+16+64, 0, 0, xdim-1, windowxy1.y-2); // top
|
|
}
|
|
|
|
if (windowxy1.x > 0 || windowxy2.x < xdim)
|
|
{
|
|
const int32_t rx = windowxy2.x-windowxy2.x%tilesiz[dapicnum].x;
|
|
for (y=y1+windowxy1.y-windowxy1.y%tilesiz[dapicnum].y; y<windowxy2.y; y+=tilesiz[dapicnum].y)
|
|
for (x=0; x<windowxy1.x || x+rx<xdim; x+=tilesiz[dapicnum].x)
|
|
{
|
|
if (windowxy1.x > 0)
|
|
rotatesprite(x<<16, y<<16, 65536L, 0, dapicnum, 8, 0, 8+16+64, 0, windowxy1.y-1, windowxy1.x-2, windowxy2.y); // left
|
|
if (windowxy2.x < xdim)
|
|
rotatesprite((x+rx)<<16, y<<16, 65536L, 0, dapicnum, 8, 0, 8+16+64, windowxy2.x+1, windowxy1.y-1, xdim-1, windowxy2.y); // right
|
|
}
|
|
}
|
|
|
|
if (windowxy2.y < ydim)
|
|
{
|
|
for (y=y1+windowxy2.y-(windowxy2.y%tilesiz[dapicnum].y); y<y2; y+=tilesiz[dapicnum].y)
|
|
for (x=0; x<xdim; x+=tilesiz[dapicnum].x)
|
|
rotatesprite(x<<16, y<<16, 65536L, 0, dapicnum, 8, 0, 8+16+64, 0, windowxy2.y+1, xdim-1, ydim-1); // bottom
|
|
}
|
|
|
|
x1 = windowxy1.x-4;
|
|
y1 = windowxy1.y-4;
|
|
x2 = windowxy2.x+4;
|
|
y2 = windowxy2.y+4;
|
|
|
|
if (windowxy1.x > 0 || windowxy2.x < xdim)
|
|
for (y=y1+4; y<y2-4; y+=64)
|
|
{
|
|
if (windowxy1.x > 0)
|
|
rotatesprite(x1<<16, y<<16, 65536L, 0, VIEWBORDER, 0, 0, 8+16+64, x1, y1, x2, y2); // left
|
|
if (windowxy2.x < xdim)
|
|
rotatesprite((x2+1)<<16, (y+64)<<16, 65536L, 1024, VIEWBORDER, 0, 0, 8+16+64, x1, y1, x2, y2); // right
|
|
}
|
|
|
|
if (windowxy1.y > 0 || windowxy2.y < ydim)
|
|
for (x=x1+4; x<x2-4; x+=64)
|
|
{
|
|
if (windowxy1.y > 0)
|
|
rotatesprite((x+64)<<16, y1<<16, 65536L, 512, VIEWBORDER, 0, 0, 8+16+64, x1, y1, x2, y2); // top
|
|
if (windowxy2.y < ydim)
|
|
rotatesprite(x<<16, (y2+1)<<16, 65536L, 1536, VIEWBORDER, 0, 0, 8+16+64, x1, y1, x2, y2); // bottom
|
|
}
|
|
|
|
if (windowxy1.x > 0 && windowxy1.y > 0)
|
|
rotatesprite(x1<<16, y1<<16, 65536L, 0, VIEWBORDER+1, 0, 0, 8+16+64, x1, y1, x2, y2); // top left
|
|
if (windowxy2.x < xdim && windowxy1.y > 0)
|
|
rotatesprite((x2+1)<<16, y1<<16, 65536L, 512, VIEWBORDER+1, 0, 0, 8+16+64, x1, y1, x2, y2); // top right
|
|
if (windowxy2.x < xdim && windowxy2.y < ydim)
|
|
rotatesprite((x2+1)<<16, (y2+1)<<16, 65536L, 1024, VIEWBORDER+1, 0, 0, 8+16+64, x1, y1, x2, y2); // bottom right
|
|
if (windowxy1.x > 0 && windowxy2.y < ydim)
|
|
rotatesprite(x1<<16, (y2+1)<<16, 65536L, 1536, VIEWBORDER+1, 0, 0, 8+16+64, x1, y1, x2, y2); // bottom left
|
|
|
|
pus = pub = NUMPAGES;
|
|
}
|