int CHudBackground::Draw(float flTime)
{
int r = 0, g = 0, b = 0, x = 0, y = 0;
int x_length = 0, y_length = 0; // positions of the spots
y_length = gHUD.GetSpriteRect(m_HUD_back).bottom - gHUD.GetSpriteRect(m_HUD_back).top;
x_length = gHUD.GetSpriteRect(m_HUD_back).right - gHUD.GetSpriteRect(m_HUD_back).left;
UnpackRGB(r, g, b, RGB_WHITEISH);
ScaleColors(r, g, b, 255);
// position the sprite in the upper right corner of display...
x = XRES(0);
y = (YRES(480) - y_length);
if (g_iWaterLevel != 3)
{
y_length = gHUD.GetSpriteRect(m_HUD_back).bottom - gHUD.GetSpriteRect(m_HUD_back).top;
x_length = gHUD.GetSpriteRect(m_HUD_back).right - gHUD.GetSpriteRect(m_HUD_back).left;
SPR_Set(m_hSprite, r, g, b);
SPR_DrawHoles(0, x, y, m_SpriteArea);
return 1;
}
else
{
y_length = gHUD.GetSpriteRect(m_HUD_water).bottom - gHUD.GetSpriteRect(m_HUD_water).top;
x_length = gHUD.GetSpriteRect(m_HUD_water).right - gHUD.GetSpriteRect(m_HUD_water).left;
SPR_Set(gHUD.GetSprite(m_HUD_water), r, g, b);
SPR_DrawHoles((((int)(flTime*14))%24), x, y, m_SpriteArea);
return 0;
}
}
int CHudHealth::DrawDamage(float flTime)
{
int r, g, b, a;
DAMAGE_IMAGE *pdmg;
if (!m_bitsDamage)
return 1;
UnpackRGB(r,g,b, RGB_YELLOWISH);
a = (int)( fabs(sin(flTime*2)) * 256.0);
ScaleColors(r, g, b, a);
// Draw all the items
int i;
for (i = 0; i < NUM_DMG_TYPES; i++)
{
if (m_bitsDamage & giDmgFlags[i])
{
pdmg = &m_dmg[i];
SPR_Set(gHUD.GetSprite(m_HUD_dmg_bio + i), r, g, b );
SPR_DrawAdditive(0, pdmg->x, pdmg->y, &gHUD.GetSpriteRect(m_HUD_dmg_bio + i));
}
}
// check for bits that should be expired
for ( i = 0; i < NUM_DMG_TYPES; i++ )
{
DAMAGE_IMAGE *pdmg = &m_dmg[i];
if ( m_bitsDamage & giDmgFlags[i] )
{
pdmg->fExpire = min( flTime + DMG_IMAGE_LIFE, pdmg->fExpire );
if ( pdmg->fExpire <= flTime // when the time has expired
&& a < 40 ) // and the flash is at the low point of the cycle
{
pdmg->fExpire = 0;
int y = pdmg->y;
pdmg->x = pdmg->y = 0;
// move everyone above down
for (int j = 0; j < NUM_DMG_TYPES; j++)
{
pdmg = &m_dmg[j];
if ((pdmg->y) && (pdmg->y < y))
pdmg->y += giDmgHeight;
}
m_bitsDamage &= ~giDmgFlags[i]; // clear the bits
}
}
}
return 1;
}
int CHudHealth::Draw(float flTime)
{
int r, g, b;
int a = 0, x, y;
int HealthWidth;
if ( (gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH) || gEngfuncs.IsSpectateOnly() )
return 1;
if ( !m_HSPRITE )
m_HSPRITE = LoadSprite(PAIN_NAME);
// Has health changed? Flash the health #
if (m_fFade)
{
m_fFade -= (gHUD.m_flTimeDelta * 20);
if (m_fFade <= 0)
{
a = MIN_ALPHA;
m_fFade = 0;
}
// Fade the health number back to dim
a = MIN_ALPHA + (m_fFade/FADE_TIME) * 128;
}
else
a = MIN_ALPHA;
// If health is getting low, make it bright red
if (m_iHealth <= 15)
a = 255;
GetPainColor( r, g, b );
ScaleColors(r, g, b, a );
// Only draw health if we have the suit.
if (gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)))
{
HealthWidth = gHUD.GetSpriteRect(gHUD.m_HUD_number_0).right - gHUD.GetSpriteRect(gHUD.m_HUD_number_0).left;
int CrossWidth = gHUD.GetSpriteRect(m_HUD_cross).right - gHUD.GetSpriteRect(m_HUD_cross).left;
y = ScreenHeight - gHUD.m_iFontHeight - gHUD.m_iFontHeight / 2;
x = CrossWidth /2;
SPR_Set(gHUD.GetSprite(m_HUD_cross), r, g, b);
SPR_DrawAdditive(0, x, y, &gHUD.GetSpriteRect(m_HUD_cross));
x = CrossWidth + HealthWidth / 2;
//x = gHUD.DrawHudNumber(x, y, DHN_3DIGITS | DHN_DRAWZERO, m_iHealth, r, g, b);
gHUD.DrawHudNumber2( x, y, false, 3, m_iHealth, r, g, b);
}
DrawDamage(flTime);
return DrawPain(flTime);
}
int CHudAmmoSecondary::Draw( float flTime )
{
if( ( gHUD.m_iHideHUDDisplay & ( HIDEHUD_WEAPONS | HIDEHUD_ALL ) ) )
return 1;
// draw secondary ammo icons above normal ammo readout
int a, x, y, r, g, b, AmmoWidth;
UnpackRGB( r, g, b, RGB_YELLOWISH );
a = (int)max( MIN_ALPHA, m_fFade );
if( m_fFade > 0 )
m_fFade -= ( gHUD.m_flTimeDelta * 20 ); // slowly lower alpha to fade out icons
ScaleColors( r, g, b, a );
AmmoWidth = gHUD.GetSpriteRect( gHUD.m_HUD_number_0 ).right - gHUD.GetSpriteRect( gHUD.m_HUD_number_0 ).left;
y = ScreenHeight - ( gHUD.m_iFontHeight * 4 ); // this is one font height higher than the weapon ammo values
x = ScreenWidth - AmmoWidth;
if( m_HUD_ammoicon )
{
// Draw the ammo icon
x -= ( gHUD.GetSpriteRect( m_HUD_ammoicon ).right - gHUD.GetSpriteRect( m_HUD_ammoicon ).left );
y -= ( gHUD.GetSpriteRect( m_HUD_ammoicon ).top - gHUD.GetSpriteRect( m_HUD_ammoicon ).bottom );
SPR_Set( gHUD.GetSprite( m_HUD_ammoicon ), r, g, b );
SPR_DrawAdditive( 0, x, y, &gHUD.GetSpriteRect( m_HUD_ammoicon ) );
}
else
{
// move the cursor by the '0' char instead, since we don't have an icon to work with
x -= AmmoWidth;
y -= ( gHUD.GetSpriteRect( gHUD.m_HUD_number_0 ).top - gHUD.GetSpriteRect( gHUD.m_HUD_number_0 ).bottom );
}
// draw the ammo counts, in reverse order, from right to left
for( int i = MAX_SEC_AMMO_VALUES-1; i >= 0; i-- )
{
if( m_iAmmoAmounts[i] < 0 )
continue; // negative ammo amounts imply that they shouldn't be drawn
// half a char gap between the ammo number and the previous pic
x -= ( AmmoWidth / 2 );
// draw the number, right-aligned
x -= ( gHUD.GetNumWidth( m_iAmmoAmounts[i], DHN_DRAWZERO ) * AmmoWidth );
gHUD.DrawHudNumber( x, y, DHN_DRAWZERO, m_iAmmoAmounts[i], r, g, b );
if( i != 0 )
{
// draw the divider bar
x -= ( AmmoWidth / 2 );
FillRGBA( x, y, ( AmmoWidth/10 ), gHUD.m_iFontHeight, r, g, b, a );
}
}
return 1;
}
int CHudFlashlight::Draw(float flTime)
{
if ( gHUD.m_iHideHUDDisplay & ( HIDEHUD_FLASHLIGHT | HIDEHUD_ALL ) )
return 1;
int r, g, b, x, y, a;
wrect_t rc;
if (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) ))
return 1;
if (m_fOn)
a = 225;
else
a = MIN_ALPHA;
if (m_flBat < 0.20)
UnpackRGB(r,g,b, RGB_REDISH);
else
{
gHUD.GetPrimaryHudColor(r, g, b);
}
ScaleColors(r, g, b, a);
y = (m_prc1->bottom - m_prc2->top)/2;
x = ScreenWidth() - m_iWidth - m_iWidth/2 ;
// Draw the flashlight casing
SPR_Set(m_hSprite1, r, g, b );
SPR_DrawAdditive( 0, x, y, m_prc1);
if ( m_fOn )
{ // draw the flashlight beam
x = ScreenWidth() - m_iWidth/2;
SPR_Set( m_hBeam, r, g, b );
SPR_DrawAdditive( 0, x, y, m_prcBeam );
}
// draw the flashlight energy level
x = ScreenWidth() - m_iWidth - m_iWidth/2 ;
int iOffset = m_iWidth * (1.0 - m_flBat);
if (iOffset < m_iWidth)
{
rc = *m_prc2;
rc.left += iOffset;
SPR_Set(m_hSprite2, r, g, b );
SPR_DrawAdditive( 0, x + iOffset, y, &rc);
}
return 1;
}
bool CHudFlashlight::Draw(float flTime)
{
if ( GetHud().GetHideHudBits().Any( HIDEHUD_FLASHLIGHT | HIDEHUD_ALL ) )
return true;
int r, g, b, x, y, a;
wrect_t rc;
if (!( Hud().GetWeaponBits() & (1<<(WEAPON_SUIT)) ))
return true;
if (m_fOn)
a = 225;
else
a = MIN_ALPHA;
if (m_flBat < 0.20)
GetHud().GetEmptyItemColor().UnpackRGB(r,g,b);
else
GetHud().GetPrimaryColor().UnpackRGB(r,g,b);
ScaleColors(r, g, b, a);
y = (m_prc1->bottom - m_prc2->top)/2;
x = ScreenWidth - m_iWidth - m_iWidth/2 ;
// Draw the flashlight casing
SPR_Set(m_hSprite1, r, g, b );
SPR_DrawAdditive( 0, x, y, m_prc1);
if ( m_fOn )
{ // draw the flashlight beam
x = ScreenWidth - m_iWidth/2;
SPR_Set( m_hBeam, r, g, b );
SPR_DrawAdditive( 0, x, y, m_prcBeam );
}
// draw the flashlight energy level
x = ScreenWidth - m_iWidth - m_iWidth/2 ;
int iOffset = m_iWidth * (1.0 - m_flBat);
if (iOffset < m_iWidth)
{
rc = *m_prc2;
rc.left += iOffset;
SPR_Set(m_hSprite2, r, g, b );
SPR_DrawAdditive( 0, x + iOffset, y, &rc);
}
return true;
}
int CHudAmmo::Draw(float flTime)
{
int a, x, y, r, g, b;
int AmmoWidth;
int iCrossX;
int iCrossY;
int iCrossLength;
char *chCrossHair = "+"; // Heh
/*if (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) ))
return 1;*/
if((gHUD.m_iHideHUDDisplay & (HIDEHUD_WEAPONS | HIDEHUD_ALL)))
return 1;
// Draw Weapon Menu
DrawWList(flTime);
// Draw ammo pickup history
gHR.DrawAmmoHistory(flTime);
if(!(m_iFlags & HUD_ACTIVE))
return 0;
if(!m_pWeapon)
return 0;
WEAPON *pw = m_pWeapon; // shorthand
// SPR_Draw Ammo
if((pw->iAmmoType < 0) && (pw->iAmmo2Type < 0))
return 0;
int iFlags = DHN_DRAWZERO; // draw 0 values
AmmoWidth = gHUD.GetSpriteRect(gHUD.m_HUD_number_0).right - gHUD.GetSpriteRect(gHUD.m_HUD_number_0).left;
a = (int)max(MIN_ALPHA, m_fFade);
if(m_fFade > 0)
m_fFade -= (gHUD.m_flTimeDelta * 20);
UnpackRGB(r, g, b, RGB_YELLOWISH);
ScaleColors(r, g, b, a);
// Does this weapon have a clip?
y = ScreenHeight - gHUD.m_iFontHeight - gHUD.m_iFontHeight / 2;
/******************* DRAW CROSSHAIR *********************/
iCrossLength = gHUD.m_scrinfo.charWidths[*chCrossHair];
iCrossY = ScreenHeight / 2 - gHUD.m_scrinfo.iCharHeight / 2;
iCrossX = ScreenWidth / 2 - iCrossLength / 2;
gHUD.DrawHudString(iCrossX, iCrossY, iCrossX + 50, chCrossHair, 170, 170, 170);
/******************* DRAW CROSSHAIR *********************/
// Does weapon have any ammo at all?
if(m_pWeapon->iAmmoType > 0)
{
int iIconWidth = m_pWeapon->rcAmmo.right - m_pWeapon->rcAmmo.left;
if(pw->iClip >= 0)
{
x = ScreenWidth - (8 * AmmoWidth) - iIconWidth;
UnpackRGB(r, g, b, RGB_YELLOWISH);
// GL Seems to need this
ScaleColors(r, g, b, a);
m_iNumberXPosition = x = gHUD.DrawHudNumber(x, y, iFlags | DHN_3DIGITS, gWR.CountAmmo(pw->iAmmoType), r, g, b);
}
// Draw the ammo Icon
int iOffset = (m_pWeapon->rcAmmo.bottom - m_pWeapon->rcAmmo.top) / 8;
SPR_Set(m_pWeapon->hAmmo, r, g, b);
SPR_DrawAdditive(0, x, y - iOffset, &m_pWeapon->rcAmmo);
m_iXPosition = x;
}
return 1;
}
int CHudStatusBar::Draw(float fTime)
{
int r, g, b, a, name_r, name_g, name_b;
if(m_bReparseString)
{
for(int i = 0; i < MAX_STATUSBAR_LINES; i++)
ParseStatusString(i);
m_bReparseString = FALSE;
}
//Not Watching anyone
if(m_iStatusValues[1] == 0)
{
m_iFlags &= ~HUD_ACTIVE;
return 1;
}
// Draw the status bar lines
for(int i = 0; i < MAX_STATUSBAR_LINES; i++)
{
int TextHeight = 0;
int TotalTextWidth = 0;
//Ugly way to get
if(m_iTeamMate[i])
{
TotalTextWidth += gHUD.ReturnStringPixelLength(m_szName[i]);
TotalTextWidth += gHUD.ReturnStringPixelLength(m_szHealth[i]);
TotalTextWidth += gHUD.ReturnStringPixelLength(m_szArmor[i]);
TotalTextWidth += 48;
TextHeight = gHUD.m_scrinfo.iCharHeight;
}
else
TotalTextWidth += gHUD.ReturnStringPixelLength(m_szName[i]);
TextHeight = gHUD.m_scrinfo.iCharHeight;
if(g_iNameColors == 1)
{
name_r = 255;
name_g = 50;
name_b = 50;
}
else if(g_iNameColors == 2)
{
name_r = 50;
name_g = 50;
name_b = 255;
}
else
name_r = name_g = name_b = 255;
int Y_START;
if(ScreenHeight >= 480)
Y_START = ScreenHeight - 55;
else
Y_START = ScreenHeight - 45;
int x = gHUD.m_Ammo.m_iNumberXPosition;
int y = Y_START; // = ( ScreenHeight / 2 ) + ( TextHeight * 3 );
int x_offset;
a = 200;
UnpackRGB(r, g, b, RGB_NORMAL);
ScaleColors(r, g, b, a);
ScaleColors(name_r, name_g, name_b, 125);
//Draw the name First
gHUD.DrawHudString(x, y, 1024, m_szName[i], name_r, name_g, name_b);
if(!m_iTeamMate[i])
continue;
//Get the length in pixels for the name
x_offset = gHUD.ReturnStringPixelLength(m_szName[i]);
//Add the offset
x += (x_offset + 8);
//Now draw the Sprite for the health
SPR_Set(m_hHealth, r, g, b);
SPR_DrawHoles(0, x, y, &gHUD.GetSpriteRect(m_iHealthSpriteIndex));
//Add the sprite width size
x += 16;
//Draw the health value ( x + offset for the name lenght + width of the sprite )
gHUD.DrawHudString(x, y, 1024, m_szHealth[i], name_r, name_g, name_b);
//Get the length in pixels for the health
x_offset = gHUD.ReturnStringPixelLength(m_szHealth[i]);
//Add the offset
x += (x_offset + 8);
//Now draw the Sprite for the Armor
SPR_Set(m_hArmor, r, g, b);
SPR_DrawHoles(0, x, y, &gHUD.GetSpriteRect(m_iArmorSpriteIndex));
x += 16;
//Draw the armor value ( x + offset for the name lenght + width of the sprite )
gHUD.DrawHudString(x, y, 1024, m_szArmor[i], name_r, name_g, name_b);
}
return 1;
}
int CHudScores::Draw(float time)
{
if (cl_scores->value < 1.0f)
return 0;
const size_t rows_to_draw = static_cast<size_t>(cl_scores->value);
const uint8_t alpha = static_cast<uint8_t>(std::min(255.0f, std::max(0.0f, cl_scores_alpha->value)));
int x, y;
if (sscanf(cl_scores_pos->string, "%d %d", &x, &y) != 2) {
x = 0;
y = 0;
}
std::array<ScoreRow, NUM_ROWS> rows;
size_t row_count = 0;
const auto scoreboard = gViewPort->GetScoreBoard();
if (!gHUD.m_Teamplay) {
gViewPort->GetAllPlayersInfo();
for (int row = 0; row < scoreboard->m_iRows; ++row) {
if (scoreboard->m_iIsATeam[row])
continue;
const auto sorted = scoreboard->m_iSortedRows[row];
if (g_IsSpectator[sorted])
continue;
const int score = g_PlayerExtraInfo[sorted].frags;
const uint8_t color = g_PlayerExtraInfo[sorted].teamnumber % iNumberOfTeamColors;
char* name = nullptr;
if (steam_id::is_showing_real_names())
name = const_cast<char*>(steam_id::get_real_name(sorted - 1).c_str());
if (!name || name[0] == '\0')
name = g_PlayerInfoList[sorted].name;
if (!name || name[0] == '\0')
continue;
rows[row_count].score = score;
rows[row_count].name = name;
rows[row_count].color = color;
if (++row_count >= rows_to_draw)
break;
}
} else {
for (int row = 0; row < scoreboard->m_iRows; ++row) {
if (scoreboard->m_iIsATeam[row] != TEAM_YES)
continue;
const auto sorted = scoreboard->m_iSortedRows[row];
const int score = g_TeamInfo[sorted].frags;
const uint8_t color = g_TeamInfo[sorted].teamnumber % iNumberOfTeamColors;
char* name = g_TeamInfo[sorted].name;
rows[row_count].score = score;
rows[row_count].name = name;
rows[row_count].color = color;
if (++row_count >= rows_to_draw)
break;
}
}
const auto last_row = rows.cbegin() + row_count;
// Figure out the scoreboard dimensions.
int score_width = 0, name_width = 0;
for (auto row = rows.cbegin(); row != last_row; ++row) {
char buf[16];
std::snprintf(buf, ARRAYSIZE(buf), "%d", row->score);
score_width = std::max(score_width, gHUD.GetHudStringWidth(buf));
name_width = std::max(name_width, gHUD.GetHudStringWidthWithColorTags(row->name));
}
// Draw the scoreboard.
for (auto row = rows.cbegin(); row != last_row; ++row) {
int r = iTeamColors[row->color][0],
g = iTeamColors[row->color][1],
b = iTeamColors[row->color][2];
FillRGBA(x, y, PADDING + score_width + GAP + name_width + PADDING, gHUD.m_scrinfo.iCharHeight, r, g, b, alpha);
ScaleColors(r, g, b, 135);
char buf[16];
std::snprintf(buf, ARRAYSIZE(buf), "%d", row->score);
gHUD.DrawHudStringRightAligned(x + PADDING + score_width, y, buf, r, g, b);
gHUD.DrawHudStringWithColorTags(x + PADDING + score_width + GAP,
y,
row->name,
r,
g,
b);
y += gHUD.m_scrinfo.iCharHeight;
}
return 0;
}
int CHudHealth::DrawPain(float flTime)
{
if(!(m_fAttackFront || m_fAttackRear || m_fAttackLeft || m_fAttackRight))
return 1;
int r, g, b;
int x, y, a, shade;
// TODO: get the shift value of the health
a = 255; // max brightness until then
float fFade = gHUD.m_flTimeDelta * 2;
// SPR_Draw top
if(m_fAttackFront > 0.4)
{
GetPainColor(r, g, b);
shade = a * max(m_fAttackFront, 0.5);
ScaleColors(r, g, b, shade);
SPR_Set(m_hSprite, r, g, b);
x = ScreenWidth / 2 - SPR_Width(m_hSprite, 0) / 2;
y = ScreenHeight / 2 - SPR_Height(m_hSprite, 0) * 3;
SPR_DrawAdditive(0, x, y, NULL);
m_fAttackFront = max(0, m_fAttackFront - fFade);
}
else
m_fAttackFront = 0;
if(m_fAttackRight > 0.4)
{
GetPainColor(r, g, b);
shade = a * max(m_fAttackRight, 0.5);
ScaleColors(r, g, b, shade);
SPR_Set(m_hSprite, r, g, b);
x = ScreenWidth / 2 + SPR_Width(m_hSprite, 1) * 2;
y = ScreenHeight / 2 - SPR_Height(m_hSprite, 1) / 2;
SPR_DrawAdditive(1, x, y, NULL);
m_fAttackRight = max(0, m_fAttackRight - fFade);
}
else
m_fAttackRight = 0;
if(m_fAttackRear > 0.4)
{
GetPainColor(r, g, b);
shade = a * max(m_fAttackRear, 0.5);
ScaleColors(r, g, b, shade);
SPR_Set(m_hSprite, r, g, b);
x = ScreenWidth / 2 - SPR_Width(m_hSprite, 2) / 2;
y = ScreenHeight / 2 + SPR_Height(m_hSprite, 2) * 2;
SPR_DrawAdditive(2, x, y, NULL);
m_fAttackRear = max(0, m_fAttackRear - fFade);
}
else
m_fAttackRear = 0;
if(m_fAttackLeft > 0.4)
{
GetPainColor(r, g, b);
shade = a * max(m_fAttackLeft, 0.5);
ScaleColors(r, g, b, shade);
SPR_Set(m_hSprite, r, g, b);
x = ScreenWidth / 2 - SPR_Width(m_hSprite, 3) * 3;
y = ScreenHeight / 2 - SPR_Height(m_hSprite, 3) / 2;
SPR_DrawAdditive(3, x, y, NULL);
m_fAttackLeft = max(0, m_fAttackLeft - fFade);
}
else
m_fAttackLeft = 0;
return 1;
}
int CHudFlashlight::Draw( float flTime )
{
static bool show = ( gHUD.m_iHideHUDDisplay & ( HIDEHUD_FLASHLIGHT | HIDEHUD_ALL ) );
if( show != !( gHUD.m_iHideHUDDisplay & ( HIDEHUD_FLASHLIGHT | HIDEHUD_ALL ) ) )
{
show = !( gHUD.m_iHideHUDDisplay & ( HIDEHUD_FLASHLIGHT | HIDEHUD_ALL ) );
if( gMobileEngfuncs )
{
gMobileEngfuncs->pfnTouchHideButtons( "flashlight", !show );
}
}
if( !show )
return 1;
int r, g, b, x, y, a;
wrect_t rc;
if( gEngfuncs.IsSpectateOnly() )
return 1;
if( !( gHUD.m_iWeaponBits & ( 1 << ( WEAPON_SUIT ) ) ) )
return 1;
if( m_fOn )
a = 225;
else
a = MIN_ALPHA;
if( m_flBat < 0.20 )
UnpackRGB( r,g,b, RGB_REDISH );
else
UnpackRGB( r,g,b, RGB_YELLOWISH );
ScaleColors( r, g, b, a );
y = ( m_prc1->bottom - m_prc2->top ) / 2;
x = ScreenWidth - m_iWidth - m_iWidth / 2 ;
// Draw the flashlight casing
SPR_Set( m_hSprite1, r, g, b );
SPR_DrawAdditive( 0, x, y, m_prc1 );
if( m_fOn )
{
// draw the flashlight beam
x = ScreenWidth - m_iWidth / 2;
SPR_Set( m_hBeam, r, g, b );
SPR_DrawAdditive( 0, x, y, m_prcBeam );
}
// draw the flashlight energy level
x = ScreenWidth - m_iWidth - m_iWidth / 2;
int iOffset = m_iWidth * ( 1.0 - m_flBat );
if( iOffset < m_iWidth )
{
rc = *m_prc2;
rc.left += iOffset;
SPR_Set( m_hSprite2, r, g, b );
SPR_DrawAdditive( 0, x + iOffset, y, &rc );
}
return 1;
}
int CHudHealth::Draw(float flTime)
{
int r, g, b;
int a = 0, x, y;
int HealthWidth;
// if (m_iHealth <= 0)
// return 1;
if ( gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH )
return 1;
if ( !m_hSprite )
m_hSprite = LoadSprite(PAIN_NAME);
// Has health changed? Flash the health #
if (m_fFade)
{
m_fFade -= (gHUD.m_flTimeDelta * 20);
if (m_fFade <= 0)
{
a = MIN_ALPHA;
m_fFade = 0;
}
// Fade the health number back to dim
a = MIN_ALPHA + (m_fFade/FADE_TIME) * 128;
}
else
a = MIN_ALPHA;
// If health is getting low, make it bright red
if (m_iHealth <= 15)
a = 255;
GetPainColor( r, g, b );
ScaleColors(r, g, b, a );
// Only draw health if we have the suit.
{
HealthWidth = gHUD.GetSpriteRect(gHUD.m_HUD_number_0).right - gHUD.GetSpriteRect(gHUD.m_HUD_number_0).left;
int CrossWidth = gHUD.GetSpriteRect(m_HUD_cross).right - gHUD.GetSpriteRect(m_HUD_cross).left;
y = ScreenHeight - gHUD.m_iFontHeight - gHUD.m_iFontHeight / 2;
x = CrossWidth /2;
SPR_Set(gHUD.GetSprite(m_HUD_cross), r, g, b);
SPR_DrawAdditive(0, x, y, &gHUD.GetSpriteRect(m_HUD_cross));
x = CrossWidth + HealthWidth / 2;
x = gHUD.DrawHudNumber(x, y, DHN_3DIGITS | DHN_DRAWZERO, m_iHealth, r, g, b);
x += HealthWidth/2;
int iHeight = gHUD.m_iFontHeight;
int iWidth = HealthWidth/10;
FillRGBA(x, y, iWidth, iHeight, 255, 160, 0, a);
}
DrawDamage(flTime);
return DrawPain(flTime);
}
//
// Draw Ammo pickup history
//
int HistoryResource::DrawAmmoHistory(float flTime)
{
for(int i = 0; i < MAX_HISTORY; i++)
{
if(rgAmmoHistory[i].type)
{
rgAmmoHistory[i].DisplayTime = min(rgAmmoHistory[i].DisplayTime, gHUD.m_flTime + HISTORY_DRAW_TIME);
if(rgAmmoHistory[i].DisplayTime <= flTime)
{ // pic drawing time has expired
memset(&rgAmmoHistory[i], 0, sizeof(HIST_ITEM));
CheckClearHistory();
}
else if(rgAmmoHistory[i].type == HISTSLOT_AMMO)
{
wrect_t rcPic;
HSPRITE *spr = gWR.GetAmmoPicFromWeapon(rgAmmoHistory[i].iId, rcPic);
int r, g, b;
UnpackRGB(r, g, b, RGB_YELLOWISH);
float scale = (rgAmmoHistory[i].DisplayTime - flTime) * 80;
ScaleColors(r, g, b, min(scale, 255));
// Draw the pic
int ypos = ScreenHeight - (AMMO_PICKUP_PICK_HEIGHT + (AMMO_PICKUP_GAP * i));
int xpos = ScreenWidth - 24;
if(spr && *spr) // weapon isn't loaded yet so just don't draw the pic
{ // the dll has to make sure it has sent info the weapons you need
SPR_Set(*spr, r, g, b);
SPR_DrawAdditive(0, xpos, ypos, &rcPic);
}
// Draw the number
gHUD.DrawHudNumberString(xpos - 10, ypos, xpos - 100, rgAmmoHistory[i].iCount, r, g, b);
}
else if(rgAmmoHistory[i].type == HISTSLOT_WEAP)
{
WEAPON *weap = gWR.GetWeapon(rgAmmoHistory[i].iId);
if(!weap)
return 1; // we don't know about the weapon yet, so don't draw anything
int r, g, b;
UnpackRGB(r, g, b, RGB_YELLOWISH);
if(!gWR.HasAmmo(weap))
UnpackRGB(r, g, b, RGB_REDISH); // if the weapon doesn't have ammo, display it as red
float scale = (rgAmmoHistory[i].DisplayTime - flTime) * 80;
ScaleColors(r, g, b, min(scale, 255));
int ypos = ScreenHeight - (AMMO_PICKUP_PICK_HEIGHT + (AMMO_PICKUP_GAP * i));
int xpos = ScreenWidth - (weap->rcInactive.right - weap->rcInactive.left);
SPR_Set(weap->hInactive, r, g, b);
SPR_DrawAdditive(0, xpos, ypos, &weap->rcInactive);
}
else if(rgAmmoHistory[i].type == HISTSLOT_ITEM)
{
int r, g, b;
if(!rgAmmoHistory[i].iId)
continue; // sprite not loaded
wrect_t rect = gHUD.GetSpriteRect(rgAmmoHistory[i].iId);
UnpackRGB(r, g, b, RGB_YELLOWISH);
float scale = (rgAmmoHistory[i].DisplayTime - flTime) * 80;
ScaleColors(r, g, b, min(scale, 255));
int ypos = ScreenHeight - (AMMO_PICKUP_PICK_HEIGHT + (AMMO_PICKUP_GAP * i));
int xpos = ScreenWidth - (rect.right - rect.left) - 10;
SPR_Set(gHUD.GetSprite(rgAmmoHistory[i].iId), r, g, b);
SPR_DrawAdditive(0, xpos, ypos, &rect);
}
}
}
return 1;
}
int CHudHealth::DrawDamage(float flTime)
{
int r, g, b, a;
DAMAGE_IMAGE *pdmg;
if (!m_bitsDamage)
return 1;
UnpackRGB(r,g,b, RGB_YELLOWISH);
a = (int)( fabs(sin(flTime*2)) * 256.0);
ScaleColors(r, g, b, a);
// Draw all the items
for (int i = 0; i < NUM_DMG_TYPES; i++)
{
if (m_bitsDamage & giDmgFlags[i])
{
pdmg = &m_dmg[i];
SPR_Set(gHUD.GetSprite(m_HUD_dmg_bio + i), r, g, b );
// Discwar: Hack. Freeze is the only icon we use. Just place it directly above the disc ammo
int iX = (ScreenWidth - DISC_ICON_WIDTH) / 2;
int iXPos = iX - DISC_ICON_SPACER;
SPR_DrawAdditive(0, iXPos + (DISC_ICON_SPACER), ScreenHeight - YRES(92), &gHUD.GetSpriteRect(m_HUD_dmg_bio + i));
}
}
/*
// check for bits that should be expired
for ( i = 0; i < NUM_DMG_TYPES; i++ )
{
DAMAGE_IMAGE *pdmg = &m_dmg[i];
if ( m_bitsDamage & giDmgFlags[i] )
{
pdmg->fExpire = min( flTime + DMG_IMAGE_LIFE, pdmg->fExpire );
if ( pdmg->fExpire <= flTime // when the time has expired
&& a < 40 ) // and the flash is at the low point of the cycle
{
pdmg->fExpire = 0;
int y = pdmg->y;
pdmg->x = pdmg->y = 0;
// move everyone above down
for (int j = 0; j < NUM_DMG_TYPES; j++)
{
pdmg = &m_dmg[j];
if ((pdmg->y) && (pdmg->y < y))
pdmg->y += giDmgHeight;
}
m_bitsDamage &= ~giDmgFlags[i]; // clear the bits
}
}
}
*/
return 1;
}
int CHudBattery::Draw(float flTime)
{
if ( gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH )
return 1;
int r, g, b, x, y, a;
wrect_t rc;
rc = *m_prc2;
int theMaxArmor = gHUD.GetHUDMaxArmor();
float theScalar = 1.0f/theMaxArmor;
rc.top += m_iHeight * ((float)(theMaxArmor-(min(theMaxArmor, m_iBat))) * theScalar); // battery can go from 0 to 100 so * 0.01 goes from 0 to 1
gHUD.GetPrimaryHudColor(r, g, b);
if (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) ))
return 1;
// Has health changed? Flash the health #
if (m_fFade)
{
if (m_fFade > FADE_TIME)
m_fFade = FADE_TIME;
m_fFade -= (gHUD.m_flTimeDelta * 20);
if (m_fFade <= 0)
{
a = 128;
m_fFade = 0;
}
// Fade the health number back to dim
a = MIN_ALPHA + (m_fFade/FADE_TIME) * 128;
}
else
a = MIN_ALPHA;
ScaleColors(r, g, b, a );
int iOffset = (m_prc1->bottom - m_prc1->top)/6;
int theInset = 0;
if(gHUD.GetIsAlien())
{
theInset = ScreenWidth()*kResourceEnergyBarWidth;
}
int theViewport[4];
gHUD.GetViewport(theViewport);
y = theViewport[1] + theViewport[3] - gHUD.m_iFontHeight - gHUD.m_iFontHeight / 2;
x = theViewport[0] + theInset + kArmorLeftInset*ScreenWidth();
// make sure we have the right sprite handles
if ( !m_hSprite1 )
m_hSprite1 = gHUD.GetSprite( gHUD.GetSpriteIndex( "suit_empty" ) );
if ( !m_hSprite2 )
m_hSprite2 = gHUD.GetSprite( gHUD.GetSpriteIndex( "suit_full" ) );
SPR_Set(m_hSprite1, r, g, b );
SPR_DrawAdditive( 0, x, y - iOffset, m_prc1);
if (rc.bottom > rc.top)
{
SPR_Set(m_hSprite2, r, g, b );
SPR_DrawAdditive( 0, x, y - iOffset + (rc.top - m_prc2->top), &rc);
}
x += (m_prc1->right - m_prc1->left);
x = gHUD.DrawHudNumber(x, y, DHN_3DIGITS | DHN_DRAWZERO, m_iBat, r, g, b);
return 1;
}
//
// Draw Weapon Menu
//
int CHudAmmo::DrawWList(float flTime)
{
int r, g, b, x, y, a, i;
if(!gpActiveSel)
return 0;
int iActiveSlot;
if(gpActiveSel == (WEAPON *)1)
iActiveSlot = -1; // current slot has no weapons
else
iActiveSlot = gpActiveSel->iSlot;
x = 10; //!!!
y = 10; //!!!
// Ensure that there are available choices in the active slot
if(iActiveSlot > 0)
{
if(!gWR.GetFirstPos(iActiveSlot))
{
gpActiveSel = (WEAPON *)1;
iActiveSlot = -1;
}
}
// Draw top line
for(i = 0; i < MAX_WEAPON_SLOTS; i++)
{
int iWidth;
UnpackRGB(r, g, b, RGB_YELLOWISH);
if(iActiveSlot == i)
a = 255;
else
a = 192;
ScaleColors(r, g, b, 255);
SPR_Set(gHUD.GetSprite(m_HUD_bucket0 + i), r, g, b);
// make active slot wide enough to accomodate gun pictures
if(i == iActiveSlot)
{
WEAPON *p = gWR.GetFirstPos(iActiveSlot);
if(p)
iWidth = p->rcActive.right - p->rcActive.left;
}
else
iWidth = giBucketWidth;
if(i == iActiveSlot)
SPR_DrawAdditive(0, x + 104, y, &gHUD.GetSpriteRect(m_HUD_bucket0 + i));
else
SPR_DrawAdditive(0, x, y, &gHUD.GetSpriteRect(m_HUD_bucket0 + i));
x += iWidth + 5;
}
a = 128; //!!!
x = 10;
// Draw all of the buckets
for(i = 1; i < MAX_WEAPON_SLOTS + 1; i++)
{
y = giBucketHeight + 10;
// If this is the active slot, draw the bigger pictures,
// otherwise just draw boxes
if(i == iActiveSlot)
{
WEAPON *p = gWR.GetFirstPos(i);
int iWidth = giBucketWidth;
if(p)
iWidth = p->rcActive.right - p->rcActive.left;
for(int iPos = 0; iPos < MAX_WEAPON_POSITIONS; iPos++)
{
p = gWR.GetWeaponSlot(i, iPos);
if(!p || !p->iId)
continue;
UnpackRGB(r, g, b, RGB_YELLOWISH);
// if active, then we must have ammo.
if(gpActiveSel == p)
{
if(gWR.HasAmmo(p))
ScaleColors(r, g, b, 192);
else
{
UnpackRGB(r, g, b, RGB_REDISH);
ScaleColors(r, g, b, 128);
}
SPR_Set(p->hActive, r, g, b);
SPR_DrawAdditive(0, x, y, &p->rcActive);
}
else
{
// Draw Weapon if Red if no ammo
if(gWR.HasAmmo(p))
ScaleColors(r, g, b, 192);
else
{
UnpackRGB(r, g, b, RGB_REDISH);
ScaleColors(r, g, b, 128);
}
SPR_Set(p->hInactive, r, g, b);
SPR_DrawAdditive(0, x, y, &p->rcInactive);
}
// Draw Ammo Bar
DrawAmmoBar(p, x + giABWidth / 2, y, giABWidth, giABHeight);
y += p->rcActive.bottom - p->rcActive.top + 5;
}
x += iWidth + 5;
}
else
{
// Draw Row of weapons.
UnpackRGB(r, g, b, RGB_YELLOWISH);
for(int iPos = 0; iPos < MAX_WEAPON_POSITIONS; iPos++)
{
WEAPON *p = gWR.GetWeaponSlot(i, iPos);
if(!p || !p->iId)
continue;
if(gWR.HasAmmo(p))
{
UnpackRGB(r, g, b, RGB_YELLOWISH);
a = 128;
}
else
{
UnpackRGB(r, g, b, RGB_REDISH);
a = 96;
}
FillRGBA(x, y, giBucketWidth, giBucketHeight, r, g, b, a);
y += giBucketHeight + 5;
}
x += giBucketWidth + 5;
}
}
return 1;
}
bool CHudBattery::Draw(float flTime)
{
if ( gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH )
return true;
wrect_t rc;
rc = *m_prc2;
#if defined( _TFC )
float fScale = 0.0;
if ( m_iBatMax > 0 )
fScale = 1.0 / (float)m_iBatMax;
rc.top += m_iHeight * ((float)(m_iBatMax-(min(m_iBatMax,m_iBat))) * fScale); // battery can go from 0 to m_iBatMax so * fScale goes from 0 to 1
#else
rc.top += m_iHeight * ((float)(100-(min(100,m_iBat))) * 0.01); // battery can go from 0 to 100 so * 0.01 goes from 0 to 1
#endif
if (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) ))
return true;
int r, g, b, x, y, a = MIN_ALPHA;
gHUD.GetPrimaryColor().UnpackRGB( r, g, b );
// Has health changed? Flash the health #
if (m_fFade)
{
if (m_fFade > FADE_TIME)
m_fFade = FADE_TIME;
m_fFade -= (gHUD.m_flTimeDelta * 20);
if (m_fFade <= 0)
{
m_fFade = 0;
}
// Fade the health number back to dim
a += ( m_fFade / FADE_TIME ) * 128;
}
ScaleColors(r, g, b, a );
int iOffset = (m_prc1->bottom - m_prc1->top)/6;
y = ScreenHeight - gHUD.m_iFontHeight - gHUD.m_iFontHeight / 2;
x = ScreenWidth/5;
// make sure we have the right sprite handles
if ( !m_hSprite1 )
m_hSprite1 = gHUD.GetSprite( gHUD.GetSpriteIndex( "suit_empty" ) );
if ( !m_hSprite2 )
m_hSprite2 = gHUD.GetSprite( gHUD.GetSpriteIndex( "suit_full" ) );
SPR_Set(m_hSprite1, r, g, b );
SPR_DrawAdditive( 0, x, y - iOffset, m_prc1);
if (rc.bottom > rc.top)
{
SPR_Set(m_hSprite2, r, g, b );
SPR_DrawAdditive( 0, x, y - iOffset + (rc.top - m_prc2->top), &rc);
}
x += (m_prc1->right - m_prc1->left);
x = gHUD.DrawHudNumber(x, y, DHN_3DIGITS | DHN_DRAWZERO, m_iBat, r, g, b);
return true;
}
int CHudAmmo::Draw(float flTime)
{
int a, x, y, r, g, b;
int AmmoWidth;
if (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) ))
return 1;
if ( (gHUD.m_iHideHUDDisplay & ( HIDEHUD_WEAPONS | HIDEHUD_ALL )) )
return 1;
// Draw Weapon Menu
DrawWList(flTime);
// Draw ammo pickup history
gHR.DrawAmmoHistory( flTime );
if (!(m_iFlags & HUD_ACTIVE))
return 0;
if (!m_pWeapon)
return 0;
// Fograin92: We're rendering ammo counters using new HUD, begone with this thing!
return 0;
WEAPON *pw = m_pWeapon; // shorthand
// SPR_Draw Ammo
if ((pw->iAmmoType < 0) && (pw->iAmmo2Type < 0))
return 0;
int iFlags = DHN_DRAWZERO; // draw 0 values
AmmoWidth = gHUD.GetSpriteRect(gHUD.m_HUD_number_0).right - gHUD.GetSpriteRect(gHUD.m_HUD_number_0).left;
a = (int) max( MIN_ALPHA, m_fFade );
if (m_fFade > 0)
m_fFade -= (gHUD.m_flTimeDelta * 20);
// Fograin92: A little changes
//UnpackRGB(r,g,b, RGB_YELLOWISH);
r = SM_HUDcolor(1);
g = SM_HUDcolor(2);
b = SM_HUDcolor(3);
ScaleColors(r, g, b, a );
// Does this weapon have a clip?
y = ScreenHeight - gHUD.m_iFontHeight - gHUD.m_iFontHeight/2;
// Does weapon have any ammo at all?
if (m_pWeapon->iAmmoType > 0)
{
int iIconWidth = m_pWeapon->rcAmmo.right - m_pWeapon->rcAmmo.left;
if (pw->iClip >= 0)
{
// room for the number and the '|' and the current ammo
x = ScreenWidth - (8 * AmmoWidth) - iIconWidth;
x = gHUD.DrawHudNumber(x, y, iFlags | DHN_3DIGITS, pw->iClip, r, g, b);
wrect_t rc;
rc.top = 0;
rc.left = 0;
rc.right = AmmoWidth;
rc.bottom = 100;
int iBarWidth = AmmoWidth/10;
x += AmmoWidth/2;
// Fograin92: A little changes
//UnpackRGB(r,g,b, RGB_YELLOWISH);
r = SM_HUDcolor(1);
g = SM_HUDcolor(2);
b = SM_HUDcolor(3);
// draw the | bar
FillRGBA(x, y, iBarWidth, gHUD.m_iFontHeight, r, g, b, a);
x += iBarWidth + AmmoWidth/2;;
// GL Seems to need this
ScaleColors(r, g, b, a );
x = gHUD.DrawHudNumber(x, y, iFlags | DHN_3DIGITS, gWR.CountAmmo(pw->iAmmoType), r, g, b);
}
else
{
// SPR_Draw a bullets only line
x = ScreenWidth - 4 * AmmoWidth - iIconWidth;
x = gHUD.DrawHudNumber(x, y, iFlags | DHN_3DIGITS, gWR.CountAmmo(pw->iAmmoType), r, g, b);
}
// Draw the ammo Icon
int iOffset = (m_pWeapon->rcAmmo.bottom - m_pWeapon->rcAmmo.top)/8;
SPR_Set(m_pWeapon->hAmmo, r, g, b);
SPR_DrawAdditive(0, x, y - iOffset, &m_pWeapon->rcAmmo);
}
// Does weapon have seconday ammo?
if (pw->iAmmo2Type > 0)
{
int iIconWidth = m_pWeapon->rcAmmo2.right - m_pWeapon->rcAmmo2.left;
// Do we have secondary ammo?
if ((pw->iAmmo2Type != 0) && (gWR.CountAmmo(pw->iAmmo2Type) > 0))
{
y -= gHUD.m_iFontHeight + gHUD.m_iFontHeight/4;
x = ScreenWidth - 4 * AmmoWidth - iIconWidth;
x = gHUD.DrawHudNumber(x, y, iFlags|DHN_3DIGITS, gWR.CountAmmo(pw->iAmmo2Type), r, g, b);
// Draw the ammo Icon
SPR_Set(m_pWeapon->hAmmo2, r, g, b);
int iOffset = (m_pWeapon->rcAmmo2.bottom - m_pWeapon->rcAmmo2.top)/8;
SPR_DrawAdditive(0, x, y - iOffset, &m_pWeapon->rcAmmo2);
}
}
return 1;
}
int CHudBattery::Draw(float flTime)
{
if ( gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH )
return 1;
// modif de jUlien
if ( !(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT))) )
return 1;
/*
int r, g, b, x, y, a;
wrect_t rc;
rc = *m_prc2;
rc.top += m_iHeight * ((float)(100-(min(100,m_iBat))) * 0.01); // battery can go from 0 to 100 so * 0.01 goes from 0 to 1
UnpackRGB(r,g,b, RGB_YELLOWISH);
if (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) ))
return 1;
// Has health changed? Flash the health #
if (m_fFade)
{
if (m_fFade > FADE_TIME)
m_fFade = FADE_TIME;
m_fFade -= (gHUD.m_flTimeDelta * 20);
if (m_fFade <= 0)
{
a = 128;
m_fFade = 0;
}
// Fade the health number back to dim
a = MIN_ALPHA + (m_fFade/FADE_TIME) * 128;
}
else
a = MIN_ALPHA;
ScaleColors(r, g, b, a );
int iOffset = (m_prc1->bottom - m_prc1->top)/6;
y = ScreenHeight - gHUD.m_iFontHeight - gHUD.m_iFontHeight / 2;
x = ScreenWidth/5;
// make sure we have the right sprite handles
if ( !m_hSprite1 )
m_hSprite1 = gHUD.GetSprite( gHUD.GetSpriteIndex( "suit_empty" ) );
if ( !m_hSprite2 )
m_hSprite2 = gHUD.GetSprite( gHUD.GetSpriteIndex( "suit_full" ) );
SPR_Set(m_hSprite1, r, g, b );
SPR_DrawAdditive( 0, x, y - iOffset, m_prc1);
if (rc.bottom > rc.top)
{
SPR_Set(m_hSprite2, r, g, b );
SPR_DrawAdditive( 0, x, y - iOffset + (rc.top - m_prc2->top), &rc);
}
x += (m_prc1->right - m_prc1->left);
x = gHUD.DrawHudNumber(x, y, DHN_3DIGITS | DHN_DRAWZERO, m_iBat, r, g, b);
*/
// modif de Julien
// affichage du nouveau hud
for ( int i = 0; i < 7; i++ )
{
// couleurs précalculées
int r = m_flArmor[i][0], g = m_flArmor[i][1], b = m_flArmor[i][2];
// brillance pour les dommages
if ( m_flPain[i] > 0 )
{
// blanc
r = r + ( m_flPain[i] / ARMOR_PAIN_TIME ) * ( 255 - r );
g = g + ( m_flPain[i] / ARMOR_PAIN_TIME ) * ( 255 - g );
b = b + ( m_flPain[i] / ARMOR_PAIN_TIME ) * ( 255 - b );
m_flPain[i] = max ( 0, m_flPain[i] - gHUD.m_flTimeDelta );
}
if ( m_flPain[i] < 0 )
{
// rouge
r = r + ( -m_flPain[i] / ARMOR_PAIN_TIME ) * ( 255 - r );
g = g + ( -m_flPain[i] / ARMOR_PAIN_TIME ) * ( 0 - g );
b = b + ( -m_flPain[i] / ARMOR_PAIN_TIME ) * ( 0 - b );
m_flPain[i] = min ( 0, m_flPain[i] + gHUD.m_flTimeDelta );
}
ScaleColors ( r,g,b, 200 );
SPR_Set( m_sprCorps, r, g, b );
SPR_DrawAdditive(i, 0, 0, &m_wrcCorps);
}
//-----------------------
return 1;
}
bool CHudAmmo::Draw(float flTime)
{
int a, x, y, r, g, b;
int AmmoWidth;
if (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) ))
return true;
if ( (gHUD.m_iHideHUDDisplay & ( HIDEHUD_WEAPONS | HIDEHUD_ALL )) )
return true;
// Draw Weapon Menu
DrawWList(flTime);
// Draw ammo pickup history
gHR.DrawAmmoHistory( flTime );
if (!(m_iFlags & HUD_ACTIVE))
return false;
if (!m_pWeapon)
return false;
if( m_pCrosshair->value != 0 && m_hCrosshair != INVALID_HSPRITE )
{
float flScale;
switch( static_cast<int>( m_pCrosshairMode->value ) )
{
default:
case CROSS_NATIVESCALE:
flScale = 1;
break;
case CROSS_RESSCALE:
flScale = max( ( ScreenWidth / 640.0 ) * 0.75, 1.0 );
break;
case CROSS_USERSCALE:
flScale = abs( m_pCrosshairScale->value );
break;
}
class CCrosshairTriCallback : public ITriCoordFallback
{
public:
void Calculate( HSPRITE hSprite, const int frame, const wrect_t& rect, const float flScale, int& x, int& y ) override
{
x = ( ScreenWidth - ( ( rect.right - rect.left ) ) ) / 2;
y = ( ScreenHeight - ( ( rect.bottom - rect.top ) ) ) / 2;
}
};
CCrosshairTriCallback callback;
Tri_DrawScaledSprite( m_hCrosshair, 0, m_iR, m_iG, m_iB, 255, kRenderTransTexture, flScale, callback, &m_CrosshairRC );
}
CBasePlayerWeapon *pw = m_pWeapon; // shorthand
// SPR_Draw Ammo
if( !pw->GetWeaponInfo()->GetPrimaryAmmo() && !pw->GetWeaponInfo()->GetSecondaryAmmo() )
return false;
int iFlags = DHN_DRAWZERO; // draw 0 values
AmmoWidth = gHUD.GetSpriteRect(gHUD.m_HUD_number_0).right - gHUD.GetSpriteRect(gHUD.m_HUD_number_0).left;
a = (int) max( static_cast<float>( MIN_ALPHA ), m_fFade );
if (m_fFade > 0)
m_fFade -= (gHUD.m_flTimeDelta * 20);
gHUD.GetPrimaryColor().UnpackRGB(r,g,b);
ScaleColors(r, g, b, a );
// Does this weapon have a clip?
y = ScreenHeight - gHUD.m_iFontHeight - gHUD.m_iFontHeight/2;
CBasePlayer* pPlayer = g_Prediction.GetLocalPlayer();
// Does weapon have any ammo at all?
if ( auto pAmmo = pw->GetWeaponInfo()->GetPrimaryAmmo() )
{
const auto& ammo = m_pWeapon->GetWeaponInfo()->GetHUDInfo()->GetPrimaryAmmo();
int iIconWidth = ammo.rect.right - ammo.rect.left;
if (pw->m_iClientClip >= 0)
{
// room for the number and the '|' and the current ammo
x = ScreenWidth - (8 * AmmoWidth) - iIconWidth;
x = gHUD.DrawHudNumber(x, y, iFlags | DHN_3DIGITS, pw->m_iClientClip, r, g, b);
wrect_t rc;
rc.top = 0;
rc.left = 0;
rc.right = AmmoWidth;
rc.bottom = 100;
int iBarWidth = AmmoWidth/10;
x += AmmoWidth/2;
gHUD.GetPrimaryColor().UnpackRGB(r,g,b);
// draw the | bar
FillRGBA(x, y, iBarWidth, gHUD.m_iFontHeight, r, g, b, a);
x += iBarWidth + AmmoWidth/2;;
// GL Seems to need this
ScaleColors(r, g, b, a );
x = gHUD.DrawHudNumber(x, y, iFlags | DHN_3DIGITS, pPlayer->CountAmmo( pAmmo->GetID() ), r, g, b);
}
else
{
// SPR_Draw a bullets only line
x = ScreenWidth - 4 * AmmoWidth - iIconWidth;
x = gHUD.DrawHudNumber(x, y, iFlags | DHN_3DIGITS, pPlayer->CountAmmo( pAmmo->GetID() ), r, g, b);
}
// Draw the ammo Icon
int iOffset = ( ammo.rect.bottom - ammo.rect.top)/8;
SPR_Set( ammo.hSprite, r, g, b);
SPR_DrawAdditive(0, x, y - iOffset, &ammo.rect );
}
// Does weapon have seconday ammo?
if ( auto pAmmo = pw->GetWeaponInfo()->GetSecondaryAmmo() )
{
const auto& ammo2 = m_pWeapon->GetWeaponInfo()->GetHUDInfo()->GetSecondaryAmmo();
int iIconWidth = ammo2.rect.right - ammo2.rect.left;
// Do we have secondary ammo?
if ( pPlayer->CountAmmo( pAmmo->GetID() ) > 0 )
{
y -= gHUD.m_iFontHeight + gHUD.m_iFontHeight/4;
x = ScreenWidth - 4 * AmmoWidth - iIconWidth;
x = gHUD.DrawHudNumber(x, y, iFlags|DHN_3DIGITS, pPlayer->CountAmmo( pAmmo->GetID() ), r, g, b);
// Draw the ammo Icon
SPR_Set( ammo2.hSprite, r, g, b);
int iOffset = ( ammo2.rect.bottom - ammo2.rect.top)/8;
SPR_DrawAdditive(0, x, y - iOffset, &ammo2.rect );
}
}
return true;
}
int CHudBattery::Draw( float flTime )
{
if( gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH )
return 1;
if (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) ))
return 1;
int r, g, b, x, y, a;
wrect_t rc;
rc = *m_prc2;
// battery can go from 0 to 100 so * 0.01 goes from 0 to 1
rc.top += m_iHeight * ((float)( 100 - ( min( 100, m_iBat ))) * 0.01f );
UnpackRGB( r, g, b, RGB_YELLOWISH );
// Has health changed? Flash the health #
if( m_fFade )
{
if( m_fFade > FADE_TIME )
m_fFade = FADE_TIME;
m_fFade -= (gHUD.m_flTimeDelta * 20);
if( m_fFade <= 0 )
{
a = 128;
m_fFade = 0;
}
// Fade the health number back to dim
a = MIN_ALPHA + (m_fFade / FADE_TIME) * 128;
}
else
{
a = MIN_ALPHA;
}
ScaleColors( r, g, b, a );
int iOffset = (m_prc1->bottom - m_prc1->top) / 6;
y = ScreenHeight - gHUD.m_iFontHeight - gHUD.m_iFontHeight / 2;
x = ScreenWidth / 5;
// make sure we have the right sprite handles
if( !m_hSprite1 )
m_hSprite1 = gHUD.GetSprite( gHUD.GetSpriteIndex( "suit_empty" ));
if( !m_hSprite2 )
m_hSprite2 = gHUD.GetSprite( gHUD.GetSpriteIndex( "suit_full" ));
if( !m_hSprite1Helmet )
m_hSprite1Helmet = gHUD.GetSprite( gHUD.GetSpriteIndex( "suithelmet_empty" ));
if( !m_hSprite2Helmet )
m_hSprite2Helmet = gHUD.GetSprite( gHUD.GetSpriteIndex( "suithelmet_full" ));
if( m_enArmorType == Vest )
SPR_Set( m_hSprite1, r, g, b );
else
SPR_Set( m_hSprite1Helmet, r, g, b );
SPR_DrawAdditive( 0, x, y - iOffset, m_prc1 );
if( rc.bottom > rc.top )
{
if( m_enArmorType == Vest )
SPR_Set( m_hSprite2, r, g, b );
else
SPR_Set( m_hSprite2Helmet, r, g, b );
SPR_DrawAdditive( 0, x, y - iOffset + (rc.top - m_prc2->top), &rc );
}
x += (m_prc1->right - m_prc1->left);
x = gHUD.DrawHudNumber( x, y, DHN_3DIGITS|DHN_DRAWZERO, m_iBat, r, g, b );
return 1;
}
//
// Draw Weapon Menu
//
int CHudAmmo::DrawWList(float flTime)
{
int r,g,b,x,y,a,i;
if ( !m_pActiveSel )
return 0;
int iActiveSlot;
if ( m_pActiveSel == ( CBasePlayerWeapon *)1 )
iActiveSlot = -1; // current slot has no weapons
else
iActiveSlot = m_pActiveSel->GetWeaponInfo()->GetBucket();
x = 10; //!!!
y = 10; //!!!
CBasePlayer* pPlayer = g_Prediction.GetLocalPlayer();
// Ensure that there are available choices in the active slot
if ( iActiveSlot > 0 )
{
if ( !pPlayer->GetFirstPos( iActiveSlot ) )
{
m_pActiveSel = ( CBasePlayerWeapon *)1;
iActiveSlot = -1;
}
}
// Shepard : determine how many buckets we should draw
int iBucketsToDraw = 0;
for ( i = 0; i < MAX_WEAPON_SLOTS; i++ )
{
for ( int j = 0; j < MAX_WEAPONS; j++ )
{
CBasePlayerWeapon *pWeapon = pPlayer->GetWeapon( i, j );
if ( pWeapon && pWeapon->GetWeaponInfo() && pWeapon->GetWeaponInfo()->GetBucket() > iBucketsToDraw )
iBucketsToDraw = pWeapon->GetWeaponInfo()->GetBucket();
}
}
iBucketsToDraw++;
// Draw top line
for ( i = 0; i < iBucketsToDraw; i++ )
{
int iWidth;
gHUD.GetPrimaryColor().UnpackRGB(r,g,b);
if ( iActiveSlot == i )
a = 255;
else
a = 192;
ScaleColors(r, g, b, 255);
SPR_Set(gHUD.GetSprite(m_HUD_bucket0 + i), r, g, b );
// make active slot wide enough to accomodate gun pictures
if ( i == iActiveSlot )
{
CBasePlayerWeapon *p = pPlayer->GetFirstPos(iActiveSlot);
if ( p )
iWidth = p->GetWeaponInfo()->GetHUDInfo()->GetActive().rect.right - p->GetWeaponInfo()->GetHUDInfo()->GetActive().rect.left;
else
iWidth = m_iBucketWidth;
}
else
iWidth = m_iBucketWidth;
SPR_DrawAdditive(0, x, y, &gHUD.GetSpriteRect(m_HUD_bucket0 + i));
x += iWidth + 5;
}
a = 128; //!!!
x = 10;
// Draw all of the buckets
for (i = 0; i < iBucketsToDraw; i++)
{
y = m_iBucketHeight + 10;
// If this is the active slot, draw the bigger pictures,
// otherwise just draw boxes
if ( i == iActiveSlot )
{
CBasePlayerWeapon *p = pPlayer->GetFirstPos( i );
int iWidth = m_iBucketWidth;
if ( p )
iWidth = p->GetWeaponInfo()->GetHUDInfo()->GetActive().rect.right - p->GetWeaponInfo()->GetHUDInfo()->GetActive().rect.left;
for ( int iPos = 0; iPos < MAX_WEAPONS; iPos++ )
{
p = pPlayer->GetWeapon( i, iPos );
if ( !p || !p->GetWeaponInfo() )
continue;
auto pHUDInfo = p->GetWeaponInfo()->GetHUDInfo();
gHUD.GetPrimaryColor().UnpackRGB( r,g,b );
// if active, then we must have ammo.
if ( m_pActiveSel == p )
{
SPR_Set( pHUDInfo->GetActive().hSprite, r, g, b );
SPR_DrawAdditive(0, x, y, &pHUDInfo->GetActive().rect );
SPR_Set(gHUD.GetSprite(m_HUD_selection), r, g, b );
SPR_DrawAdditive(0, x, y, &gHUD.GetSpriteRect(m_HUD_selection));
}
else
{
// Draw Weapon if Red if no ammo
if ( pPlayer->HasAmmo(p) )
ScaleColors(r, g, b, 192);
else
{
gHUD.GetEmptyItemColor().UnpackRGB(r,g,b);
ScaleColors(r, g, b, 128);
}
SPR_Set( pHUDInfo->GetInactive().hSprite, r, g, b );
SPR_DrawAdditive( 0, x, y, &pHUDInfo->GetInactive().rect );
}
// Draw Ammo Bar
DrawAmmoBar(p, x + m_iABWidth/2, y, m_iABWidth, m_iABHeight);
y += pHUDInfo->GetActive().rect.bottom - pHUDInfo->GetActive().rect.top + 5;
}
x += iWidth + 5;
}
else
{
// Draw Row of weapons.
gHUD.GetPrimaryColor().UnpackRGB(r,g,b);
for ( int iPos = 0; iPos < MAX_WEAPONS; iPos++ )
{
CBasePlayerWeapon *p = pPlayer->GetWeapon( i, iPos );
if ( !p || !p->GetWeaponInfo() )
continue;
if ( pPlayer->HasAmmo(p) )
{
gHUD.GetPrimaryColor().UnpackRGB(r,g,b);
a = 128;
}
else
{
gHUD.GetEmptyItemColor().UnpackRGB(r,g,b);
a = 96;
}
FillRGBA( x, y, m_iBucketWidth, m_iBucketHeight, r, g, b, a );
y += m_iBucketHeight + 5;
}
x += m_iBucketWidth + 5;
}
}
return 1;
}
