From 2a9cda7ea868078f925bf536c386c01f8abd750a Mon Sep 17 00:00:00 2001 From: Spoike Date: Fri, 15 Oct 2004 00:37:21 +0000 Subject: [PATCH] sbar plugin. Supports click + drag hud elements. git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@338 fc73d0e0-1445-4013-8a0c-d673dee63da5 --- plugins/hud/ui_sbar.c | 1172 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1172 insertions(+) create mode 100644 plugins/hud/ui_sbar.c diff --git a/plugins/hud/ui_sbar.c b/plugins/hud/ui_sbar.c new file mode 100644 index 000000000..14787596b --- /dev/null +++ b/plugins/hud/ui_sbar.c @@ -0,0 +1,1172 @@ +#include "../plugin.h" + +#define MAX_ELEMENTS 128 + +int K_UPARROW; +int K_DOWNARROW; +int K_LEFTARROW; +int K_RIGHTARROW; +int K_ESCAPE; +int K_MOUSE1; +int K_HOME; +int K_SHIFT; + + +#define MAX_CL_STATS 32 +#define STAT_HEALTH 0 +#define STAT_WEAPON 2 +#define STAT_AMMO 3 +#define STAT_ARMOR 4 +#define STAT_WEAPONFRAME 5 +#define STAT_SHELLS 6 +#define STAT_NAILS 7 +#define STAT_ROCKETS 8 +#define STAT_CELLS 9 +#define STAT_ACTIVEWEAPON 10 +#define STAT_TOTALSECRETS 11 +#define STAT_TOTALMONSTERS 12 +#define STAT_SECRETS 13 // bumped on client side by svc_foundsecret +#define STAT_MONSTERS 14 // bumped by svc_killedmonster +#define STAT_ITEMS 15 + +//some engines can use more. +//any mod specific ones should be 31 and downwards rather than upwards. + + +#define IT_GUN1 (1<<0) +#define IT_GUN2 (1<<1) //the code assumes these are linear. +#define IT_GUN3 (1<<2) //be careful with strange mods. +#define IT_GUN4 (1<<3) +#define IT_GUN5 (1<<4) +#define IT_GUN6 (1<<5) +#define IT_GUN7 (1<<6) +#define IT_GUN8 (1<<7) //quake doesn't normally use this. + +#define IT_AMMO1 (1<<8) +#define IT_AMMO2 (1<<9) +#define IT_AMMO3 (1<<10) +#define IT_AMMO4 (1<<11) + +#define IT_GUN0 (1<<12) + +#define IT_ARMOR1 (1<<13) +#define IT_ARMOR2 (1<<14) +#define IT_ARMOR3 (1<<15) +#define IT_SUPERHEALTH (1<<16) + +#define IT_PUP1 (1<<17) +#define IT_PUP2 (1<<18) +#define IT_PUP3 (1<<19) +#define IT_PUP4 (1<<20) +#define IT_PUP5 (1<<21) +#define IT_PUP6 (1<<22) + +#define IT_RUNE1 (1<<23) +#define IT_RUNE2 (1<<24) +#define IT_RUNE3 (1<<25) +#define IT_RUNE4 (1<<26) + +//these are linear and treated the same +#define numpups 6 + +//the names of the cvars, as they will appear on the console +#define UI_NOSBAR "ui_defaultsbar" +#define UI_NOIBAR "ui_noibar" +#define UI_NOFLASH "ui_nosbarflash" + +static char *weaponabbreviation[] = { //the postfix for the weapon anims + "shotgun", + "sshotgun", + "nailgun", + "snailgun", + "rlaunch", //grenades actually. + "srlaunch", + "lightng" +}; +#define numweaps (sizeof(weaponabbreviation) / sizeof(char *)) + +static char *pupabbr[] = { //the postfix for the powerup anims + "key1", + "key2", + "invis", + "invul", + "suit", + "quad" +}; +static char *pupabbr2[] = { //the postfix for the powerup anims + "key1", + "key2", + "invis", + "invuln", + "suit", + "quad" +}; + +//0 = owned, 1 selected, 2-7 flashing +static qhandle_t con_chars; +static qhandle_t pic_weapon[8][numweaps]; +static qhandle_t sbarback, ibarback; + +//0 = owned, 1-6 flashing +static qhandle_t pic_pup[7][numpups]; +static qhandle_t pic_armour[3]; +static qhandle_t pic_ammo[4]; +static qhandle_t pic_rune[4]; +static qhandle_t pic_num[13]; +static qhandle_t pic_anum[11]; + +//faces +static qhandle_t pic_face[5]; +static qhandle_t pic_facep[5]; +static qhandle_t pic_facequad; +static qhandle_t pic_faceinvis; +static qhandle_t pic_faceinvisinvuln; +static qhandle_t pic_faceinvuln; +static qhandle_t pic_faceinvulnquad; + +static int currenttime; +static int gotweapontime[numweaps]; +static int gotpuptime[numpups]; + +float sbarminx; +float sbarminy; +float sbarscalex; +float sbarscaley; + +static int hudedit; + +enum { + DZ_BOTTOMLEFT, + DZ_BOTTOMRIGHT +}; + +typedef struct { + int width; + int height; + float defaultx; //used if couldn't load a config + float defaulty; + int defaultzone; + float defaultalpha; + void (*DrawElement)(void); +} hudelementtype_t; + +void Hud_SBar(void); +void Hud_ArmourPic(void); +void Hud_ArmourBig(void); +void Hud_HealthPic(void); +void Hud_HealthBig(void); +void Hud_CurrentAmmoPic(void); +void Hud_CurrentAmmoBig(void); +void Hud_IBar(void); +void Hud_W_Shotgun(void); +void Hud_W_SuperShotgun(void); +void Hud_W_Nailgun(void); +void Hud_W_SuperNailgun(void); +void Hud_W_GrenadeLauncher(void); +void Hud_W_RocketLauncher(void); +void Hud_W_Lightning(void); +void Hud_Key1(void); +void Hud_Key2(void); +void Hud_PUPInvis(void); +void Hud_PUPInvuln(void); +void Hud_PUPSuit(void); +void Hud_PUPQuad(void); +void Hud_Rune1(void); +void Hud_Rune2(void); +void Hud_Rune3(void); +void Hud_Rune4(void); +void Hud_Shells(void); +void Hud_Nails(void); +void Hud_Rockets(void); +void Hud_Cells(void); + +hudelementtype_t hetype[] = { + { + 320, 24, + 0, -24, DZ_BOTTOMLEFT, + 0.3f, + Hud_SBar + }, + + { + 24, 24, + 0, -24, DZ_BOTTOMLEFT, + 1, + Hud_ArmourPic + }, + { + 24*3, 24, + 24, -24, DZ_BOTTOMLEFT, + 1, + Hud_ArmourBig + }, + + { + 24, 24, + 112, -24, DZ_BOTTOMLEFT, + 1, + Hud_HealthPic + }, + { + 24*3, 24, + 24*6, -24, DZ_BOTTOMLEFT, + 1, + Hud_HealthBig + }, + + { + 24*3, 24, + 224, -24, DZ_BOTTOMLEFT, + 1, + Hud_CurrentAmmoPic + }, + { + 24*3, 24, + 248, -24, DZ_BOTTOMLEFT, + 1, + Hud_CurrentAmmoBig + }, + + { + 320, 24, + 0, -48, DZ_BOTTOMLEFT, + 0.3f, + Hud_IBar + }, + + { + 24, 16, + 0, -40, DZ_BOTTOMLEFT, + 1, + Hud_W_Shotgun + }, + { + 24, 16, + 24, -40, DZ_BOTTOMLEFT, + 1, + Hud_W_SuperShotgun + }, + { + 24, 16, + 48, -40, DZ_BOTTOMLEFT, + 1, + Hud_W_Nailgun + }, + { + 24, 16, + 72, -40, DZ_BOTTOMLEFT, + 1, + Hud_W_SuperNailgun + }, + { + 24, 16, + 96, -40, DZ_BOTTOMLEFT, + 1, + Hud_W_GrenadeLauncher + }, + { + 24, 16, + 120, -40, DZ_BOTTOMLEFT, + 1, + Hud_W_RocketLauncher + }, + { + 24, 16, + 146, -40, DZ_BOTTOMLEFT, + 1, + Hud_W_Lightning + }, + { + 24, 16, + 194, -40, DZ_BOTTOMLEFT, + 0.3f, + Hud_Key1 + }, + { + 24, 16, + 208, -40, DZ_BOTTOMLEFT, + 0.3f, + Hud_Key2 + }, + { + 24, 16, + 224, -40, DZ_BOTTOMLEFT, + 1, + Hud_PUPInvis + }, + { + 24, 16, + 240, -40, DZ_BOTTOMLEFT, + 1, + Hud_PUPInvuln + }, + { + 24, 16, + 256, -40, DZ_BOTTOMLEFT, + 1, + Hud_PUPSuit + }, + { + 24, 16, + 272, -40, DZ_BOTTOMLEFT, + 1, + Hud_PUPQuad + }, + { + 24, 16, + 288, -40, DZ_BOTTOMLEFT, + 0.3f, + Hud_Rune1 + }, + { + 24, 16, + 296, -40, DZ_BOTTOMLEFT, + 0.3f, + Hud_Rune2 + }, + { + 24, 16, + 304, -40, DZ_BOTTOMLEFT, + 0.3f, + Hud_Rune3 + }, + { + 24, 16, + 312, -40, DZ_BOTTOMLEFT, + 0.3f, + Hud_Rune4 + }, + + { + 42, 11, + 0, -48, DZ_BOTTOMLEFT, + 1, + Hud_Shells + }, + { + 42, 11, + 42, -48, DZ_BOTTOMLEFT, + 1, + Hud_Nails + }, + { + 42, 11, + 42*2, -48, DZ_BOTTOMLEFT, + 1, + Hud_Rockets + }, + { + 42, 11, + 42*3, -48, DZ_BOTTOMLEFT, + 1, + Hud_Cells + } +}; +typedef struct { + int type; + + float x, y; + float scalex; + float scaley; + float alpha; +} hudelement_t; +hudelement_t element[MAX_ELEMENTS]; //look - Spike used a constant - that's a turn up for the books! +int numelements; + +void UI_DrawPic(qhandle_t pic, int x, int y, int width, int height) +{ + Draw_Image((float)x*sbarscalex+sbarminx, (float)y*sbarscaley+sbarminy, (float)width*sbarscalex, (float)height*sbarscaley, 0, 0, 1, 1, pic); +} +void UI_DrawChar(unsigned int c, int x, int y) +{ +static float size = 1.0f/16.0f; + float s1 = size * (c&15); + float t1 = size * (c>>4); + Draw_Image((float)x*sbarscalex+sbarminx, (float)y*sbarscaley+sbarminy, 8*sbarscalex, 8*sbarscaley, s1, t1, s1+size, t1+size, con_chars); +} + +void UI_DrawBigNumber(int num, int x, int y, qboolean red) +{ + char *s; + int len; + s = va("%i", num); + + + len = strlen(s); + if (len < 3) + x += 24*(3-len); + else + s += len-3; + + if (red) + { + while(*s) + { + if (*s == '-') + UI_DrawPic (pic_anum[10], x, y, 24, 24); + else + UI_DrawPic (pic_anum[*s-'0'], x, y, 24, 24); + s++; + x+=24; + } + } + else + { + while(*s) + { + if (*s == '-') + UI_DrawPic (pic_num[10], x, y, 24, 24); + else + UI_DrawPic (pic_num[*s-'0'], x, y, 24, 24); + s++; + x+=24; + } + } +} + +void SBar_FlushAll(void) +{ + numelements = 0; +} + +void SBar_ReloadDefaults(void) +{ + int i; + for (i = 0; i < sizeof(hetype)/sizeof(hetype[0]); i++) + { + if (hetype[i].defaultalpha) + { + if (numelements >= MAX_ELEMENTS) + break; + element[numelements].type = i; + element[numelements].alpha = hetype[i].defaultalpha; + element[numelements].scalex = 1; + element[numelements].scaley = 1; + switch(hetype[i].defaultzone) + { + case DZ_BOTTOMLEFT: + element[numelements].x = hetype[i].defaultx; + element[numelements].y = 480+hetype[i].defaulty; + break; + case DZ_BOTTOMRIGHT: + element[numelements].x = 640+hetype[i].defaultx; + element[numelements].y = 480+hetype[i].defaulty; + break; + } + numelements++; + } + } +} + +void UI_SbarInit(void) +{ + int i; + int j; + +//main bar (add cvars later) + ibarback = Draw_LoadImage("ibar", true); + sbarback = Draw_LoadImage("sbar", true); + + con_chars = Draw_LoadImage("conchars", true); + +//load images. + for (i = 0; i < 10; i++) + { + pic_num[i] = Draw_LoadImage(va("num_%i", i), true); + pic_anum[i] = Draw_LoadImage(va("anum_%i", i), true); + } + pic_num[10] = Draw_LoadImage("num_minus", true); + pic_anum[10] = Draw_LoadImage("anum_minus", true); + pic_num[11] = Draw_LoadImage("num_colon", true); + pic_num[12] = Draw_LoadImage("num_slash", true); + + for (i = 0; i < numweaps; i++) + { + gotweapontime[i] = 0; + pic_weapon[0][i] = Draw_LoadImage(va("inv_%s", weaponabbreviation[i]), true); + pic_weapon[1][i] = Draw_LoadImage(va("inv2_%s", weaponabbreviation[i]), true); + for (j = 0; j < 5; j++) + { + pic_weapon[2+j][i] = Draw_LoadImage(va("inva%i_%s", j+1, weaponabbreviation[i]), true); + } + } + for (i = 0; i < numpups; i++) + { + gotpuptime[i] = 0; + pic_pup[0][i] = Draw_LoadImage(va("sb_%s", pupabbr2[i]), true); + for (j = 0; j < 5; j++) + { + pic_pup[1+j][i] = Draw_LoadImage(va("sba%i_%s", j+1, pupabbr[i]), true); + } + } + pic_armour[0] = Draw_LoadImage("sb_armor1", true); + pic_armour[1] = Draw_LoadImage("sb_armor2", true); + pic_armour[2] = Draw_LoadImage("sb_armor3", true); + + pic_ammo[0] = Draw_LoadImage("sb_shells", true); + pic_ammo[1] = Draw_LoadImage("sb_nails", true); + pic_ammo[2] = Draw_LoadImage("sb_rocket", true); + pic_ammo[3] = Draw_LoadImage("sb_cells", true); + + pic_rune[0] = Draw_LoadImage("sb_sigil1", true); + pic_rune[1] = Draw_LoadImage("sb_sigil2", true); + pic_rune[2] = Draw_LoadImage("sb_sigil3", true); + pic_rune[3] = Draw_LoadImage("sb_sigil4", true); + + pic_face[0] = Draw_LoadImage("face1", true); + pic_face[1] = Draw_LoadImage("face2", true); + pic_face[2] = Draw_LoadImage("face3", true); + pic_face[3] = Draw_LoadImage("face4", true); + pic_face[4] = Draw_LoadImage("face5", true); + + pic_facep[0] = Draw_LoadImage("face_p1", true); + pic_facep[1] = Draw_LoadImage("face_p2", true); + pic_facep[2] = Draw_LoadImage("face_p3", true); + pic_facep[3] = Draw_LoadImage("face_p4", true); + pic_facep[4] = Draw_LoadImage("face_p5", true); + + pic_facequad = Draw_LoadImage("face_quad", true); + pic_faceinvis = Draw_LoadImage("face_invis", true); + pic_faceinvisinvuln = Draw_LoadImage("face_inv2", true); + pic_faceinvuln = Draw_LoadImage("face_invul1", true); + pic_faceinvulnquad = Draw_LoadImage("face_invul2", true); + + SBar_FlushAll(); + SBar_ReloadDefaults(); +} + +unsigned int stats[MAX_CL_STATS]; + +void Hud_SBar(void) +{ + UI_DrawPic(sbarback, 0, 0, 320, 24); +} +void Hud_ArmourPic(void) +{ + if (stats[STAT_ITEMS] & IT_ARMOR3) + UI_DrawPic(pic_armour[2], 0, 0, 24, 24); + else if (stats[STAT_ITEMS] & IT_ARMOR2) + UI_DrawPic(pic_armour[1], 0, 0, 24, 24); + else if (stats[STAT_ITEMS] & IT_ARMOR1) + UI_DrawPic(pic_armour[0], 0, 0, 24, 24); +} +void Hud_ArmourBig(void) +{ + int i = stats[STAT_ARMOR]; + UI_DrawBigNumber(i, 0, 0, i < 25); +} +void Hud_HealthPic(void) +{ + int hl; + + if (stats[STAT_ITEMS] & IT_PUP3) + { //invisability + if (stats[STAT_ITEMS] & IT_PUP4) + UI_DrawPic(pic_faceinvisinvuln, 0, 0, 24, 24); + else + UI_DrawPic(pic_faceinvis, 0, 0, 24, 24); + return; + } + + if (stats[STAT_ITEMS] & IT_PUP4) + { //invuln + if (stats[STAT_ITEMS] & IT_PUP6) + UI_DrawPic(pic_faceinvulnquad, 0, 0, 24, 24); + else + UI_DrawPic(pic_faceinvuln, 0, 0, 24, 24); + return; + } + if (stats[STAT_ITEMS] & IT_PUP6) + { + UI_DrawPic(pic_facequad, 0, 0, 24, 24); + return; + } + + hl = stats[STAT_HEALTH]/20; + if (hl > 4) + hl = 4; + if (hl < 0) + hl = 0; +// if (innpain) +// UI_DrawPic(pic_facep[4-hl], 0, 0, 24, 24); +// else + UI_DrawPic(pic_face[4-hl], 0, 0, 24, 24); +} +void Hud_HealthBig(void) +{ + int i = stats[STAT_HEALTH]; + UI_DrawBigNumber(i, 0, 0, i < 25); +} + +void Hud_CurrentAmmoPic(void) +{ + if (stats[STAT_ITEMS] & IT_AMMO1) + UI_DrawPic(pic_ammo[0], 0, 0, 24, 24); + else if (stats[STAT_ITEMS] & IT_AMMO2) + UI_DrawPic(pic_ammo[1], 0, 0, 24, 24); + else if (stats[STAT_ITEMS] & IT_AMMO3) + UI_DrawPic(pic_ammo[2], 0, 0, 24, 24); + else if (stats[STAT_ITEMS] & IT_AMMO4) + UI_DrawPic(pic_ammo[3], 0, 0, 24, 24); +} +void Hud_CurrentAmmoBig(void) +{ + int i = stats[STAT_AMMO]; + UI_DrawBigNumber(i, 0, 0, i < 25); +} +void Hud_IBar(void) +{ + UI_DrawPic(ibarback, 0, 0, 320, 24); +} + +void Hud_Weapon(int wnum) +{ + int flash; + if (!(stats[STAT_ITEMS] & (IT_GUN1 << wnum)) && !hudedit) + return; + if (!gotweapontime[wnum]) + gotweapontime[wnum] = currenttime; + flash = (currenttime - gotweapontime[wnum])/100; + if (flash < 0) //errr... whoops... + flash = 0; + + if (flash > 10) + { + if (stats[STAT_WEAPON] & (IT_GUN1 << wnum)) + flash = 1; //selected. + else + flash = 0; + } + else + flash = (flash%5) + 2; + + UI_DrawPic(pic_weapon[flash][wnum], 0, 0, 24, 16); +} + +void Hud_W_Shotgun(void) +{ + Hud_Weapon(0); +} +void Hud_W_SuperShotgun(void) +{ + Hud_Weapon(1); +} +void Hud_W_Nailgun(void) +{ + Hud_Weapon(2); +} +void Hud_W_SuperNailgun(void) +{ + Hud_Weapon(3); +} +void Hud_W_GrenadeLauncher(void) +{ + Hud_Weapon(4); +} +void Hud_W_RocketLauncher(void) +{ + Hud_Weapon(5); +} +void Hud_W_HalfLightning(void) //left half only (needed due to LG icon being twice as wide) +{ + int flash; + int wnum = 6; + + if (!(stats[STAT_ITEMS] & (IT_GUN1 << wnum)) && !hudedit) + return; + + if (!gotweapontime[wnum]) + gotweapontime[wnum] = currenttime; + flash = (currenttime - gotweapontime[wnum])/100; + if (flash < 0) //errr... whoops... + flash = 0; + + if (flash > 10) + { + if (stats[STAT_WEAPON] & (IT_GUN1 << wnum)) + flash = 1; //selected. + else + flash = 0; + } + else + flash = (flash%5) + 2; + + Draw_Image(sbarminx, sbarminy, (float)24*sbarscalex, (float)16*sbarscaley, 0, 0, 0.5, 1, pic_weapon[flash][wnum]); +} +void Hud_W_Lightning(void) +{ + int flash; + int wnum = 6; + + if (!(stats[STAT_ITEMS] & (IT_GUN1 << wnum)) && !hudedit) + return; + + if (!gotweapontime[wnum]) + gotweapontime[wnum] = currenttime; + flash = (currenttime - gotweapontime[wnum])/100; + if (flash < 0) //errr... whoops... + flash = 0; + + if (flash > 10) + { + if (stats[STAT_WEAPON] & (IT_GUN1 << wnum)) + flash = 1; //selected. + else + flash = 0; + } + else + flash = (flash%5) + 2; + + UI_DrawPic(pic_weapon[flash][wnum], 0, 0, 48, 16); +} + +void Hud_Powerup(int wnum) +{ + int flash; + if (!(stats[STAT_ITEMS] & (IT_PUP1 << wnum)) && !hudedit) + return; + + if (!gotpuptime[wnum]) + gotpuptime[wnum] = currenttime; + flash = (currenttime - gotpuptime[wnum])/100; + if (flash < 0) //errr... whoops... + flash = 0; + + if (flash > 10) + { + flash = 0; + } + else + flash = (flash%5) + 2; + + UI_DrawPic(pic_pup[flash][wnum], 0, 0, 16, 16); +} + +void Hud_Key1(void) +{ + Hud_Powerup(0); +} +void Hud_Key2(void) +{ + Hud_Powerup(1); +} +void Hud_PUPInvis(void) +{ + Hud_Powerup(2); +} +void Hud_PUPInvuln(void) +{ + Hud_Powerup(3); +} +void Hud_PUPSuit(void) +{ + Hud_Powerup(4); +} +void Hud_PUPQuad(void) +{ + Hud_Powerup(5); +} + +void Hud_Rune1(void) +{ + if (!(stats[STAT_ITEMS] & (IT_RUNE1 << 0)) && !hudedit) + return; + UI_DrawPic(pic_rune[0], 0, 0, 8, 16); +} +void Hud_Rune2(void) +{ + if (!(stats[STAT_ITEMS] & (IT_RUNE1 << 1)) && !hudedit) + return; + UI_DrawPic(pic_rune[1], 0, 0, 8, 16); +} +void Hud_Rune3(void) +{ + if (!(stats[STAT_ITEMS] & (IT_RUNE1 << 2)) && !hudedit) + return; + UI_DrawPic(pic_rune[2], 0, 0, 8, 16); +} +void Hud_Rune4(void) +{ + if (!(stats[STAT_ITEMS] & (IT_RUNE1 << 3)) && !hudedit) + return; + UI_DrawPic(pic_rune[3], 0, 0, 8, 16); +} + +void Hud_Ammo(int type) +{ + int num; + Draw_Image(sbarminx, sbarminy, (float)42*sbarscalex, (float)11*sbarscaley, (3+(type*48))/320.0f, 0, (3+(type*48)+42)/320.0f, 11/24.0f, ibarback); + + num = stats[STAT_SHELLS+type]; + UI_DrawChar(num%10+18, 19, 0); + num/=10; + if (num%10) + UI_DrawChar(num%10+18, 11, 0); + num/=10; + if (num%10) + UI_DrawChar(num%10+18, 3, 0); +} +void Hud_Shells(void) +{ + Hud_Ammo(0); +} +void Hud_Nails(void) +{ + Hud_Ammo(1); +} +void Hud_Rockets(void) +{ + Hud_Ammo(2); +} +void Hud_Cells(void) +{ + Hud_Ammo(3); +} + +//draw cody of sbar +//arg[0] is playernum +//arg[1]/arg[2] is x/y start of subwindow +//arg[3]/arg[4] is width/height of subwindow +int UI_StatusBar(int *arg) +{ +// int flash; + int i; +// int x; +// char *s; +// unsigned int items; +// unsigned int weapon; +// int mx, my; + +// qboolean noflash = Cvar_GetFloat(UI_NOFLASH); + + float vsx, vsy; + + CL_GetStats(arg[0], stats, sizeof(stats)/sizeof(int)); + + vsx = arg[3]/640.0f; + vsy = arg[4]/480.0f; + for (i = 0; i < numelements; i++) + { + sbarminx = arg[1] + element[i].x*vsx; + sbarminy = arg[2] + element[i].y*vsy; + sbarscalex = element[i].scalex*vsx; + sbarscaley = element[i].scaley*vsy; + hetype[element[i].type].DrawElement(); + } +/* + items = stats[STAT_ITEMS]; + weapon = stats[STAT_WEAPON]; + + //background of sbar + UI_DrawPic(sbarback, 0, vid.height-24, 320, 24); + + //armour quant + i = stats[STAT_ARMOR]; + UI_DrawBigNumber(i, 24, vid.height-24, i < 25); + + //armour pic + if (items & IT_ARMOR3) + UI_DrawPic(pic_armour[2], 0, vid.height-24, 24, 24); + else if (items & IT_ARMOR2) + UI_DrawPic(pic_armour[1], 0, vid.height-24, 24, 24); + else if (items & IT_ARMOR1) + UI_DrawPic(pic_armour[0], 0, vid.height-24, 24, 24); + + //health quant + i = stats[STAT_HEALTH]; + UI_DrawBigNumber(i, 24*6, vid.height-24, i < 25); + + //faces +//FIXME: implement + + if (Cvar_GetFloat(UI_NOIBAR)) + return true; + + //back of ibar + UI_DrawPic(ibarback, 0, vid.height-24-24, 320, 24); + + //weapons + for (i = 0; i < numweaps; i++) + { + if (items & (IT_GUN1 << i)) + { + if (!gotweapontime[i]) + gotweapontime[i] = time; + flash = (int)((time - gotweapontime[i])*10); + if (flash < 0) //errr... whoops... + flash = 0; + + if (flash > 10 || noflash) + { + if (weapon & (IT_GUN1 << i)) + flash = 1; //selected. + else + flash = 0; + } + else + flash = (flash%5) + 2; + + if (i == 6) + UI_DrawPic(pic_weapon[flash][i], 24*i, vid.height-16-24, 48, 16); + else + UI_DrawPic(pic_weapon[flash][i], 24*i, vid.height-16-24, 24, 16); + } + else + gotweapontime[i] = 0; + } + + //currentammo +//FIXME: implement + + //powerups + for (i = 0; i < numpups; i++) + { + if (items & (IT_PUP1 << i)) + { + if (!gotpuptime[i]) + gotpuptime[i] = time; + flash = (int)((time - gotpuptime[i])*10); + if (flash < 0) //errr... whoops... + flash = 0; + + if (flash > 10 || noflash) + { + flash = 0; + } + else + flash = (flash%5) + 1; + + UI_DrawPic(pic_pup[flash][i], (24*8)+(16*i), vid.height-16-24, 16, 16); + } + else + gotpuptime[i] = 0; + } + + //runes +//FIXME: implement + + //ammo counts + for (i = 0; i < 4; i++) + { + s = va("%i", stats[STAT_SHELLS+i]); + + x = (6*i+1)*8; + + flash = strlen(s); + if (flash < 3) + x += 8*(3-flash); + else + s += flash-3; + + + while(*s) + { + UI_DrawChar((unsigned)*s + 18 - '0', x, vid.height-24-24); + s++; + x+=8; + } + } + + //small 4player scorecard +//FIXME: implement +*/ + return true; +} + +int currentitem; +qboolean mousedown, shiftdown; +float mouseofsx, mouseofsy; + +void UI_KeyPress(int key, int mx, int my) +{ + int i; + if (key == K_ESCAPE) + { + Menu_Control(0); + return; + } + + if (key == K_MOUSE1) + { //figure out which one our cursor is over... + mousedown = false; + + for (i = 0; i < numelements; i++) + { + if (element[i].x < mx && + element[i].y < my && + element[i].x + element[i].scalex*hetype[element[i].type].width > mx && + element[i].y + element[i].scaley*hetype[element[i].type].height > my) + { + mouseofsx = mx - element[i].x; + mouseofsy = my - element[i].y; + mousedown = true; + currentitem = i; + break; + } + } + return; + } + + if (key == 'i') + { + if (numelements==MAX_ELEMENTS) + return; //too many + + element[numelements].scalex = 1; + element[numelements].scaley = 1; + element[numelements].alpha = 1; + numelements++; + } + else if (currentitem < numelements) + { + if (key == K_SHIFT) + shiftdown = true; + else if (key == 'd') + { + mousedown = false; + memcpy(element+currentitem, element+currentitem+1, sizeof(element[0]) * (numelements - currentitem-1)); + numelements--; + currentitem = 0; + } + else if (key == 'q') + { + element[currentitem].type--; + if (element[currentitem].type < 0) + element[currentitem].type = sizeof(hetype)/sizeof(hetype[0])-1; + } + else if (key == 'w') + { + element[currentitem].type++; + if (element[currentitem].type >= sizeof(hetype)/sizeof(hetype[0])) + element[currentitem].type = 0; + } + else if (key == K_UPARROW) + { + element[currentitem].y-=shiftdown?8:1; + } + else if (key == K_DOWNARROW) + { + element[currentitem].y+=shiftdown?8:1; + } + else if (key == K_LEFTARROW) + { + element[currentitem].x-=shiftdown?8:1; + } + else if (key == K_RIGHTARROW) + { + element[currentitem].x+=shiftdown?8:1; + } + else if (key == K_HOME) + { + element[currentitem].scalex=1.0f; + element[currentitem].scaley=1.0f; + } + else if (key == '+') + { + element[currentitem].scalex*=1.1f; + element[currentitem].scaley*=1.1f; + } + else if (key == '-') + { + element[currentitem].scalex/=1.1f; + element[currentitem].scaley/=1.1f; + } + } +} + +int Plug_MenuEvent(int *args) +{ + int altargs[5]; + + args[2]=(int)(args[2]*640.0f/vid.width); + args[3]=(int)(args[3]*480.0f/vid.height); + + switch(args[0]) + { + case 0: //draw + + if (mousedown) + { + element[currentitem].x = args[2] - mouseofsx; + element[currentitem].y = args[3] - mouseofsy; + if (shiftdown) + { + element[currentitem].x -= (int)element[currentitem].x & 7; + element[currentitem].y -= (int)element[currentitem].y & 7; + } + } + + hudedit = !!(currenttime/250)&3; + + altargs[0] = 0; + altargs[1] = 0; + altargs[2] = 0; + altargs[3] = vid.width; + altargs[4] = vid.height; + UI_StatusBar(altargs); //draw it using the same function (we're lazy) + + if ((currenttime/250)&1) + Draw_Fill( (int)element[currentitem].x, (int)element[currentitem].y, + (int)(element[currentitem].scalex*hetype[element[currentitem].type].width), + (int)(element[currentitem].scaley*hetype[element[currentitem].type].height)); + break; + case 1: //keydown + UI_KeyPress(args[1], args[2], args[3]); + break; + case 2: //keyup + if (args[1] == K_MOUSE1) + mousedown = false; + else if (args[1] == K_SHIFT) + shiftdown = false; + break; + case 3: //menu closed (this is called even if we change it). + hudedit = false; + break; + case 4: //mousemove + break; + } + + return 0; +} + +int Plug_Tick(int *args) +{ + currenttime = args[0]; + return true; +} + +int Plug_ExecuteCommand(int *args) +{ + char cmd[256]; + Cmd_Argv(0, cmd, sizeof(cmd)); + if (!strcmp("sbar_edit", cmd)) + { + Menu_Control(1); + mousedown=false; + return 1; + } + return 0; +} + +int Plug_Init(int *args) +{ + if (Plug_Export("Tick", Plug_Tick) && + Plug_Export("SbarBase", UI_StatusBar) && + Plug_Export("ExecuteCommand", Plug_ExecuteCommand) && + Plug_Export("MenuEvent", Plug_MenuEvent)) + { + UI_SbarInit(); + + K_UPARROW = Key_GetKeyCode("uparrow"); + K_DOWNARROW = Key_GetKeyCode("downarrow"); + K_LEFTARROW = Key_GetKeyCode("leftarrow"); + K_RIGHTARROW = Key_GetKeyCode("rightarrow"); + K_ESCAPE = Key_GetKeyCode("escape"); + K_HOME = Key_GetKeyCode("home"); + K_MOUSE1 = Key_GetKeyCode("mouse1"); + K_SHIFT = Key_GetKeyCode("shift"); + + return true; + } + return false; +} \ No newline at end of file