NXEngine v1.0.0.6

[NXEngine.git] / statusbar.cpp

#include "nx.h"
#include "statusbar.h"
#include "statusbar.fdh"

#ifdef WIDESCREEN
        #define STATUS_X        10
        #define STATUS_Y        10
#else
        #define STATUS_X        16
        #define STATUS_Y        16
#endif

#define HEALTH_X                        (STATUS_X+0)
#define HEALTH_Y                        (STATUS_Y+24)
#define HEALTHFILL_X            (HEALTH_X+24)
#define HEALTHFILL_Y            (HEALTH_Y+1)
#define HEALTHFILL_MAXLEN       39

#define WEAPONBAR_Y                     (STATUS_Y+1)
#define CURWEAPON_X                     (STATUS_X+1)

#define XPBAR_Y                         (STATUS_Y+16)           // Y coordinate of "XP" area
#define XPBAR_X                         (STATUS_X+24)           // X of yellow XP bar

#define AMMO_X                          (STATUS_X+32)
#define AMMO_Y                          (STATUS_Y+0)

#define NIKU_X                          STATUS_X
#define NIKU_Y                          8

#define FRAME_XP_BAR            0                       // empty bar frame
#define FRAME_XP_FILL           1                       // sprite to fill bar with
#define FRAME_XP_FLASH          2                       // white flashing when XP is gained
#define FRAME_XP_MAX            3                       // "MAX" when XP is at max on L3

//int displayed_health = 0;
//int healthdectimer = 0;
StatusBar statusbar;
static PercentBar PHealthBar;

// the "slide" effect when changing weapons
struct stWeaponSlide
{
        int lv_offset;                                  // offset of XP bar
        int wpn_offset;                                 // offset of weapon bar
        int ammo_offset;                                // offset of ammo, in addition to wpn_offset
        char timer;
        int move_dir;
        int firstWeapon;                                // weapon to show as current weapon
} slide;
#define SLIDE_LV_OFFSET                 16
#define SLIDE_TIMER_START               5


bool statusbar_init(void)
{
        InitPercentBar(&PHealthBar, player->hp);
        
        memset(&slide, 0, sizeof(slide));
        slide.firstWeapon = player->curWeapon;
        return 0;
}


