1891 lines
37 KiB
C
1891 lines
37 KiB
C
#include "../plugin.h"
|
|
|
|
#define DEFAULTHUDNAME "ftehud.hud"
|
|
|
|
#define MAX_ELEMENTS 128
|
|
|
|
int K_UPARROW;
|
|
int K_DOWNARROW;
|
|
int K_LEFTARROW;
|
|
int K_RIGHTARROW;
|
|
int K_ESCAPE;
|
|
int K_MOUSE1;
|
|
int K_MOUSE2;
|
|
int K_HOME;
|
|
int K_SHIFT;
|
|
int K_MWHEELDOWN;
|
|
int K_MWHEELUP;
|
|
int K_PAGEUP;
|
|
int K_PAGEDOWN;
|
|
|
|
|
|
#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 pic_cursor;
|
|
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;
|
|
float sbaralpha;
|
|
int sbartype;
|
|
int sbarindex;
|
|
|
|
static int hudedit;
|
|
|
|
enum {
|
|
DZ_BOTTOMLEFT,
|
|
DZ_BOTTOMRIGHT
|
|
};
|
|
|
|
typedef void drawelementfnc_t(void);
|
|
typedef struct {
|
|
float defaultx; //used if couldn't load a config
|
|
float defaulty;
|
|
int defaultzone;
|
|
float defaultalpha;
|
|
drawelementfnc_t *DrawElement;
|
|
int subtype;
|
|
} huddefaultelement_t;
|
|
|
|
|
|
|
|
|
|
|
|
drawelementfnc_t Hud_SBar;
|
|
drawelementfnc_t Hud_StatSmall;
|
|
drawelementfnc_t Hud_StatBig;
|
|
drawelementfnc_t Hud_ArmourPic;
|
|
drawelementfnc_t Hud_HealthPic;
|
|
drawelementfnc_t Hud_CurrentAmmoPic;
|
|
drawelementfnc_t Hud_IBar;
|
|
drawelementfnc_t Hud_Weapon;
|
|
drawelementfnc_t Hud_W_Lightning;
|
|
drawelementfnc_t Hud_Powerup;
|
|
drawelementfnc_t Hud_Rune;
|
|
drawelementfnc_t Hud_Ammo;
|
|
drawelementfnc_t Hud_ScoreCard;
|
|
drawelementfnc_t Hud_ScoreName;
|
|
drawelementfnc_t Hud_Blackness;
|
|
drawelementfnc_t Hud_TeamScore;
|
|
drawelementfnc_t Hud_TeamName;
|
|
// TODO: more elements
|
|
// - generalized graphic elements
|
|
// - cvar controlled small and big numbers
|
|
// - alias controlled graphic elements (both +/-showscores like and alias calling?)
|
|
// - Q2-style current weapon icon
|
|
|
|
int statsremap[] =
|
|
{
|
|
STAT_HEALTH,
|
|
STAT_ARMOR,
|
|
STAT_AMMO,
|
|
STAT_SHELLS,
|
|
STAT_NAILS,
|
|
STAT_ROCKETS,
|
|
STAT_NAILS
|
|
};
|
|
|
|
typedef struct {
|
|
drawelementfnc_t *draw;
|
|
char *name;
|
|
int width, height;
|
|
int maxsubtype;
|
|
} drawelement_t;
|
|
drawelement_t drawelement[] =
|
|
{
|
|
{Hud_SBar, "Status bar", 320, 24, 0},
|
|
{Hud_StatSmall, "Stat (small)", 8*3, 8, 6}, // equal to sizeof(statsremap)/sizeof(statsremap[0])-1
|
|
{Hud_StatBig, "Stat (big)", 24*3, 24, 6}, // equal to sizeof(statsremap)/sizeof(statsremap[0])-1
|
|
{Hud_ArmourPic, "Armor pic", 24, 24, 0},
|
|
{Hud_HealthPic, "Health pic", 24, 24, 0},
|
|
{Hud_CurrentAmmoPic, "Ammo pic", 24, 24, 0},
|
|
{Hud_IBar, "Info bar", 320, 24, 0},
|
|
{Hud_Weapon, "Weapon pic", 24, 16, 6},
|
|
{Hud_W_Lightning, "Shaft pic", 24, 16, 0},
|
|
{Hud_Powerup, "Powerup pic", 16, 16, 5},
|
|
{Hud_Rune, "Rune pic", 8, 16, 3},
|
|
{Hud_Ammo, "Ammo display", 42, 11, 3},
|
|
{Hud_Blackness, "Blackness", 16, 16, 10},
|
|
{Hud_ScoreCard, "Scorecard", 32, 8, 16},
|
|
{Hud_ScoreName, "Scorename", 128, 8, 8},
|
|
|
|
{Hud_TeamScore, "TeamScore", 32, 8, 8},
|
|
{Hud_TeamName, "TeamName", 128, 8, 8}
|
|
};
|
|
|
|
huddefaultelement_t hedefaulttype[] = {
|
|
{
|
|
0, -24, DZ_BOTTOMLEFT,
|
|
0.3f,
|
|
Hud_SBar
|
|
},
|
|
|
|
{
|
|
0, -24, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_ArmourPic
|
|
},
|
|
{
|
|
24, -24, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_StatBig,
|
|
1
|
|
},
|
|
|
|
{
|
|
112, -24, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_HealthPic
|
|
},
|
|
{
|
|
24*6, -24, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_StatBig,
|
|
0
|
|
},
|
|
|
|
{
|
|
224, -24, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_CurrentAmmoPic
|
|
},
|
|
{
|
|
248, -24, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_StatBig,
|
|
2
|
|
},
|
|
|
|
{
|
|
0, -48, DZ_BOTTOMLEFT,
|
|
0.3f,
|
|
Hud_IBar
|
|
},
|
|
|
|
{
|
|
0, -40, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_Weapon,
|
|
0
|
|
},
|
|
{
|
|
24, -40, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_Weapon,
|
|
1
|
|
},
|
|
{
|
|
48, -40, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_Weapon,
|
|
2
|
|
},
|
|
{
|
|
72, -40, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_Weapon,
|
|
3
|
|
},
|
|
{
|
|
96, -40, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_Weapon,
|
|
4
|
|
},
|
|
{
|
|
120, -40, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_Weapon,
|
|
5
|
|
},
|
|
{
|
|
146, -40, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_W_Lightning
|
|
},
|
|
{
|
|
194, -40, DZ_BOTTOMLEFT,
|
|
0.3f,
|
|
Hud_Powerup,
|
|
0
|
|
},
|
|
{
|
|
208, -40, DZ_BOTTOMLEFT,
|
|
0.3f,
|
|
Hud_Powerup,
|
|
1
|
|
},
|
|
{
|
|
224, -40, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_Powerup,
|
|
2
|
|
},
|
|
{
|
|
240, -40, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_Powerup,
|
|
3
|
|
},
|
|
{
|
|
256, -40, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_Powerup,
|
|
4
|
|
},
|
|
{
|
|
272, -40, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_Powerup,
|
|
5
|
|
},
|
|
{
|
|
288, -40, DZ_BOTTOMLEFT,
|
|
0.3f,
|
|
Hud_Rune,
|
|
0
|
|
},
|
|
{
|
|
296, -40, DZ_BOTTOMLEFT,
|
|
0.3f,
|
|
Hud_Rune,
|
|
1
|
|
},
|
|
{
|
|
304, -40, DZ_BOTTOMLEFT,
|
|
0.3f,
|
|
Hud_Rune,
|
|
2
|
|
},
|
|
{
|
|
312, -40, DZ_BOTTOMLEFT,
|
|
0.3f,
|
|
Hud_Rune,
|
|
3
|
|
},
|
|
|
|
{
|
|
48*0+3, -48, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_Ammo,
|
|
0
|
|
},
|
|
{
|
|
48*1+3, -48, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_Ammo,
|
|
1
|
|
},
|
|
{
|
|
48*2+3, -48, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_Ammo,
|
|
2
|
|
},
|
|
{
|
|
48*3+3, -48, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_Ammo,
|
|
3
|
|
},
|
|
|
|
{
|
|
42*3, -48, DZ_BOTTOMLEFT,
|
|
1,
|
|
Hud_ScoreCard
|
|
}
|
|
};
|
|
typedef struct {
|
|
int type;
|
|
int subtype;
|
|
|
|
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;
|
|
|
|
int currentitem;
|
|
int hoveritem;
|
|
qboolean mousedown, shiftdown;
|
|
float mouseofsx, mouseofsy;
|
|
qboolean context;
|
|
|
|
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_DrawString(char *s, int x, int y)
|
|
{
|
|
while(*s)
|
|
{
|
|
UI_DrawChar((unsigned int)*s++, x, y);
|
|
x+=8;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
static int idxforfunc(drawelementfnc_t *fnc)
|
|
{
|
|
int i;
|
|
for (i = 0; i < sizeof(drawelement)/sizeof(drawelement[0]); i++)
|
|
{
|
|
if (drawelement[i].draw == fnc)
|
|
return i;
|
|
}
|
|
return -10000; //try and crash
|
|
}
|
|
|
|
void SBar_ReloadDefaults(void)
|
|
{
|
|
int i;
|
|
for (i = 0; i < sizeof(hedefaulttype)/sizeof(hedefaulttype[0]); i++)
|
|
{
|
|
if (hedefaulttype[i].defaultalpha)
|
|
{
|
|
if (numelements >= MAX_ELEMENTS)
|
|
break;
|
|
element[numelements].type = idxforfunc(hedefaulttype[i].DrawElement);
|
|
element[numelements].alpha = hedefaulttype[i].defaultalpha;
|
|
element[numelements].scalex = 1;
|
|
element[numelements].scaley = 1;
|
|
element[numelements].subtype = hedefaulttype[i].subtype;
|
|
switch(hedefaulttype[i].defaultzone)
|
|
{
|
|
case DZ_BOTTOMLEFT:
|
|
element[numelements].x = hedefaulttype[i].defaultx;
|
|
element[numelements].y = 480+hedefaulttype[i].defaulty;
|
|
break;
|
|
case DZ_BOTTOMRIGHT:
|
|
element[numelements].x = 640+hedefaulttype[i].defaultx;
|
|
element[numelements].y = 480+hedefaulttype[i].defaulty;
|
|
break;
|
|
}
|
|
numelements++;
|
|
}
|
|
}
|
|
}
|
|
|
|
void UI_SbarInit(void)
|
|
{
|
|
int i;
|
|
int j;
|
|
|
|
//main bar (add cvars later)
|
|
ibarback = Draw_LoadImage("ibar", false);
|
|
sbarback = Draw_LoadImage("sbar", false);
|
|
|
|
con_chars = Draw_LoadImage("conchars", false);
|
|
|
|
//load images.
|
|
for (i = 0; i < 10; i++)
|
|
{
|
|
pic_num[i] = Draw_LoadImage(va("num_%i", i), false);
|
|
pic_anum[i] = Draw_LoadImage(va("anum_%i", i), false);
|
|
}
|
|
pic_num[10] = Draw_LoadImage("num_minus", false);
|
|
pic_anum[10] = Draw_LoadImage("anum_minus", false);
|
|
pic_num[11] = Draw_LoadImage("num_colon", false);
|
|
pic_num[12] = Draw_LoadImage("num_slash", false);
|
|
|
|
for (i = 0; i < numweaps; i++)
|
|
{
|
|
gotweapontime[i] = 0;
|
|
pic_weapon[0][i] = Draw_LoadImage(va("inv_%s", weaponabbreviation[i]), false);
|
|
pic_weapon[1][i] = Draw_LoadImage(va("inv2_%s", weaponabbreviation[i]), false);
|
|
for (j = 0; j < 5; j++)
|
|
{
|
|
pic_weapon[2+j][i] = Draw_LoadImage(va("inva%i_%s", j+1, weaponabbreviation[i]), false);
|
|
}
|
|
}
|
|
for (i = 0; i < numpups; i++)
|
|
{
|
|
gotpuptime[i] = 0;
|
|
pic_pup[0][i] = Draw_LoadImage(va("sb_%s", pupabbr2[i]), false);
|
|
for (j = 0; j < 5; j++)
|
|
{
|
|
pic_pup[1+j][i] = Draw_LoadImage(va("sba%i_%s", j+1, pupabbr[i]), false);
|
|
}
|
|
}
|
|
pic_cursor = Draw_LoadImage("gfx/cursor", false);
|
|
|
|
pic_armour[0] = Draw_LoadImage("sb_armor1", false);
|
|
pic_armour[1] = Draw_LoadImage("sb_armor2", false);
|
|
pic_armour[2] = Draw_LoadImage("sb_armor3", false);
|
|
|
|
pic_ammo[0] = Draw_LoadImage("sb_shells", false);
|
|
pic_ammo[1] = Draw_LoadImage("sb_nails", false);
|
|
pic_ammo[2] = Draw_LoadImage("sb_rocket", false);
|
|
pic_ammo[3] = Draw_LoadImage("sb_cells", false);
|
|
|
|
pic_rune[0] = Draw_LoadImage("sb_sigil1", false);
|
|
pic_rune[1] = Draw_LoadImage("sb_sigil2", false);
|
|
pic_rune[2] = Draw_LoadImage("sb_sigil3", false);
|
|
pic_rune[3] = Draw_LoadImage("sb_sigil4", false);
|
|
|
|
pic_face[0] = Draw_LoadImage("face1", false);
|
|
pic_face[1] = Draw_LoadImage("face2", false);
|
|
pic_face[2] = Draw_LoadImage("face3", false);
|
|
pic_face[3] = Draw_LoadImage("face4", false);
|
|
pic_face[4] = Draw_LoadImage("face5", false);
|
|
|
|
pic_facep[0] = Draw_LoadImage("face_p1", false);
|
|
pic_facep[1] = Draw_LoadImage("face_p2", false);
|
|
pic_facep[2] = Draw_LoadImage("face_p3", false);
|
|
pic_facep[3] = Draw_LoadImage("face_p4", false);
|
|
pic_facep[4] = Draw_LoadImage("face_p5", false);
|
|
|
|
pic_facequad = Draw_LoadImage("face_quad", false);
|
|
pic_faceinvis = Draw_LoadImage("face_invis", false);
|
|
pic_faceinvisinvuln = Draw_LoadImage("face_inv2", false);
|
|
pic_faceinvuln = Draw_LoadImage("face_invul1", false);
|
|
pic_faceinvulnquad = Draw_LoadImage("face_invul2", false);
|
|
|
|
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 || hudedit)
|
|
UI_DrawPic(pic_armour[0], 0, 0, 24, 24);
|
|
}
|
|
|
|
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;
|
|
|
|
//FIXME
|
|
// 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_StatBig(void)
|
|
{
|
|
int i = stats[statsremap[sbartype]];
|
|
|
|
UI_DrawBigNumber(i, 0, 0, i < 25);
|
|
}
|
|
|
|
void Hud_StatSmall(void)
|
|
{
|
|
int i = stats[statsremap[sbartype]];
|
|
|
|
// TODO: need some sort of options thing to change between brown/white/gold text
|
|
UI_DrawChar(i%10+18, 19, 0);
|
|
i/=10;
|
|
if (i)
|
|
UI_DrawChar(i%10+18, 11, 0);
|
|
i/=10;
|
|
if (i)
|
|
UI_DrawChar(i%10+18, 3, 0);
|
|
}
|
|
|
|
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 || hudedit)
|
|
UI_DrawPic(pic_ammo[3], 0, 0, 24, 24);
|
|
}
|
|
|
|
void Hud_IBar(void)
|
|
{
|
|
UI_DrawPic(ibarback, 0, 0, 320, 24);
|
|
}
|
|
|
|
void Hud_Weapon(void)
|
|
{
|
|
int flash;
|
|
if (!(stats[STAT_ITEMS] & (IT_GUN1 << sbartype)) && !hudedit)
|
|
{
|
|
gotweapontime[sbartype] = 0;
|
|
return;
|
|
}
|
|
|
|
if (!gotweapontime[sbartype])
|
|
gotweapontime[sbartype] = currenttime;
|
|
flash = (currenttime - gotweapontime[sbartype])/100;
|
|
if (flash < 0) //errr... whoops...
|
|
flash = 0;
|
|
|
|
if (flash > 10)
|
|
{
|
|
if (stats[STAT_ACTIVEWEAPON] & (IT_GUN1 << sbartype))
|
|
flash = 1; //selected.
|
|
else
|
|
flash = 0;
|
|
}
|
|
else
|
|
flash = (flash%5) + 2;
|
|
|
|
UI_DrawPic(pic_weapon[flash][sbartype], 0, 0, 24, 16);
|
|
}
|
|
|
|
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)
|
|
{
|
|
gotweapontime[wnum] = 0;
|
|
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_ACTIVEWEAPON] & (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)
|
|
{
|
|
gotweapontime[wnum] = 0;
|
|
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_ACTIVEWEAPON] & (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(void)
|
|
{
|
|
int flash;
|
|
if (!(stats[STAT_ITEMS] & (IT_PUP1 << sbartype)) && !hudedit)
|
|
return;
|
|
|
|
if (!gotpuptime[sbartype])
|
|
gotpuptime[sbartype] = currenttime;
|
|
flash = (currenttime - gotpuptime[sbartype])/100;
|
|
if (flash < 0) //errr... whoops...
|
|
flash = 0;
|
|
|
|
if (flash > 10)
|
|
{
|
|
flash = 0;
|
|
}
|
|
else
|
|
flash = (flash%5) + 2;
|
|
|
|
UI_DrawPic(pic_pup[flash][sbartype], 0, 0, 16, 16);
|
|
}
|
|
|
|
void Hud_Rune(void)
|
|
{
|
|
if (!(stats[STAT_ITEMS] & (IT_RUNE1 << sbartype)) && !hudedit)
|
|
return;
|
|
UI_DrawPic(pic_rune[sbartype], 0, 0, 8, 16);
|
|
}
|
|
|
|
void Hud_Ammo(void)
|
|
{
|
|
int num;
|
|
Draw_Image(sbarminx, sbarminy, (float)42*sbarscalex, (float)11*sbarscaley, (3+(sbartype*48))/320.0f, 0, (3+(sbartype*48)+42)/320.0f, 11/24.0f, ibarback);
|
|
|
|
num = stats[STAT_SHELLS+sbartype];
|
|
if (hudedit)
|
|
num = 999;
|
|
|
|
UI_DrawChar(num%10+18, 19, 0);
|
|
num/=10;
|
|
if (num)
|
|
UI_DrawChar(num%10+18, 11, 0);
|
|
num/=10;
|
|
if (num)
|
|
UI_DrawChar(num%10+18, 3, 0);
|
|
}
|
|
|
|
float pc[16][3] =
|
|
{
|
|
/*
|
|
{235, 235, 235},
|
|
{143, 111, 035},
|
|
{139, 139, 203},
|
|
{107, 107, 015},
|
|
{127, 000, 000},
|
|
{175, 103, 035},
|
|
{255, 243, 027},
|
|
{227, 179, 151},
|
|
{171, 139, 163},
|
|
{187, 115, 159},
|
|
{219, 195, 187},
|
|
{111, 131, 123},
|
|
{255, 243, 027},
|
|
{000, 000, 255},
|
|
{247, 211, 139}
|
|
*/
|
|
{0.922, 0.922, 0.922},
|
|
{0.560, 0.436, 0.137},
|
|
{0.545, 0.545, 0.796},
|
|
{0.420, 0.420, 0.059},
|
|
{0.498, 0.000, 0.000},
|
|
{0.686, 0.404, 0.137},
|
|
{1.000, 0.953, 0.106},
|
|
{0.890, 0.702, 0.592},
|
|
{0.671, 0.545, 0.639},
|
|
{0.733, 0.451, 0.624},
|
|
{0.859, 0.765, 0.733},
|
|
{0.436, 0.514, 0.482},
|
|
{1.000, 0.953, 0.106},
|
|
{0.000, 0.000, 1.000},
|
|
{0.969, 0.827, 0.545}
|
|
};
|
|
|
|
int numsortedplayers;
|
|
int playerlocal;
|
|
int sortedplayers[32];
|
|
plugclientinfo_t players[32];
|
|
|
|
void SortPlayers(void)
|
|
{
|
|
int i, j;
|
|
int temp;
|
|
|
|
numsortedplayers = 0;
|
|
playerlocal = -1;
|
|
for (i = 0; i < 32; i++)
|
|
{
|
|
if (GetPlayerInfo(i, &players[i])>0)
|
|
playerlocal = i;
|
|
if (players[i].spectator)
|
|
continue;
|
|
if (*players[i].name != 0)
|
|
sortedplayers[numsortedplayers++] = i;
|
|
}
|
|
|
|
for (i = 0; i < numsortedplayers; i++)
|
|
{
|
|
for (j = i+1; j < numsortedplayers; j++)
|
|
{
|
|
if (players[sortedplayers[i]].frags < players[sortedplayers[j]].frags)
|
|
{
|
|
temp = sortedplayers[j];
|
|
sortedplayers[j] = sortedplayers[i];
|
|
sortedplayers[i] = temp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
typedef struct {
|
|
char name[8];
|
|
int frags;
|
|
int tc;
|
|
int bc;
|
|
} teams_t;
|
|
teams_t team[32];
|
|
int numsortedteams;
|
|
|
|
void SortTeams(void)
|
|
{
|
|
teams_t temp;
|
|
int i, j;
|
|
|
|
numsortedplayers = 0;
|
|
playerlocal = -1;
|
|
for (i = 0; i < 32; i++)
|
|
{
|
|
if (GetPlayerInfo(i, &players[i])>0)
|
|
playerlocal = i;
|
|
if (players[i].spectator)
|
|
continue;
|
|
if (*players[i].name != 0)
|
|
sortedplayers[numsortedplayers++] = i;
|
|
|
|
for (j = 0; j < numsortedteams; j++)
|
|
{
|
|
if (!strcmp(team[j].name, players[i].name))
|
|
{
|
|
team[j].frags += players[i].frags;
|
|
while(j > 0)
|
|
{
|
|
if (team[j-1].frags < team[j].frags)
|
|
{
|
|
memcpy(&temp, &team[j], sizeof(teams_t));
|
|
memcpy(&team[j], &team[j-1], sizeof(teams_t));
|
|
memcpy(&team[j-1], &temp, sizeof(teams_t));
|
|
j--;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (j == numsortedteams)
|
|
{
|
|
strlcpy(team[j].name, players[i].name, sizeof(team[j].name));
|
|
team[j].frags = players[i].frags;
|
|
team[j].tc = players[i].topcolour;
|
|
team[j].bc = players[i].bottomcolour;
|
|
numsortedteams++;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Hud_ScoreCard(void)
|
|
{
|
|
int frags, tc, bc, p;
|
|
int brackets;
|
|
char number[6];
|
|
char *num;
|
|
|
|
if (hudedit)
|
|
{
|
|
frags = sbartype;
|
|
tc = 0;
|
|
bc = 0;
|
|
brackets = 1;
|
|
}
|
|
else
|
|
{
|
|
SortPlayers();
|
|
if (sbartype>=numsortedplayers)
|
|
return;
|
|
p = sortedplayers[sbartype];
|
|
bc = players[p].bottomcolour;
|
|
tc = players[p].topcolour;
|
|
frags = players[p].frags;
|
|
brackets = p==playerlocal;
|
|
}
|
|
|
|
Draw_Colour4f(pc[tc][0], pc[tc][1], pc[tc][2], sbaralpha);
|
|
Draw_Fill(sbarminx, sbarminy, (float)32*sbarscalex, (float)4*sbarscaley);
|
|
Draw_Colour4f(pc[bc][0], pc[bc][1], pc[bc][2], sbaralpha);
|
|
Draw_Fill(sbarminx, sbarminy+4*sbarscaley, (float)32*sbarscalex, (float)4*sbarscaley);
|
|
|
|
Draw_Colour4f(1, 1, 1, sbaralpha);
|
|
if (brackets)
|
|
{
|
|
UI_DrawChar(16, 0, 0);
|
|
UI_DrawChar(17, 24, 0);
|
|
}
|
|
|
|
snprintf(number, sizeof(number), "%-3i", frags);
|
|
UI_DrawChar(number[0], 4, 0);
|
|
UI_DrawChar(number[1], 12, 0);
|
|
UI_DrawChar(number[2], 20, 0);
|
|
|
|
Draw_Colour4f(1,1,1,1);
|
|
}
|
|
void Hud_ScoreName(void)
|
|
{
|
|
int p;
|
|
char *name;
|
|
if (hudedit)
|
|
{
|
|
name = va("Player %i", sbartype);
|
|
}
|
|
else
|
|
{
|
|
SortPlayers();
|
|
if (sbartype>=numsortedplayers)
|
|
return;
|
|
p = sortedplayers[sbartype];
|
|
name = players[p].name;
|
|
}
|
|
UI_DrawString(name, 0, 0);
|
|
}
|
|
|
|
void Hud_TeamScore(void)
|
|
{
|
|
int frags, tc, bc, p;
|
|
int brackets;
|
|
char number[6];
|
|
char *num;
|
|
|
|
if (hudedit)
|
|
{
|
|
frags = sbartype;
|
|
tc = 0;
|
|
bc = 0;
|
|
brackets = 1;
|
|
}
|
|
else
|
|
{
|
|
SortPlayers();
|
|
if (sbartype>=numsortedteams)
|
|
return;
|
|
p = sbartype;
|
|
bc = team[p].bc;
|
|
tc = team[p].tc;
|
|
frags = team[p].frags;
|
|
brackets = p==playerlocal;
|
|
}
|
|
|
|
Draw_Colour4f(pc[tc][0], pc[tc][1], pc[tc][2], sbaralpha);
|
|
Draw_Fill(sbarminx, sbarminy, (float)32*sbarscalex, (float)4*sbarscaley);
|
|
Draw_Colour4f(pc[bc][0], pc[bc][1], pc[bc][2], sbaralpha);
|
|
Draw_Fill(sbarminx, sbarminy+4*sbarscaley, (float)32*sbarscalex, (float)4*sbarscaley);
|
|
|
|
Draw_Colour4f(1, 1, 1, sbaralpha);
|
|
if (brackets)
|
|
{
|
|
UI_DrawChar(16, 0, 0);
|
|
UI_DrawChar(17, 24, 0);
|
|
}
|
|
|
|
snprintf(number, sizeof(number), "%-3i", frags);
|
|
UI_DrawChar(number[0], 4, 0);
|
|
UI_DrawChar(number[1], 12, 0);
|
|
UI_DrawChar(number[2], 20, 0);
|
|
|
|
|
|
|
|
Draw_Colour4f(1,1,1,1);
|
|
}
|
|
|
|
void Hud_TeamName(void)
|
|
{
|
|
int p;
|
|
char *tname;
|
|
|
|
if (hudedit)
|
|
{
|
|
tname = va("T%-3i", sbartype);
|
|
}
|
|
else
|
|
{
|
|
SortTeams();
|
|
if (sbartype>=numsortedteams)
|
|
return;
|
|
p = sbartype;
|
|
tname = team[p].name;
|
|
}
|
|
|
|
Draw_Colour4f(1, 1, 1, sbaralpha);
|
|
|
|
if (tname[0])
|
|
{
|
|
UI_DrawChar(tname[0], 0, 0);
|
|
if (tname[1])
|
|
{
|
|
UI_DrawChar(tname[1], 8, 0);
|
|
if (tname[2])
|
|
{
|
|
UI_DrawChar(tname[2], 8, 0);
|
|
if (tname[3])
|
|
{
|
|
UI_DrawChar(tname[3], 8, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Draw_Colour4f(1,1,1,1);
|
|
}
|
|
|
|
//fixme: draw dark blobs
|
|
void Hud_Blackness(void)
|
|
{
|
|
Draw_Colour4f(0, 0, 0, sbartype/10.0f);
|
|
|
|
if (hudedit)
|
|
{
|
|
if (sbarindex == currentitem)
|
|
{
|
|
float j = ((currenttime % 1000) - 500) / 500.0f;
|
|
if (j < 0)
|
|
j = -j;
|
|
j/=3;
|
|
|
|
Draw_Colour4f(j, 0, 0, sbartype/10.0f);
|
|
}
|
|
else if (sbarindex == hoveritem)
|
|
{
|
|
Draw_Colour4f(0.0, 0.2, 0.0, sbartype/10.0f);
|
|
}
|
|
}
|
|
Draw_Fill(sbarminx, sbarminy, (float)16*sbarscalex, (float)16*sbarscaley);
|
|
Draw_Colour4f(1,1,1,1);
|
|
}
|
|
|
|
|
|
void UI_DrawHandles(int *arg, int i)
|
|
{
|
|
int mt;
|
|
float vsx, vsy;
|
|
vsx = arg[3]/640.0f;
|
|
vsy = arg[4]/480.0f;
|
|
|
|
sbarminx = arg[1] + element[i].x*vsx;
|
|
sbarminy = arg[2] + element[i].y*vsy;
|
|
sbarscalex = element[i].scalex*vsx;
|
|
sbarscaley = element[i].scaley*vsy;
|
|
mt = element[i].type;
|
|
sbartype = element[i].subtype;
|
|
sbaralpha = element[i].alpha;
|
|
|
|
Draw_Colour4f(1, 0, 0, 1);
|
|
Draw_Fill(sbarminx+drawelement[mt].width*sbarscalex-((sbarscalex<0)?0:(vsx*4)), sbarminy-((sbarscaley>=0)?0:(vsy*4)), (float)4*vsx, (float)4*vsy);
|
|
|
|
Draw_Colour4f(0, 1, 0, 1);
|
|
Draw_Fill(sbarminx+drawelement[mt].width*sbarscalex-((sbarscalex<0)?0:(vsx*4)), sbarminy+drawelement[mt].height*sbarscaley-((sbarscaley<0)?0:(vsy*4)), (float)4*vsx, (float)4*vsy);
|
|
}
|
|
|
|
//draw body 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 i;
|
|
|
|
float vsx, vsy;
|
|
|
|
if (arg[5])
|
|
return false;
|
|
|
|
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;
|
|
sbartype = element[i].subtype;
|
|
sbaralpha = element[i].alpha;
|
|
drawelement[element[i].type].draw();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
int UI_StatusBarEdit(int *arg) // seperated so further improvements to editor view can be done
|
|
{
|
|
int i;
|
|
|
|
float vsx, vsy;
|
|
qboolean clrset = false;
|
|
|
|
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++)
|
|
{
|
|
if (i == currentitem)
|
|
{
|
|
float j = ((currenttime % 1000) - 500) / 500.0f;
|
|
if (j < 0)
|
|
j = -j;
|
|
|
|
Draw_Colour3f(1.0, j, j);
|
|
clrset = true;
|
|
}
|
|
else if (i == hoveritem)
|
|
{
|
|
Draw_Colour3f(0.0, 1.0, 0.0);
|
|
clrset = true;
|
|
}
|
|
|
|
sbarminx = arg[1] + element[i].x*vsx;
|
|
sbarminy = arg[2] + element[i].y*vsy;
|
|
sbarscalex = element[i].scalex*vsx;
|
|
sbarscaley = element[i].scaley*vsy;
|
|
sbartype = element[i].subtype;
|
|
sbaralpha = element[i].alpha;
|
|
sbarindex = i;
|
|
drawelement[element[i].type].draw();
|
|
|
|
if (clrset)
|
|
{
|
|
Draw_Colour3f(1.0, 1.0, 1.0);
|
|
clrset = false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
int UI_ScoreBoard(int *arg)
|
|
{
|
|
int i;
|
|
if (!arg[5])
|
|
return;
|
|
|
|
sbarminx = 320;
|
|
sbarminy = 48;
|
|
sbarscalex = 1;
|
|
sbarscaley = 1;
|
|
sbaralpha = 1;
|
|
|
|
SortPlayers();
|
|
for (i = 0; i < numsortedplayers; i++)
|
|
{
|
|
sbartype = i;
|
|
Hud_ScoreCard();
|
|
UI_DrawString(players[sortedplayers[i]].name, 40, 0);
|
|
|
|
sbarminy += 16;
|
|
}
|
|
}
|
|
|
|
#define HUD_VERSION 52345
|
|
void PutFloat(float f, char sep, qhandle_t handle)
|
|
{
|
|
char *buffer;
|
|
buffer = va("%f%c", f, sep);
|
|
FS_Write(handle, buffer, strlen(buffer));
|
|
}
|
|
void PutInteger(int i, char sep, qhandle_t handle)
|
|
{
|
|
char *buffer;
|
|
buffer = va("%i%c", i, sep);
|
|
FS_Write(handle, buffer, strlen(buffer));
|
|
}
|
|
|
|
void Hud_Save(char *fname)
|
|
{
|
|
int i;
|
|
qhandle_t handle;
|
|
if (!*fname)
|
|
fname = DEFAULTHUDNAME;
|
|
if (FS_Open(fname, &handle, 2)<0)
|
|
{
|
|
Con_Printf("Couldn't open %s\n", fname);
|
|
return;
|
|
}
|
|
|
|
PutInteger(HUD_VERSION, '\n', handle);
|
|
PutInteger(numelements, '\n', handle);
|
|
for (i = 0; i < numelements; i++)
|
|
{
|
|
PutFloat(element[i].x, ' ', handle);
|
|
PutFloat(element[i].y, ' ', handle);
|
|
PutFloat(element[i].scalex, ' ', handle);
|
|
PutFloat(element[i].scaley, ' ', handle);
|
|
PutInteger(element[i].type, ' ', handle);
|
|
PutInteger(element[i].subtype, ' ', handle);
|
|
PutFloat(element[i].alpha, '\n', handle);
|
|
}
|
|
|
|
FS_Close(handle);
|
|
}
|
|
float GetFloat(char **f, qhandle_t handle)
|
|
{
|
|
char *ts;
|
|
while(**f <= ' ' && **f != 0)
|
|
(*f)++;
|
|
while(*f[0] == '/' && *f[1] == '/')
|
|
{
|
|
while(**f != '\n' && **f != 0)
|
|
(*f)++;
|
|
while(**f <= ' ' && **f != 0)
|
|
(*f)++;
|
|
}
|
|
ts = *f;
|
|
while (**f>' ')
|
|
(*f)++;
|
|
|
|
return (float)atof(ts);
|
|
}
|
|
int GetInteger(char **f, qhandle_t handle)
|
|
{
|
|
char *ts;
|
|
while(**f <= ' ' && **f != 0)
|
|
(*f)++;
|
|
while(*f[0] == '/' && *f[1] == '/')
|
|
{
|
|
while(**f != '\n' && **f != 0)
|
|
(*f)++;
|
|
while(**f <= ' ' && **f != 0)
|
|
(*f)++;
|
|
}
|
|
ts = *f;
|
|
while (**f>' ')
|
|
(*f)++;
|
|
|
|
return atoi(ts);
|
|
}
|
|
void Hud_Load(char *fname)
|
|
{
|
|
char file[16384];
|
|
char *p;
|
|
int len;
|
|
int i;
|
|
qhandle_t handle;
|
|
int ver;
|
|
|
|
float x, y, sx, sy, a;
|
|
int type, subtype;
|
|
|
|
if (!*fname)
|
|
fname = DEFAULTHUDNAME;
|
|
len = FS_Open(fname, &handle, 1);
|
|
if (len < 0)
|
|
{
|
|
Con_Printf("Couldn't load file\n");
|
|
return;
|
|
}
|
|
if (len > 16383)
|
|
len = 16383;
|
|
FS_Read(handle, file, len);
|
|
file[len] = 0;
|
|
FS_Close(handle);
|
|
|
|
p = file;
|
|
|
|
ver = GetInteger(&p, handle);
|
|
if (ver != HUD_VERSION)
|
|
{
|
|
Con_Printf("Hud version doesn't match (%i != %i)\n", ver, HUD_VERSION);
|
|
return;
|
|
}
|
|
numelements = GetInteger(&p, handle);
|
|
if (numelements > MAX_ELEMENTS)
|
|
{
|
|
numelements = 0;
|
|
Con_Printf("Hud has too many elements\n");
|
|
return;
|
|
}
|
|
for (i = 0; i < numelements; i++)
|
|
{
|
|
x = GetFloat(&p, handle);
|
|
y = GetFloat(&p, handle);
|
|
sx = GetFloat(&p, handle);
|
|
sy = GetFloat(&p, handle);
|
|
type = GetInteger(&p, handle);
|
|
subtype = GetInteger(&p, handle);
|
|
a = GetFloat(&p, handle);
|
|
|
|
if (type<0 || type>=sizeof(drawelement)/sizeof(drawelement[0]))
|
|
{
|
|
numelements--;
|
|
i--;
|
|
continue;
|
|
}
|
|
|
|
element[i].x = x;
|
|
element[i].y = y;
|
|
element[i].scalex = sx;
|
|
element[i].scaley = sy;
|
|
element[i].alpha = a;
|
|
element[i].type = type;
|
|
element[i].subtype = subtype;
|
|
}
|
|
}
|
|
|
|
// FindItemUnderMouse: given mouse coordinates, finds element number under mouse
|
|
// returns -1 if no element found
|
|
int FindItemUnderMouse(int mx, int my)
|
|
{
|
|
int i;
|
|
int rv;
|
|
|
|
rv = -1;
|
|
|
|
for (i = 0; i < numelements; i++)
|
|
{
|
|
if (element[i].scalex < 0)
|
|
{
|
|
if (element[i].x < mx)
|
|
continue;
|
|
if (element[i].x + element[i].scalex*drawelement[element[i].type].width > mx)
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if (element[i].x > mx)
|
|
continue;
|
|
if (element[i].x + element[i].scalex*drawelement[element[i].type].width < mx)
|
|
continue;
|
|
}
|
|
if (element[i].scaley < 0)
|
|
{
|
|
if (element[i].y < my)
|
|
continue;
|
|
if (element[i].y + element[i].scaley*drawelement[element[i].type].height > my)
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if (element[i].y > my)
|
|
continue;
|
|
if (element[i].y + element[i].scaley*drawelement[element[i].type].height < my)
|
|
continue;
|
|
}
|
|
|
|
rv = i;
|
|
}
|
|
|
|
return rv; // no element found
|
|
}
|
|
|
|
void DrawContextMenu(int mx, int my)
|
|
{
|
|
int i;
|
|
int y;
|
|
Draw_Colour4f(0, 0, 0, 0.4);
|
|
Draw_Fill((mouseofsx-8)*sbarscalex, (mouseofsy-8)*sbarscaley, (float)112*sbarscalex, (float)(9*8)*sbarscaley);
|
|
Draw_Colour4f(1,1,1,1);
|
|
|
|
sbarminx = mouseofsx*sbarscalex;
|
|
sbarminy = mouseofsy*sbarscaley;
|
|
|
|
my -= mouseofsy;
|
|
my/=8;
|
|
my--;
|
|
|
|
y = 0;
|
|
UI_DrawString("CONTEXT MENU", 0, y);
|
|
y+=8;
|
|
UI_DrawString("------------", 0, y);
|
|
y+=8;
|
|
Draw_Colour4f(1-(my--)!=0,1,1,1);
|
|
UI_DrawString("Clone", 0, y);
|
|
y+=8;
|
|
Draw_Colour4f(1-(my--)!=0,1,1,1);
|
|
UI_DrawString("Snap To Grid", 0, y);
|
|
if (shiftdown)
|
|
UI_DrawString("X", -8, y);
|
|
y+=8;
|
|
Draw_Colour4f(1-(my--)!=0,1,1,1);
|
|
UI_DrawString("Save", 0, y);
|
|
y+=8;
|
|
Draw_Colour4f(1-(my--)!=0,1,1,1);
|
|
UI_DrawString("Reload", 0, y);
|
|
y+=8;
|
|
Draw_Colour4f(1-(my--)!=0,1,1,1);
|
|
UI_DrawString("Defaults", 0, y);
|
|
y+=8;
|
|
|
|
Draw_Colour4f(1,1,1,1);
|
|
}
|
|
|
|
void UI_KeyPress(int key, int mx, int my)
|
|
{
|
|
int i;
|
|
if (key == K_ESCAPE)
|
|
{
|
|
Menu_Control(0);
|
|
return;
|
|
}
|
|
|
|
if (context)
|
|
{
|
|
i = my - mouseofsy;
|
|
i /= 8;
|
|
context = false;
|
|
switch(i)
|
|
{
|
|
case 2: //clone
|
|
if (numelements==MAX_ELEMENTS)
|
|
return; //too many
|
|
memcpy(element+numelements, element+currentitem, sizeof(hudelement_t));
|
|
currentitem = numelements;
|
|
numelements++;
|
|
break;
|
|
case 3: //snap
|
|
shiftdown ^= 1;
|
|
break;
|
|
case 4: //save
|
|
Hud_Save(NULL);
|
|
break;
|
|
case 5: //reload
|
|
Hud_Load(NULL);
|
|
break;
|
|
case 6: //defaults
|
|
SBar_FlushAll();
|
|
SBar_ReloadDefaults();
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (key == K_MOUSE1)
|
|
{ //figure out which one our cursor is over...
|
|
mousedown = false;
|
|
|
|
i = FindItemUnderMouse(mx, my);
|
|
if (i != -1)
|
|
{
|
|
int oldcurrent;
|
|
float big;
|
|
oldcurrent = currentitem;
|
|
currentitem = i;
|
|
|
|
mouseofsx = mx - element[i].x;
|
|
mouseofsy = my - element[i].y;
|
|
mousedown |= 1;
|
|
|
|
if (element[i].scalex < 0)
|
|
{
|
|
if (mx > element[i].x+4)
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
big = element[i].scalex*drawelement[element[i].type].width;
|
|
if (mx-element[i].x+4 < big)
|
|
return;
|
|
}
|
|
|
|
if (my < element[i].y+4)
|
|
{
|
|
if (currentitem == oldcurrent)
|
|
UI_KeyPress('d', 0, 0);
|
|
return;
|
|
}
|
|
|
|
if (element[i].scaley < 0)
|
|
{
|
|
if (my > element[i].y+4)
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
big = element[i].scaley*drawelement[element[i].type].height;
|
|
if (my-element[i].y+4 < big)
|
|
return;
|
|
}
|
|
|
|
mouseofsx = mx - element[i].scalex*drawelement[element[i].type].width;
|
|
mouseofsy = my - element[i].scaley*drawelement[element[i].type].height;
|
|
mousedown |= 2;
|
|
}
|
|
}
|
|
|
|
// TODO: extra buttons
|
|
// - toggle clip to edges and clip to other controls
|
|
// - maybe toggle snap to grid instead of holding shift with mouse?
|
|
|
|
else if (key == K_MOUSE2)
|
|
{
|
|
mousedown = false; //perhaps not logically true, but it's safest this way.
|
|
context = true;
|
|
|
|
mouseofsx = mx;
|
|
mouseofsy = my;
|
|
}
|
|
else if (key == 'n')
|
|
{
|
|
currentitem++;
|
|
if (currentitem >= numelements)
|
|
currentitem = 0;
|
|
}
|
|
else if (key == 'm')
|
|
{
|
|
currentitem--;
|
|
if (currentitem < 0)
|
|
currentitem = numelements ? numelements - 1 : 0;
|
|
}
|
|
else 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 == K_PAGEUP)
|
|
{ //send to back
|
|
hudelement_t temp;
|
|
|
|
memcpy(&temp, element+currentitem, sizeof(temp));
|
|
memmove(element+1, element, sizeof(hudelement_t) * (currentitem));
|
|
memcpy(element, &temp, sizeof(hudelement_t));
|
|
currentitem = 0;
|
|
}
|
|
else if (key == K_PAGEDOWN)
|
|
{ //bring to front
|
|
hudelement_t temp;
|
|
|
|
memcpy(&temp, element+currentitem, sizeof(temp));
|
|
memcpy(element+currentitem, element+currentitem+1, sizeof(element[0]) * (numelements - currentitem-1));
|
|
currentitem = numelements - 1;
|
|
memcpy(element+currentitem , &temp, sizeof(hudelement_t));
|
|
}
|
|
else if (key == 'q')
|
|
{
|
|
element[currentitem].type--;
|
|
if (element[currentitem].type < 0)
|
|
element[currentitem].type = sizeof(drawelement)/sizeof(drawelement[0])-1;
|
|
}
|
|
else if (key == 'w')
|
|
{
|
|
element[currentitem].type++;
|
|
if (element[currentitem].type >= sizeof(drawelement)/sizeof(drawelement[0]))
|
|
element[currentitem].type = 0;
|
|
}
|
|
else if (key == ',' || key == K_MWHEELUP)
|
|
{
|
|
element[currentitem].subtype--;
|
|
if (element[currentitem].subtype < 0)
|
|
element[currentitem].subtype = drawelement[element[currentitem].type].maxsubtype;
|
|
}
|
|
else if (key == '.' || key == K_MWHEELDOWN)
|
|
{
|
|
element[currentitem].subtype++;
|
|
if (element[currentitem].subtype > drawelement[element[currentitem].type].maxsubtype)
|
|
element[currentitem].subtype = 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;
|
|
element[currentitem].alpha=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
|
|
|
|
// TODO: some sort of element property display
|
|
if (context)
|
|
{
|
|
}
|
|
else if (mousedown)
|
|
{
|
|
if (mousedown & 2) //2 is 'on the scaler'
|
|
{
|
|
float w = args[2] - mouseofsx;
|
|
float h = args[3] - mouseofsy;
|
|
if (shiftdown || (mousedown & 4)) //4 is mouse2
|
|
{
|
|
w -= (int)w & 7;
|
|
h -= (int)h & 7;
|
|
}
|
|
if (w < 8 && w > -8)
|
|
w = 8;
|
|
if (h < 8 && h > -8)
|
|
h = 8;
|
|
element[currentitem].scalex = w/drawelement[element[currentitem].type].width;
|
|
element[currentitem].scaley = h/drawelement[element[currentitem].type].height;
|
|
}
|
|
else
|
|
{
|
|
element[currentitem].x = args[2] - mouseofsx;
|
|
element[currentitem].y = args[3] - mouseofsy;
|
|
if (shiftdown || (mousedown & 4)) //4 is mouse2
|
|
{
|
|
element[currentitem].x -= (int)element[currentitem].x & 7;
|
|
element[currentitem].y -= (int)element[currentitem].y & 7;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
hoveritem = FindItemUnderMouse(args[2], args[3]); // this could possibly slow some things down...
|
|
|
|
altargs[0] = 0;
|
|
altargs[1] = 0;
|
|
altargs[2] = 0;
|
|
altargs[3] = vid.width;
|
|
altargs[4] = vid.height;
|
|
if (hudedit)
|
|
UI_StatusBarEdit(altargs);
|
|
else
|
|
UI_StatusBar(altargs); //draw it using the same function (we're lazy)
|
|
|
|
UI_DrawHandles(altargs, currentitem);
|
|
|
|
sbarscalex = vid.width/640.0f;
|
|
sbarscaley = vid.height/480.0f;
|
|
if (context)
|
|
{
|
|
|
|
DrawContextMenu(args[2], args[3]);
|
|
}
|
|
sbarminx = args[2];
|
|
sbarminy = args[3];
|
|
|
|
Draw_Colour4f(1,1,1,1);
|
|
Draw_Image((float)args[2]*sbarscalex, (float)args[3]*sbarscaley, (float)32*sbarscalex, (float)32*sbarscaley, 0, 0, 1, 1, pic_cursor);
|
|
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;
|
|
hudedit=true;
|
|
return 1;
|
|
}
|
|
if (!strcmp("sbar_save", cmd))
|
|
{
|
|
Cmd_Argv(1, cmd, sizeof(cmd));
|
|
Hud_Save(cmd);
|
|
mousedown=false;
|
|
return 1;
|
|
}
|
|
if (!strcmp("sbar_load", cmd))
|
|
{
|
|
Cmd_Argv(1, cmd, sizeof(cmd));
|
|
Hud_Load(cmd);
|
|
mousedown=false;
|
|
return 1;
|
|
}
|
|
if (!strcmp("sbar_defaults", cmd))
|
|
{
|
|
Cmd_Argv(1, cmd, sizeof(cmd));
|
|
SBar_FlushAll();
|
|
SBar_ReloadDefaults();
|
|
mousedown=false;
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int Plug_Init(int *args)
|
|
{
|
|
if (Plug_Export("Tick", Plug_Tick) &&
|
|
Plug_Export("SbarBase", UI_StatusBar) &&
|
|
Plug_Export("SbarOverlay", UI_ScoreBoard) &&
|
|
Plug_Export("ExecuteCommand", Plug_ExecuteCommand) &&
|
|
Plug_Export("MenuEvent", Plug_MenuEvent))
|
|
{
|
|
|
|
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_MOUSE2 = Key_GetKeyCode("mouse2");
|
|
K_MWHEELDOWN = Key_GetKeyCode("mwheeldown");
|
|
K_MWHEELUP = Key_GetKeyCode("mwheelup");
|
|
K_SHIFT = Key_GetKeyCode("shift");
|
|
K_PAGEUP = Key_GetKeyCode("pgup");
|
|
K_PAGEDOWN = Key_GetKeyCode("pgdn");
|
|
|
|
Cmd_AddCommand("sbar_edit");
|
|
if (BUILTINISVALID(FS_Write))
|
|
Cmd_AddCommand("sbar_save");
|
|
if (BUILTINISVALID(FS_Read))
|
|
Cmd_AddCommand("sbar_load");
|
|
Cmd_AddCommand("sbar_defaults");
|
|
|
|
UI_SbarInit();
|
|
|
|
if (BUILTINISVALID(FS_Read))
|
|
Hud_Load("");
|
|
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|