mirror of https://github.com/nmlgc/ReC98.git
434 lines
12 KiB
C++
434 lines
12 KiB
C++
#include "th01/main/vars.hpp"
|
||
#include "th01/core/str_val.hpp"
|
||
#include "th01/formats/ptn.hpp"
|
||
#include "th01/formats/grf.hpp"
|
||
#include "th01/main/playfld.hpp"
|
||
#include "th01/main/player/player.hpp"
|
||
#include "th01/sprites/main_ptn.h"
|
||
#include "th01/main/hud/hud.hpp"
|
||
|
||
/// Constants
|
||
/// ---------
|
||
static const int LIVES_LEFT = 128;
|
||
static const int LIVES_TOP = 0;
|
||
static const int LIVES_PER_ROW = 6; // for all the cheaters?
|
||
|
||
static const int BOMBS_LEFT = 128;
|
||
static const int BOMBS_TOP = 16;
|
||
|
||
static const int SCORE_LEFT = 256;
|
||
static const int MAX_TOP = 0;
|
||
static const int CUR_TOP = 16;
|
||
|
||
static const int STAGE_LEFT = 608;
|
||
static const int STAGE_TOP = 32;
|
||
|
||
static const int PTN_LIFE_QUARTER = 0;
|
||
static const int PTN_BOMB_QUARTER = 1;
|
||
|
||
static const int MAX_FX = FX(7, 2, 0);
|
||
static const int CUR_FX = FX(7, 3, 0);
|
||
|
||
#if (PTN_QUARTER_W < GLYPH_FULL_W)
|
||
#error Original code assumes PTN_QUARTER_W >= GLYPH_FULL_W
|
||
#endif
|
||
#if (PTN_QUARTER_H < GLYPH_H)
|
||
#error Original code assumes PTN_QUARTER_H >= GLYPH_H
|
||
#endif
|
||
static const int COL_W = PTN_QUARTER_W;
|
||
static const int ROW_H = PTN_QUARTER_H;
|
||
|
||
static const int SCORE_W = (SCORE_DIGITS * COL_W);
|
||
|
||
static const int CARDCOMBO_LEFT = (SCORE_LEFT + ((SCORE_DIGITS + 2) * COL_W));
|
||
static const int CARDCOMBO_W = (CARDCOMBO_DIGITS * COL_W);
|
||
static const int CARDCOMBO_RIGHT = (CARDCOMBO_LEFT + CARDCOMBO_W);
|
||
|
||
static const int SCORE_AND_CARDCOMBO_W = (CARDCOMBO_RIGHT - SCORE_LEFT);
|
||
/// ---------
|
||
|
||
/// Globals
|
||
/// -------
|
||
// Forces re-rendering of all full-width numbers on the HUD, even if they
|
||
// haven't changed since the last render call.
|
||
extern unsigned char fwnum_force_rerender;
|
||
|
||
// extern uint8_t *hud_bg;
|
||
extern uint8_t hud_bg_rle_run_byte;
|
||
extern unsigned char hud_cardcombo_max; // Why a separate variable???
|
||
// size_t hud_bg_size;
|
||
/// -------
|
||
|
||
/// Functions
|
||
/// ---------
|
||
inline int col_left(int first_left, int col) {
|
||
return (first_left + (col * COL_W));
|
||
}
|
||
|
||
#define bg_put(first_left, col, top, ptn_id, quarter) \
|
||
ptn_put_quarter_noalpha_8(col_left(first_left, col), top, ptn_id, quarter)
|
||
|
||
#define bg_snap(first_left, col, top, ptn_id, quarter) \
|
||
ptn_snap_quarter_8(col_left(first_left, col), top, ptn_id, quarter)
|
||
|
||
#define sprite_put(first_left, col, top, ptn_id, quarter) \
|
||
ptn_put_quarter_8(col_left(first_left, col), top, ptn_id, quarter)
|
||
|
||
#define ptn_id_and_quarter_from_i(func, first_left, col, top, ptn_id_base, i) \
|
||
func(first_left, col, top, (ptn_id_base + (i / 4)), (i % 4))
|
||
|
||
#define digit_changed(var, var_prev, divisor) \
|
||
((var_prev / divisor) % 10) != ((var / divisor) % 10) || \
|
||
(fwnum_force_rerender == 1)
|
||
|
||
// Copies the (⌊[w]/16⌋*16)×[ROW_H] pixels starting at (⌊left/8⌋*8, top) from
|
||
// VRAM page 0 to VRAM page 1.
|
||
void graph_copy_hud_row_0_to_1_8(int left, int top, int w);
|
||
/// ---------
|
||
}
|
||
|
||
template <class T1, class T2> inline void fwnum_put(
|
||
int left, int top, int fx, int digits, const T1 &val, const T2 &val_prev
|
||
) {
|
||
graph_putfwnum_fx(
|
||
left, top, fx, digits, val,
|
||
(fwnum_force_rerender == true) ? 0 : val_prev, true
|
||
);
|
||
}
|
||
|
||
#define score_bg(func, digit, top, ptn_id_base) \
|
||
ptn_id_and_quarter_from_i(func, SCORE_LEFT, digit, top, ptn_id_base, digit)
|
||
|
||
#define score_max_bg(func, digit) \
|
||
score_bg(func, digit, MAX_TOP, PTN_BG_MAX_SCORE)
|
||
|
||
inline void score_put(int top, int fx, const long &prev) {
|
||
fwnum_put(SCORE_LEFT, top, fx, SCORE_DIGITS, score, prev);
|
||
}
|
||
|
||
#define cardcombo_bg(func, digit, top, ptn_id) \
|
||
func(CARDCOMBO_LEFT, digit, top, ptn_id, digit)
|
||
|
||
#define cardcombo_max_bg(func, digit) \
|
||
cardcombo_bg(func, digit, MAX_TOP, PTN_BG_MAX_CARDCOMBO)
|
||
|
||
inline void cardcombo_put(int top, int fx, const int &prev) {
|
||
fwnum_put(CARDCOMBO_LEFT, top, fx, CARDCOMBO_DIGITS, cardcombo_cur, prev);
|
||
}
|
||
|
||
extern "C" {
|
||
|
||
void hiscore_update_and_render(void)
|
||
{
|
||
// TODO: Should just be `static` once the variable can be declared here
|
||
#define prev score_prev
|
||
extern long prev;
|
||
long divisor = 1000000; // Must match SCORE_DIGITS!
|
||
unsigned long hiscore = resident->hiscore;
|
||
|
||
if(hiscore >= score) {
|
||
return;
|
||
}
|
||
for(int i = 0; i < SCORE_DIGITS; i++) {
|
||
if(digit_changed(score, prev, divisor)) {
|
||
graph_accesspage_func(1); score_max_bg(bg_put, i);
|
||
graph_accesspage_func(0); score_max_bg(bg_put, i);
|
||
}
|
||
divisor /= 10;
|
||
}
|
||
graph_accesspage_func(1); score_put(MAX_TOP, MAX_FX, prev);
|
||
graph_accesspage_func(0); score_put(MAX_TOP, MAX_FX, prev);
|
||
|
||
prev = score;
|
||
resident->hiscore = score;
|
||
#undef prev
|
||
}
|
||
|
||
void cardcombo_max_render(void)
|
||
{
|
||
// TODO: Should just be `static` once the variable can be declared here
|
||
#define prev cardcombo_max_prev
|
||
extern int prev;
|
||
int divisor = 10; // Must match CARDCOMBO_DIGITS!
|
||
|
||
for(int i = 0; i < CARDCOMBO_DIGITS; i++) {
|
||
if(digit_changed(cardcombo_cur, prev, divisor)) {
|
||
graph_accesspage_func(1); cardcombo_max_bg(bg_put, i);
|
||
graph_accesspage_func(0); cardcombo_max_bg(bg_put, i);
|
||
}
|
||
divisor /= 10;
|
||
}
|
||
graph_accesspage_func(1); cardcombo_put(MAX_TOP, MAX_FX, prev);
|
||
graph_accesspage_func(0); cardcombo_put(MAX_TOP, MAX_FX, prev);
|
||
|
||
prev = cardcombo_cur;
|
||
#undef prev
|
||
}
|
||
|
||
void hud_score_and_cardcombo_render(void)
|
||
{
|
||
// TODO: Should just be `static` once the variable can be declared here
|
||
#define score_prev score_cur_prev
|
||
#define cardcombo_prev cardcombo_cur_prev
|
||
extern long score_prev;
|
||
extern int cardcombo_prev;
|
||
|
||
int digit;
|
||
int page;
|
||
int cardcombo_divisor;
|
||
long score_divisor;
|
||
|
||
score_divisor = 1000000; // Must match SCORE_DIGITS!
|
||
cardcombo_divisor = 10; // Must match CARDCOMBO_DIGITS!
|
||
for(page = 1; page >= 0; page--) {
|
||
graph_accesspage_func(page);
|
||
score_divisor = 1000000; // Must match SCORE_DIGITS!
|
||
cardcombo_divisor = 10; // Must match CARDCOMBO_DIGITS!
|
||
|
||
for(digit = 0; digit < SCORE_DIGITS; digit++) {
|
||
if(digit_changed(score, score_prev, score_divisor)) {
|
||
score_bg(bg_put, digit, CUR_TOP, PTN_BG_CUR_SCORE);
|
||
}
|
||
score_divisor /= 10;
|
||
}
|
||
score_put(CUR_TOP, CUR_FX, score_prev);
|
||
|
||
for(digit = 0; digit < CARDCOMBO_DIGITS; digit++) {
|
||
if(digit_changed(cardcombo_cur, cardcombo_prev, cardcombo_divisor)) {
|
||
cardcombo_bg(bg_put, digit, CUR_TOP, PTN_BG_CUR_CARDCOMBO);
|
||
}
|
||
cardcombo_divisor /= 10;
|
||
}
|
||
cardcombo_put(CUR_TOP, CUR_FX, cardcombo_prev);
|
||
}
|
||
|
||
score_prev = score;
|
||
cardcombo_prev = cardcombo_cur;
|
||
hiscore_update_and_render();
|
||
if(hud_cardcombo_max < cardcombo_cur) {
|
||
hud_cardcombo_max = cardcombo_cur;
|
||
cardcombo_max_render();
|
||
}
|
||
}
|
||
|
||
#define cardcombo_bg_loop(func, digit, top, ptn_id) \
|
||
for(digit = 0; digit < CARDCOMBO_DIGITS; digit++) { \
|
||
cardcombo_bg(func, digit, top, ptn_id); \
|
||
} \
|
||
|
||
inline void cardcombo_put_initial(int top, int fx) {
|
||
graph_putfwnum_fx(CARDCOMBO_LEFT, top, fx, CARDCOMBO_DIGITS, 0, 99, true);
|
||
}
|
||
|
||
#define score_snap_bg_and_put(digit, top, ptn_id, fx, score) \
|
||
graph_accesspage_func(1); \
|
||
for(digit = 0; digit < SCORE_DIGITS; digit++) { \
|
||
score_bg(bg_snap, digit, top, ptn_id); \
|
||
} \
|
||
graph_accesspage_func(0); \
|
||
graph_putfwnum_fx(SCORE_LEFT, top, fx, SCORE_DIGITS, score, 0, true);
|
||
|
||
// Setting [first_run] to false will only reset the card combo display.
|
||
void score_and_cardcombo_put_initial(bool16 first_run)
|
||
{
|
||
int digit;
|
||
|
||
// Spot the difference… :(
|
||
if(first_run) {
|
||
score_snap_bg_and_put(digit, CUR_TOP, PTN_BG_CUR_SCORE, CUR_FX, score);
|
||
graph_accesspage_func(1);
|
||
cardcombo_bg_loop(bg_snap, digit, CUR_TOP, PTN_BG_CUR_CARDCOMBO);
|
||
} else {
|
||
cardcombo_bg_loop(bg_put, digit, CUR_TOP, PTN_BG_CUR_CARDCOMBO);
|
||
}
|
||
graph_accesspage_func(0);
|
||
cardcombo_put_initial(CUR_TOP, CUR_FX);
|
||
|
||
if(first_run) {
|
||
score_snap_bg_and_put(
|
||
digit, MAX_TOP, PTN_BG_MAX_SCORE, MAX_FX, resident->hiscore
|
||
);
|
||
graph_accesspage_func(1);
|
||
cardcombo_bg_loop(bg_snap, digit, MAX_TOP, PTN_BG_MAX_CARDCOMBO);
|
||
graph_accesspage_func(0);
|
||
} else {
|
||
cardcombo_bg_loop(bg_put, digit, MAX_TOP, PTN_BG_MAX_CARDCOMBO);
|
||
}
|
||
cardcombo_put_initial(MAX_TOP, MAX_FX);
|
||
|
||
graph_copy_hud_row_0_to_1_8(SCORE_LEFT, MAX_TOP, SCORE_AND_CARDCOMBO_W);
|
||
graph_copy_hud_row_0_to_1_8(SCORE_LEFT, CUR_TOP, SCORE_AND_CARDCOMBO_W);
|
||
hud_cardcombo_max = 0;
|
||
}
|
||
|
||
/// Background
|
||
/// ----------
|
||
void hud_bg_put(void)
|
||
{
|
||
register uint16_t vram_offset;
|
||
uint16_t src_offset = 0;
|
||
uint8_t byte;
|
||
uint8_t runs;
|
||
uint8_t rle_run_byte = hud_bg_rle_run_byte;
|
||
|
||
disable();
|
||
grcg_setcolor_rmw(10);
|
||
for(vram_offset = 0; vram_offset < (66 * ROW_SIZE); vram_offset++) {
|
||
// Effectively the same algorithm as used for .GRX files, except for
|
||
// • the customizable RLE run byte, and
|
||
// • implicitly defining a run of 0x00 dots as a skip. (Which really
|
||
// is just an optimization here, since blitting a 0x00 byte with the
|
||
// GRCG won't blit anything after all.)
|
||
byte = hud_bg[src_offset++];
|
||
if(byte == rle_run_byte) {
|
||
runs = hud_bg[src_offset++];
|
||
if(runs) {
|
||
byte = hud_bg[src_offset++];
|
||
while(runs--) {
|
||
if(byte != 0) {
|
||
VRAM_PUT(B, vram_offset, byte, 8);
|
||
}
|
||
vram_offset++;
|
||
}
|
||
}
|
||
}
|
||
// Yes, in case we just did a putting run, we are in fact putting
|
||
// one more byte!
|
||
if(byte != 0) {
|
||
VRAM_PUT(B, vram_offset, byte, 8);
|
||
}
|
||
}
|
||
grcg_off();
|
||
enable();
|
||
}
|
||
|
||
int hud_bg_load(const char *fn)
|
||
{
|
||
int size;
|
||
grf_header_t header;
|
||
|
||
file_ropen(fn);
|
||
file_read(&header, sizeof(header));
|
||
|
||
hud_bg_rle_run_byte = header.rle_run_byte;
|
||
size = header.rle_size.B;
|
||
hud_bg_size = size;
|
||
hud_bg = new uint8_t[size];
|
||
|
||
file_read(hud_bg, size);
|
||
file_close();
|
||
return 0;
|
||
}
|
||
/// ----------
|
||
|
||
void graph_copy_hud_row_0_to_1_8(int left, int top, int w)
|
||
{
|
||
uint16_t vram_offset;
|
||
dots16_t dots;
|
||
int y;
|
||
uint16_t vram_offset_row = vram_offset_divmul(left, top);
|
||
int x;
|
||
|
||
vram_offset = vram_offset_row;
|
||
for(y = 0; y < ROW_H; y++) {
|
||
vram_offset = vram_offset_row;
|
||
for(x = 0; x < (w / 16); x++) {
|
||
#define copy_plane(plane) \
|
||
OUTW(0xA6, 0); VRAM_SNAP(dots, plane, vram_offset, 16); \
|
||
OUTW(0xA6, 1); VRAM_PUT(plane, vram_offset, dots, 16);
|
||
copy_plane(B);
|
||
copy_plane(R);
|
||
copy_plane(G);
|
||
copy_plane(E);
|
||
vram_offset += sizeof(dots);
|
||
#undef copy_plane
|
||
}
|
||
vram_offset_row += ROW_SIZE;
|
||
}
|
||
graph_accesspage_func(0);
|
||
}
|
||
|
||
/// Lives and bombs
|
||
/// ---------------
|
||
inline int lives_col(int i) {
|
||
return (i % LIVES_PER_ROW);
|
||
}
|
||
|
||
inline int lives_top(int i) {
|
||
return (LIVES_TOP + ((i / LIVES_PER_ROW) * ROW_H));
|
||
}
|
||
|
||
#define lives_bg(func, left, i) \
|
||
ptn_id_and_quarter_from_i( \
|
||
func, left, lives_col(i), lives_top(i), PTN_BG_LIVES, i \
|
||
)
|
||
|
||
#define lives_put(left, i) \
|
||
sprite_put(left, lives_col(i), lives_top(i), PTN_HUD, PTN_LIFE_QUARTER)
|
||
|
||
#define bombs_bg(func, left, i) \
|
||
ptn_id_and_quarter_from_i(func, left, i, BOMBS_TOP, PTN_BG_BOMBS, i)
|
||
|
||
#define bombs_put(left, i) \
|
||
sprite_put(left, i, BOMBS_TOP, PTN_HUD, PTN_BOMB_QUARTER)
|
||
|
||
#define put_initial(left, top, func_bg, func_sprite, var) \
|
||
for(int i = 0; i < var; i++) { \
|
||
func_bg(bg_snap, left, i); \
|
||
func_sprite(left, i); \
|
||
} \
|
||
/* Yet we don't accomodate cheaters here, and only copy a single row? */ \
|
||
graph_copy_hud_row_0_to_1_8(left, top, var * COL_W);
|
||
|
||
#define put_change(left, top, func_bg, func_sprite, var_prev, var_new) \
|
||
if(var_prev > var_new) { \
|
||
for(int i = var_new; i < var_prev; i++) { \
|
||
graph_accesspage_func(1); func_bg(bg_put, left, i); \
|
||
graph_accesspage_func(0); func_bg(bg_put, left, i); \
|
||
} \
|
||
} else if(var_prev < var_new) { \
|
||
for(int i = var_prev; i < var_new; i++) { \
|
||
func_bg(bg_snap, left, i); \
|
||
graph_accesspage_func(0); \
|
||
func_sprite(left, i); \
|
||
} \
|
||
graph_copy_hud_row_0_to_1_8(left, top, var_new * COL_W); \
|
||
} \
|
||
|
||
void lives_put_initial(void)
|
||
{
|
||
put_initial(LIVES_LEFT, LIVES_TOP, lives_bg, lives_put, lives);
|
||
}
|
||
|
||
void hud_lives_put(int prev)
|
||
{
|
||
put_change(LIVES_LEFT, LIVES_TOP, lives_bg, lives_put, prev, lives);
|
||
}
|
||
|
||
void bombs_put_initial(void)
|
||
{
|
||
put_initial(BOMBS_LEFT, BOMBS_TOP, bombs_bg, bombs_put, bombs);
|
||
}
|
||
|
||
void hud_bombs_put(int prev)
|
||
{
|
||
put_change(BOMBS_LEFT, BOMBS_TOP, bombs_bg, bombs_put, prev, bombs);
|
||
}
|
||
|
||
#undef put_initial
|
||
#undef put_change
|
||
/// ---------------
|
||
|
||
// Assumes page 0.
|
||
void stage_put_initial(void)
|
||
{
|
||
char str[STAGE_DIGITS + 1];
|
||
|
||
bg_snap(STAGE_LEFT, 0, STAGE_TOP, PTN_BG_STAGE, 0);
|
||
str_right_aligned_from_uint16(str, stage_num, STAGE_DIGITS);
|
||
graph_putsa_fx(STAGE_LEFT, STAGE_TOP, MAX_FX, str);
|
||
graph_copy_hud_row_0_to_1_8(
|
||
STAGE_LEFT, STAGE_TOP, STAGE_DIGITS * GLYPH_HALF_W
|
||
);
|
||
}
|