void DrawStatusBar(void)
{
int level, curxp, maxxp;
int w, x;
bool maxed_out;

        //debug("%08x", game.bossbar.object);
        //debug("%s", game.bossbar.defeated ? "true" : "false");
        
        // handle animations etc
        RunStatusBar();
        
        // draw boss bar
        if (game.bossbar.object && !game.bossbar.defeated)
        {
                #define BOSSBAR_W       198
                // BOSS_X = 32 at normal resolution
                #define BOSS_X          ((SCREEN_WIDTH / 2) - (BOSSBAR_W / 2) - 29)
                #define BOSS_Y          (SCREEN_HEIGHT-20)
                draw_sprite(BOSS_X, BOSS_Y, SPR_TEXTBOX, 0, 0);
                draw_sprite(BOSS_X, BOSS_Y+8, SPR_TEXTBOX, 2, 0);
                draw_sprite(BOSS_X+8, BOSS_Y+4, SPR_BOSSHPICON, 0, 0);
                
                // e.g. bosses w/ multiple forms (Ballos)
                if (game.bossbar.object->hp > game.bossbar.starting_hp)
                        game.bossbar.starting_hp = game.bossbar.object->hp;
                
                RunPercentBar(&game.bossbar.bar, game.bossbar.object->hp);
                DrawPercentBar(&game.bossbar.bar, BOSS_X+40, BOSS_Y+5, game.bossbar.object->hp, game.bossbar.starting_hp, BOSSBAR_W);
        }
        
        if (game.frozen || player->inputs_locked) return;
        if (fade.getstate() != FS_NO_FADE) return;
        
        if (player->hp)
        {
                if (!player->hurt_flash_state)
                {
                        if (!game.debug.god)
                        {
                                // -- draw the health bar -----------------------------
                                draw_sprite(HEALTH_X, HEALTH_Y, SPR_HEALTHBAR, 0, 0);
                                
                                DrawPercentBar(&PHealthBar, HEALTHFILL_X, HEALTHFILL_Y, player->hp, player->maxHealth, HEALTHFILL_MAXLEN);
                                
                                // draw the health in numbers
                                DrawNumberRAlign(HEALTH_X+24, HEALTH_Y, SPR_WHITENUMBERS, PHealthBar.displayed_value);
                        }
                        
                        // -- draw the XP bar ---------------------------------
                        level = player->weapons[player->curWeapon].level;
                        curxp = player->weapons[player->curWeapon].xp;
                        maxxp = player->weapons[player->curWeapon].max_xp[level];
                        
                        if (player->curWeapon == WPN_NONE)
                        {
                                curxp = 0;
                                maxxp = 1;
                        }
                        
                        // draw XP bar and fill it
                        draw_sprite(XPBAR_X+slide.lv_offset, XPBAR_Y, SPR_XPBAR, FRAME_XP_BAR, 0);
                        
                        maxed_out = ((curxp == maxxp) && level == 2);
                        if (!maxed_out)
                                DrawPercentage(XPBAR_X+slide.lv_offset, XPBAR_Y, SPR_XPBAR, FRAME_XP_FILL, curxp, maxxp, sprites[SPR_XPBAR].w);
                        
                        // draw the white flashing if we just got more XP
                        // the time-left and flash-state are in separate variables--
                        // otherwise the Spur will not flash XP bar
                        if (statusbar.xpflashcount)
                        {
                                if (++statusbar.xpflashstate & 2)
                                {
                                        draw_sprite(XPBAR_X+slide.lv_offset, XPBAR_Y, SPR_XPBAR, FRAME_XP_FLASH, 0);
                                }
                                
                                statusbar.xpflashcount--;
                        }
                        else statusbar.xpflashstate = 0;
                        
                        // draw "MAX"
                        if (maxed_out)
                                draw_sprite(XPBAR_X+slide.lv_offset, XPBAR_Y, SPR_XPBAR, FRAME_XP_MAX, 0);
                        
                        // Level Number
                        DrawWeaponLevel(HEALTH_X + slide.lv_offset, XPBAR_Y, player->curWeapon);
                }
                
                // -- draw the weapon bar -----------------------------
                // draw current weapon
                if (player->curWeapon != WPN_NONE)
                        draw_sprite(CURWEAPON_X + slide.wpn_offset, WEAPONBAR_Y, SPR_ARMSICONS, slide.firstWeapon, 0);
                
                // draw ammo, note we draw ammo of firstweapon NOT current weapon, for slide effect
                DrawWeaponAmmo((AMMO_X + slide.wpn_offset + slide.ammo_offset), AMMO_Y, slide.firstWeapon);
                
                // draw other weapons
                w = slide.firstWeapon;
                x = STATUS_X + 64 + slide.wpn_offset + 1;
                for(;;)
                {
                        if (++w >= WPN_COUNT) w = 0;
                        if (w==slide.firstWeapon) break;
                        
                        if (player->weapons[w].hasWeapon)
                        {
                                draw_sprite(x, WEAPONBAR_Y, SPR_ARMSICONS, w, RIGHT);
                                x += 16;
                        }
                }
                
                DrawAirLeft((SCREEN_WIDTH/2) - (5*8), ((SCREEN_HEIGHT)/2)-16);
        }
}

void DrawAirLeft(int x, int y)
{
        if (player->airshowtimer)
        {
                draw_sprite(x, y, SPR_AIR, (player->airleft%30 > 10) ? 0:1, RIGHT);
                
                if (player->airshowtimer%6 < 4)
                        DrawNumber(x+32, y, player->airleft/10);
        }
}

void DrawWeaponAmmo(int x, int y, int wpn)
{
        // draw slash
        if (!player->hurt_flash_state || game.mode != GM_NORMAL)
        {
                draw_sprite(x, y+8, SPR_WHITENUMBERS, 11, 0);
        }
        
        if (!player->weapons[wpn].maxammo)
        {       // ammo is "not applicable"
                x += 16;
                draw_sprite(x, y, SPR_NAAMMO, 0, 0);
                draw_sprite(x, y+8, SPR_NAAMMO, 0, 0);
        }
        else
        {
                DrawNumber(x, y, player->weapons[wpn].ammo);
                DrawNumber(x, y+8, player->weapons[wpn].maxammo);
        }
}

void DrawWeaponLevel(int x, int y, int wpn)
{
        int level = (player->weapons[wpn].level + 1);
        if (wpn == WPN_NONE) level = 0;
        
        draw_sprite(x, y, SPR_XPLEVELICON, 0, 0);
        draw_sprite(x+16, y, SPR_WHITENUMBERS, level, 0);
}


static void RunStatusBar(void)
{
        // handle slowly decreasing the health when player is hurt
        // note how it only decrements while it's actually visible--i thought that was a nice touch
        if (!player->hurt_flash_state)
        {
                RunPercentBar(&PHealthBar, player->hp);
        }
        
        if (game.frozen || player->inputs_locked) return;
        if (fade.getstate() != FS_NO_FADE) return;
        
        // sliding effect when changing weapons
        if (slide.lv_offset)
        {       // next weapon
                slide.lv_offset += slide.move_dir;
                if (--slide.timer > 0)
                {
                        slide.wpn_offset += slide.move_dir;
                }
                else
                {
                        if (!slide.timer) slide.firstWeapon = player->curWeapon;
                        slide.wpn_offset = slide.lv_offset;
                        slide.ammo_offset = 0;
                }
        }
        else
        {
                slide.firstWeapon = player->curWeapon;
        }
}


// start the slide effect. if dir = LEFT, slides left (next weapon), if RIGHT does "prev weapon"
// newwpn = the weapon to change to
void weapon_slide(int dir, int newwpn)
{
int sign;
        if (slide.lv_offset) slide.firstWeapon = player->curWeapon;             // if already sliding change immediately
        if (dir==RIGHT) sign = -1; else sign = 1;
        
        slide.lv_offset = SLIDE_LV_OFFSET * sign;
        slide.timer = SLIDE_TIMER_START;
        slide.ammo_offset = 16 * sign;
        slide.move_dir = -2 * sign;
        player->curWeapon = newwpn;
}

// the opening slide effect on load/new game
void weapon_introslide()
{
        if (player->curWeapon == WPN_NONE)
        {
                weapon_slide(LEFT, player->curWeapon);
                return;
        }
        
        stat_PrevWeapon(true);
        slide.lv_offset = 0;
        stat_NextWeapon(true);
}

// switches to the next weapon in inventory
void stat_NextWeapon(bool quiet)
{
int w;

        w = player->curWeapon;
        if (w == WPN_NONE) return;
        
        for(;;)
        {
                if (++w >= WPN_COUNT) w = 0;
                
                if (player->weapons[w].hasWeapon || w == player->curWeapon)
                {
                        if (!quiet) sound(SND_SWITCH_WEAPON);
                        weapon_slide(LEFT, w);
                        return;
                }
        } while(w != player->curWeapon);
}

// switches to the previous weapon in inventory
void stat_PrevWeapon(bool quiet)
{
int w;

        w = player->curWeapon;
        if (w == WPN_NONE) return;
        
        for(;;)
        {
                if (--w < 0) w = WPN_COUNT-1;
                
                if (player->weapons[w].hasWeapon || w == player->curWeapon)
                {
                        if (!quiet) sound(SND_SWITCH_WEAPON);
                        weapon_slide(RIGHT, w);
                        return;
                }
        }
}


void InitPercentBar(PercentBar *bar, int starting_value)
{
        PHealthBar.displayed_value = starting_value;
        PHealthBar.dectimer = 0;
}

void RunPercentBar(PercentBar *bar, int current_value)
{
        if (current_value != bar->displayed_value)
        {
                if (current_value > bar->displayed_value)
                {
                        bar->displayed_value = current_value;
                }
                else
                {
                        if (++bar->dectimer > 0x1e)
                        {
                                bar->displayed_value--;
                        }
                }
        }
        else bar->dectimer = 0;
}

void DrawPercentBar(PercentBar *bar, int x, int y, int curvalue, int maxvalue, int width)
{
        if (bar->displayed_value != curvalue)
                DrawPercentage(x, y, SPR_HEALTHFILL, 1, bar->displayed_value, maxvalue, width);
                
        DrawPercentage(x, y, SPR_HEALTHFILL, 0, curvalue, maxvalue, width);
}

/*
void c------------------------------() {}
*/

// draws number "num" at x,y.
// leading zeroes are omitted, however, the space for them is still
// skipped over (left blank). thus it always leaves space for 3 digits.
void DrawNumber(int x, int y, int num)
{
static const int numtable[3] = { 1000, 100, 10 };
int place, digit, total;

        if (num > 9999) num = 9999;
        
        place = total = 0;
        while(place < 3)
        {
                digit = 0;
                while(num >= numtable[place])
                {
                        num -= numtable[place];
                        digit++;
                }
                
                total += digit;
                
                if (total)
                        draw_sprite(x+(place*8), y, SPR_WHITENUMBERS, digit);
                
                place++;
        }
        
        draw_sprite(x+(3*8), y, SPR_WHITENUMBERS, num);
}


void DrawPercentage(int x, int y, int fill_sprite, int fsframe, int curvalue, int maxvalue, int width_at_max)
{
        if (curvalue < 0) curvalue = 0;
        if (curvalue > 0 || maxvalue==0)
        {
                int fillwidth;
                
                if (curvalue >= maxvalue)
                {
                        fillwidth = width_at_max;
                }
                else
                {
                        fillwidth = (int)(((float)width_at_max / (float)maxvalue) * (float)curvalue);
                        if (!fillwidth) return;
                }
                
                draw_sprite_clip_width(x, y, fill_sprite, fsframe, fillwidth);
        }
}

// draws a given number using sprite 's' as the font
// the numbers are drawn right-aligned to "x".
void DrawNumberRAlign(int x, int y, int s, int num)
{
char str[50];
int i, len;
int fontwidth = sprites[s].w;

        sprintf(str, "%d", num);
        x -= strlen(str) * fontwidth;
        
        len = strlen(str);
        for(i=0;i<len;i++)
        {
                draw_sprite(x, y, s, str[i] - '0');
                x += fontwidth;
        }
}

void DrawTwoDigitNumber(int x, int y, int num)
{
        DrawDigit(x+0, y, num/10);
        DrawDigit(x+8, y, num%10);
}

void DrawDigit(int x, int y, int digit)
{
        draw_sprite(x, y, SPR_WHITENUMBERS, digit);
}

/*
void c------------------------------() {}
*/

// Nikumaru Counter
void niku_run()
{
        if (player->equipmask & EQUIP_NIKUMARU)
        {
                if (!game.frozen && !player->inputs_locked)
                {
                        if (game.counter < 300000)      // 100'00"0
                                game.counter++;
                }
        }
        else
        {
                game.counter = 0;
        }
}

void niku_draw(int value, bool force_white)
{
        int clkframe = (game.counter % 30) <= 10;
        if (game.frozen || player->inputs_locked || force_white) clkframe = 0;
        
        draw_sprite(NIKU_X, NIKU_Y, SPR_NIKU_CLOCK, clkframe);
        
        int mins = (value / 3000);              // the game runs at 50 fps
        int secs = (value / 50) % 60;
        int tens = (value / 5) % 10;
        
        DrawNumber(NIKU_X, NIKU_Y, mins);
        DrawTwoDigitNumber(NIKU_X+36, NIKU_Y, secs);
        DrawDigit(NIKU_X+56, NIKU_Y, tens);
        
        draw_sprite(NIKU_X+30, NIKU_Y, SPR_NIKU_PUNC);
}