blues/p2/level.c

3716 lines
104 KiB
C

/* level main loop */
#include "game.h"
#include "resource.h"
#include "sys.h"
#include "util.h"
static const bool _score_8_digits = true; /* maximum score 99.999.999 */
static const bool _redraw_tilemap = true;
static const bool _redraw_panel = true;
static const uint16_t _undefined = 0x55AA;
static void level_completed_bonuses_animation();
static void level_player_death_animation();
static const uint8_t next_level_tbl[] = { 0xFF, 0x0C, 0x0B, 0x0A, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x0E };
static void set_level_palette() {
g_sys.set_screen_palette(palettes_tbl[g_vars.level_num], 0, 16, 6);
}
static int load_level_data_get_tilemap_size(int num, const uint8_t *lev, const uint8_t *uni) {
static const uint8_t level_height_tbl[] = { 0x31, 0x68, 0x31, 0x2D, 0x80, 0x80, 0x80, 0x56, 0x6E, 0x0C, 0x18, 0x33, 0x33, 0x26, 0xAD, 0x54 };
g_vars.tilemap.h = level_height_tbl[num];
const int tilemap_size = level_height_tbl[num] << 8;
g_vars.tilemap.size = tilemap_size;
int offset = 0;
for (int i = 0; i < 512; i += 2) {
const uint16_t num = READ_LE_UINT16(lev + tilemap_size + i);
if (num == 0xFFFF) {
continue;
}
if (num < 0x100) {
offset += 128;
} else {
/* 'UNION' tile */
}
}
return tilemap_size + 512 + offset;
}
static bool level_check_tilemap_offset(uint16_t offset) {
const uint8_t x = offset & 255;
const uint8_t y = offset >> 8;
if (y >= g_vars.tilemap.h) {
print_debug(DBG_GAME, "invalid tilemap offset %d (%d,%d)", (int16_t)offset, x, y);
return false;
}
return true;
}
uint8_t level_get_tile(uint16_t offset) {
if (level_check_tilemap_offset(offset)) {
return g_res.leveldat[offset];
}
return 0;
}
static void level_set_tile(uint16_t offset, uint8_t tile_num) {
if (level_check_tilemap_offset(offset)) {
g_res.leveldat[offset] = tile_num;
}
}
static void load_level_data_init_animated_tiles() {
for (int i = 0; i < 256; ++i) {
if ((g_res.level.tile_attributes2[i] & 0x80) == 0) { /* not animated */
g_vars.tile_tbl1[i] = i;
g_vars.tile_tbl2[i] = i;
g_vars.tile_tbl3[i] = i;
g_vars.animated_tile_flag_tbl[i] = 0;
} else {
int j = i;
g_vars.tile_tbl1[i] = j;
g_vars.tile_tbl2[i + 2] = j;
g_vars.tile_tbl3[i + 1] = j;
++j;
g_vars.tile_tbl1[i + 1] = j;
g_vars.tile_tbl2[i] = j;
g_vars.tile_tbl3[i + 2] = j;
++j;
g_vars.tile_tbl1[i + 2] = j;
g_vars.tile_tbl2[i + 1] = j;
g_vars.tile_tbl3[i] = j;
g_vars.animated_tile_flag_tbl[i] = 1;
g_vars.animated_tile_flag_tbl[i + 1] = 1;
g_vars.animated_tile_flag_tbl[i + 2] = 1;
i += 2;
}
}
g_vars.level_animated_tiles_current_tbl = g_vars.tile_tbl1;
}
static void load_level_data_init_transparent_tiles() {
const int tiles_offset = g_vars.tilemap.size + 512;
const int tiles_count = (g_res.levellen - tiles_offset) / 128;
int count = 1;
for (int i = 0; i < tiles_count; ++i) {
const uint8_t num = i;
const uint8_t *tiledat = g_res.leveldat + tiles_offset + num * 128;
uint8_t mask_opaque = 0xFF;
uint8_t mask_transparent = 0;
for (int j = 0; j < 128; ++j) {
mask_opaque &= tiledat[j];
mask_transparent |= tiledat[j];
}
if (mask_transparent == 0) {
} else if (mask_opaque == 0xFF) {
g_vars.tilemap.redraw_flag2 = 1;
} else {
++count;
g_vars.tilemap.redraw_flag2 = 1;
}
}
}
static void load_level_data_fix_items_spr_num() {
const int16_t offset = g_res.level.items_spr_num_offset;
for (int i = 0; i < MAX_LEVEL_ITEMS; ++i) {
const uint16_t num = g_res.level.items_tbl[i].spr_num;
if (num != 0xFFFF) {
g_res.level.items_tbl[i].spr_num = num - offset + 53;
}
}
for (int i = 0; i < MAX_LEVEL_PLATFORMS; ++i) {
const uint16_t num = g_res.level.platforms_tbl[i].spr_num;
if (num != 0xFFFF) {
g_res.level.platforms_tbl[i].spr_num = num - offset + 53;
}
}
}
static void load_level_data_fix_monsters_spr_num() {
if (g_res.level.items_spr_num_offset != 0xFFFF) {
for (int i = 0; i < g_res.level.monsters_count; ++i) {
uint16_t num = g_res.level.monsters_tbl[i].spr_num;
if (num != 0xFFFF) {
if (num >= g_res.level.monsters_spr_num_offset) {
num -= g_res.level.monsters_spr_num_offset;
num += g_res.spr_monsters_offset;
g_res.level.monsters_tbl[i].spr_num = num;
} else if (num >= g_res.level.items_spr_num_offset) {
num -= g_res.level.items_spr_num_offset;
num += 53;
g_res.level.monsters_tbl[i].spr_num = num;
}
}
}
}
g_res.level.items_spr_num_offset = 53;
g_res.level.monsters_spr_num_offset = g_res.spr_monsters_offset;
}
static void load_level_data_init_secret_bonus_tiles() {
int count = 0;
for (int i = 0; i < MAX_LEVEL_BONUSES; ++i) {
struct level_bonus_t *bonus = &g_res.level.bonuses_tbl[i];
const uint16_t offset = bonus->pos;
if (offset != 0xFFFF) {
const uint8_t tile_num = level_get_tile(offset);
level_set_tile(offset, bonus->tile_num0);
bonus->tile_num1 = tile_num;
++count;
}
}
g_vars.level_complete_secrets_count = count;
}
static int compare_level_item_x_pos(const void *item1, const void *item2) {
return ((const struct level_item_t *)item1)->x_pos < ((const struct level_item_t *)item2)->x_pos;
}
static void load_level_data_init_password_items() {
struct level_item_t *items_ptr_tbl[MAX_LEVEL_ITEMS];
int count = 0;
for (int i = 0; i < MAX_LEVEL_ITEMS; ++i) {
struct level_item_t *item = &g_res.level.items_tbl[i];
const uint16_t num = item->spr_num - 283;
if (num > 15) { /* not 0-9A-F */
continue;
}
items_ptr_tbl[count++] = item;
}
if (count == 0 || (count & 3) != 0) {
return;
}
qsort(items_ptr_tbl, count, sizeof(struct level_item_t *), compare_level_item_x_pos);
/* level password */
const uint16_t r = random_get_number3(g_vars.level_num);
for (int j = 0; j < count; j += 4) {
for (int i = 0; i < 4; ++i) {
struct level_item_t *item = items_ptr_tbl[j + i];
const int num = r >> ((3 - i) * 4);
item->spr_num = 283 + (num & 15);
}
}
}
static void load_level_data_init_columns() {
uint8_t *p = g_vars.columns_tiles_buf;
for (int i = 0; i < MAX_LEVEL_COLUMNS; ++i) {
struct level_column_t *column = &g_res.level.columns_tbl[i];
if (column->tilemap_pos == 0xFFFF) {
continue;
}
uint16_t offset = column->tilemap_pos - (column->y_target << 8);
const int h = column->y_target + column->h;
const int w = column->w;
WRITE_LE_UINT16(p, offset); p += 2;
*p++ = h;
*p++ = w;
for (int y = 0; y < h; ++y) {
memcpy(p, g_res.leveldat + offset, w); p += w;
offset += 0x100;
}
column->tiles_offset_buf = p - g_vars.columns_tiles_buf - w;
}
WRITE_LE_UINT16(p, 0xFFFF); p += 2;
assert(p - g_vars.columns_tiles_buf <= sizeof(g_vars.columns_tiles_buf));
}
static void level_reset_columns_tiles() {
const uint8_t *p = g_vars.columns_tiles_buf;
while (1) {
uint16_t offset = READ_LE_UINT16(p); p += 2;
if (offset == 0xFFFF) {
break;
}
const int h = *p++;
const int w = *p++;
for (int y = 0; y < h; ++y) {
memcpy(g_res.leveldat + offset, p, w); p += w;
offset += 0x100;
}
}
}
static void load_level_data(int num) {
static const uint8_t num_tbl[] = { 0, 0, 0, 1, 1, 1, 2, 3, 3, 0, 4, 4, 4, 5, 0, 2 };
char name[16];
snprintf(name, sizeof(name), "BACK%d.SQZ", num_tbl[num]);
uint8_t *data = load_file(name);
if (data) {
video_copy_img(data);
free(data);
}
memset(&g_vars.objects_tbl[0], 0, sizeof(struct object_t) * OBJECTS_COUNT);
const int level = (num < 9) ? ('1' + num) : ('A' + num - 9);
snprintf(name, sizeof(name), "LEVEL%c.SQZ", level);
free(g_res.leveldat);
g_res.leveldat = load_file(name);
g_res.levellen = g_uncompressed_size;
const int offset = load_level_data_get_tilemap_size(num, g_res.leveldat, data);
print_debug(DBG_GAME, "tilemap offset %d", offset);
load_leveldat(g_res.leveldat + offset, 0);
video_convert_tiles(g_res.leveldat + g_vars.tilemap.size + 512, offset - (g_vars.tilemap.size + 512));
print_debug(DBG_GAME, "start_pos %d,%d", g_res.level.start_x_pos, g_res.level.start_y_pos);
load_level_data_init_animated_tiles();
load_level_data_init_transparent_tiles();
g_vars.snow.pattern = (g_vars.level_num != 15) ? snow_pattern1_data : snow_pattern2_data;
g_vars.snow.counter = 0;
g_vars.tilemap_start_x_pos = g_res.level.start_x_pos;
g_vars.tilemap_start_y_pos = g_res.level.start_y_pos;
load_level_data_fix_items_spr_num();
load_level_data_fix_monsters_spr_num();
load_level_data_init_secret_bonus_tiles();
load_level_data_init_password_items();
g_res.restart = g_res.level;
load_level_data_init_columns();
int count = 0;
for (int i = 0; i < MAX_LEVEL_ITEMS; ++i) {
struct level_item_t *item = &g_res.level.items_tbl[i];
const uint16_t spr_num = item->spr_num;
if (spr_num >= 110 && spr_num <= 219) {
if (spr_num >= 128 || spr_num <= 117) {
++count;
}
}
}
g_vars.level_complete_bonuses_count = count;
if (g_vars.level_num < 10 && next_level_tbl[g_vars.level_num] != 0xFF) {
g_vars.level_complete_bonuses_count *= 2;
g_vars.level_complete_secrets_count *= 2;
}
}
static void level_draw_tile(int tile_num, int x, int y) {
const int num = READ_LE_UINT16(g_res.leveldat + g_vars.tilemap.size + tile_num * 2);
const uint8_t *tiledat;
if (num < 0x100) {
tiledat = g_res.leveldat + g_vars.tilemap.size + 512 + num * 128;
} else {
tiledat = g_res.uniondat + (num - 256) * 128;
}
video_draw_tile(tiledat, x * 16 - g_vars.tilemap.scroll_dx, y * 16 - g_vars.tilemap.scroll_dy);
}
static void level_update_tilemap() {
const uint8_t mask = (g_vars.snow.value >= 20) ? 1 : 3;
++g_vars.level_animated_tiles_counter;
if ((g_vars.level_animated_tiles_counter & mask) == 0) {
if (g_vars.level_animated_tiles_current_tbl == g_vars.tile_tbl1) {
g_vars.level_animated_tiles_current_tbl = g_vars.tile_tbl2;
} else if (g_vars.level_animated_tiles_current_tbl == g_vars.tile_tbl2) {
g_vars.level_animated_tiles_current_tbl = g_vars.tile_tbl3;
} else if (g_vars.level_animated_tiles_current_tbl == g_vars.tile_tbl3) {
g_vars.level_animated_tiles_current_tbl = g_vars.tile_tbl1;
}
} else {
if (!_redraw_tilemap) {
return;
}
}
if (GAME_SCREEN_W * GAME_SCREEN_H == 64000) {
memcpy(g_res.vga, g_res.background, 320 * 200);
} else {
memset(g_res.vga, 0, GAME_SCREEN_W * GAME_SCREEN_H);
for (int y = 0; y < MIN(200, GAME_SCREEN_H); ++y) {
for (int x = 0; x < GAME_SCREEN_W; x += 320) {
memcpy(g_res.vga + y * GAME_SCREEN_W + x, g_res.background + y * 320, MIN(320, GAME_SCREEN_W - x));
}
}
}
g_vars.tile_attr2_flags = 0;
uint16_t offset = (g_vars.tilemap.y << 8) | g_vars.tilemap.x;
for (int y = 0; y < (TILEMAP_SCREEN_H / 16) + 1; ++y) {
for (int x = 0; x < (TILEMAP_SCREEN_W / 16) + 1; ++x) {
const uint8_t tile_num = level_get_tile(offset + x);
g_vars.tile_attr2_flags |= g_res.level.tile_attributes2[tile_num];
if (_redraw_tilemap || g_vars.animated_tile_flag_tbl[tile_num] != 0) {
const uint8_t num = g_vars.level_animated_tiles_current_tbl[tile_num];
level_draw_tile(num, x, y);
}
}
offset += 256;
}
}
static void level_draw_tilemap() {
if (_redraw_tilemap) {
return;
}
if (g_vars.tilemap.redraw_flag1 == 0) {
const bool changed = (g_vars.tilemap.x != g_vars.tilemap.prev_x) || (g_vars.tilemap.y != g_vars.tilemap.prev_y);
if (!changed) {
return;
}
g_vars.tilemap.prev_x = g_vars.tilemap.x;
g_vars.tilemap.prev_y = g_vars.tilemap.y;
if (g_vars.tilemap.redraw_flag2 == 0) {
return;
}
}
g_vars.tilemap.redraw_flag1 = 0;
g_vars.tilemap.redraw_flag2 = 0;
g_vars.tile_attr2_flags = 0;
uint16_t offset = (g_vars.tilemap.y << 8) | g_vars.tilemap.x;
for (int y = 0; y < (TILEMAP_SCREEN_H / 16) + 1; ++y) {
for (int x = 0; x < TILEMAP_SCREEN_W / 16; ++x) {
const uint8_t tile_num = level_get_tile(offset + x);
g_vars.tile_attr2_flags |= g_res.level.tile_attributes2[tile_num];
level_draw_tile(tile_num, x, y);
}
offset += 256;
}
}
static bool level_adjust_hscroll_left() {
if (g_vars.tilemap.x == 0) {
return true;
}
--g_vars.tilemap.x;
return false;
}
static uint16_t tilemap_end_xpos() {
int end_x = (g_vars.objects_tbl[1].x_pos >> 4) - (TILEMAP_SCREEN_W / 16);
if (g_res.level.tilemap_w < end_x) {
end_x = 256 - (TILEMAP_SCREEN_W / 16);
} else {
end_x = g_res.level.tilemap_w;
}
return end_x;
}
static bool level_adjust_hscroll_right() {
if (g_vars.tilemap.x >= tilemap_end_xpos()) {
return true;
}
++g_vars.tilemap.x;
return false;
}
static void level_adjust_x_scroll() {
if (!g_options.dos_scrolling && g_vars.tilemap_noscroll_flag == 0) {
const int x1 = TILEMAP_SCROLL_W * 2;
const int x2 = TILEMAP_SCREEN_W - TILEMAP_SCROLL_W * 2;
int tilemap_xpos = (g_vars.tilemap.x << 4) + g_vars.tilemap.scroll_dx;
const int player_xpos = g_vars.objects_tbl[1].x_pos - tilemap_xpos;
if (player_xpos > x2) {
tilemap_xpos += (player_xpos - x2);
const int tilemap_xend = tilemap_end_xpos() << 4;
if (tilemap_xpos > tilemap_xend) {
tilemap_xpos = tilemap_xend;
}
} else if (player_xpos < x1) {
tilemap_xpos += (player_xpos - x1);
if (tilemap_xpos < 0) {
tilemap_xpos = 0;
}
}
g_vars.tilemap.x = (tilemap_xpos >> 4);
g_vars.tilemap.scroll_dx = (tilemap_xpos & 15);
g_vars.tilemap.scroll_dx &= ~1;
g_vars.level_xscroll_center_flag = 0;
return;
}
const int x_pos = (g_vars.objects_tbl[1].x_pos >> 4) - g_vars.tilemap.x;
if (x_pos >= (TILEMAP_SCREEN_W / 16) || g_vars.level_force_x_scroll_flag != 0 || g_vars.objects_tbl[1].x_velocity != 0) {
if (g_vars.level_xscroll_center_flag != 0) {
if (g_vars.level_xscroll_center_flag != 1) {
if (x_pos < 15) {
if (!level_adjust_hscroll_left()) {
return;
}
}
} else {
if (x_pos > 5) {
if (!level_adjust_hscroll_right()) {
return;
}
}
}
g_vars.level_xscroll_center_flag = 0;
} else {
if (g_vars.objects_tbl[1].x_velocity != 0) {
if (g_vars.objects_tbl[1].x_velocity < 0) {
if (x_pos <= 4) {
g_vars.level_xscroll_center_flag = 2;
}
} else {
if (x_pos >= 16) {
g_vars.level_xscroll_center_flag = 1;
}
}
} else {
if (x_pos < 10) {
if (x_pos <= 4) {
g_vars.level_xscroll_center_flag = 2;
}
} else {
if (x_pos >= 16) {
g_vars.level_xscroll_center_flag = 1;
}
}
}
}
} else {
g_vars.level_xscroll_center_flag = 0;
}
}
static bool level_adjust_vscroll_down(int dl) {
const int end_y = g_vars.tilemap.h - (TILEMAP_SCREEN_H / 16);
if (g_vars.tilemap.y >= end_y) {
return false;
}
++g_vars.tilemap.redraw_flag1;
g_vars.tilemap.scroll_dy += dl;
if (g_vars.tilemap.scroll_dy < 16) {
return true;
}
g_vars.tilemap.scroll_dy -= 16;
++g_vars.tilemap.y;
if (g_vars.tilemap.y >= end_y) {
g_vars.tilemap.scroll_dy = 0;
}
return true;
}
static bool level_adjust_vscroll_up(int dl) {
if (g_vars.tilemap.y == 0) {
return false;
}
++g_vars.tilemap.redraw_flag1;
g_vars.tilemap.scroll_dy -= dl;
if (g_vars.tilemap.scroll_dy >= 0) {
return true;
}
g_vars.tilemap.scroll_dy += 16;
--g_vars.tilemap.y;
return true;
}
static void level_adjust_y_scroll() {
if (!g_vars.tilemap_adjust_player_pos_flag && (g_res.level.scrolling_mask & 4) != 0) {
level_adjust_vscroll_down(1);
return;
}
if (g_vars.objects_tbl[1].data.p.y_velocity == 0) {
g_vars.level_yscroll_center_flag = 0;
}
const int player_yorigin_diff = (g_vars.objects_tbl[1].y_pos >> 4) - g_vars.tilemap.y;
if (g_vars.objects_tbl[1].data.p.y_velocity != 0) {
if (player_yorigin_diff >= 9) {
g_vars.tilemap_yscroll_diff = 3;
++g_vars.level_yscroll_center_flag;
} else if (player_yorigin_diff <= 2) {
g_vars.tilemap_yscroll_diff = 8;
++g_vars.level_yscroll_center_flag;
}
} else {
if ((g_res.level.scrolling_mask & 1) == 0) {
if (player_yorigin_diff >= 10) {
g_vars.tilemap_yscroll_diff = 9;
++g_vars.level_yscroll_center_flag;
} else if (player_yorigin_diff <= 3) {
g_vars.tilemap_yscroll_diff = 8;
++g_vars.level_yscroll_center_flag;
}
} else {
if (player_yorigin_diff >= 8) {
g_vars.tilemap_yscroll_diff = 7;
++g_vars.level_yscroll_center_flag;
} else if (player_yorigin_diff <= 5) {
g_vars.tilemap_yscroll_diff = 6;
++g_vars.level_yscroll_center_flag;
}
}
}
if (g_vars.level_yscroll_center_flag == 0) {
return;
}
const int bottom = (g_res.level.scrolling_top + (TILEMAP_SCREEN_H / 16)) << 4;
if (g_vars.objects_tbl[1].y_pos > bottom || g_res.level.scrolling_top >= g_vars.tilemap.y - 1) {
if (g_vars.level_yscroll_center_flag == 0) {
return;
}
if (g_vars.tilemap_yscroll_diff == player_yorigin_diff) {
g_vars.level_yscroll_center_flag = 0;
return;
}
if (g_vars.tilemap_yscroll_diff < player_yorigin_diff) {
if (g_vars.objects_tbl[1].y_pos <= bottom && g_vars.tilemap.y > g_res.level.scrolling_top) {
g_vars.level_yscroll_center_flag = 0;
return;
}
int dl = 16;
if (!g_vars.tilemap_adjust_player_pos_flag) {
const int dy = g_vars.objects_tbl[1].y_pos - g_vars.tilemap.scroll_dy;
const int index = dy - ((g_vars.tilemap.y + g_vars.tilemap_yscroll_diff) << 4);
if (index >= 0 && index < 132) {
dl = vscroll_offsets_data[index];
} else {
print_warning("Invalid scroll down delta %d", index);
return;
}
}
if (!level_adjust_vscroll_down(dl)) {
g_vars.level_yscroll_center_flag = 0;
}
return;
}
}
int dl = 16;
if (!g_vars.tilemap_adjust_player_pos_flag) {
const int dy = g_vars.objects_tbl[1].y_pos - g_vars.tilemap.scroll_dy;
const int index = ((g_vars.tilemap.y + g_vars.tilemap_yscroll_diff) << 4) - dy;
if (index >= 0 && index < 132) {
dl = vscroll_offsets_data[index];
} else {
print_warning("Invalid scroll up delta %d", index);
return;
}
}
if (!level_adjust_vscroll_up(dl)) {
g_vars.level_yscroll_center_flag = 0;
}
}
static void level_update_scrolling() {
if (g_vars.tilemap_noscroll_flag != 0) {
return;
}
if ((g_res.level.scrolling_mask & 2) == 0) {
level_adjust_x_scroll();
}
level_adjust_y_scroll();
}
static void level_init_tilemap() {
video_transition_close();
g_vars.tilemap.x = 0;
g_vars.tilemap.y = 0;
g_vars.tilemap.scroll_dx = 0;
g_vars.tilemap.scroll_dy = 0;
g_vars.level_animated_tiles_current_tbl = g_vars.tile_tbl1;
do {
g_vars.tilemap_adjust_player_pos_flag = true;
level_update_scrolling();
g_vars.tilemap_adjust_player_pos_flag = false;
} while ((g_vars.level_yscroll_center_flag | g_vars.level_xscroll_center_flag) != 0);
print_debug(DBG_GAME, "init_tilemap x_pos %d y_pos %d scrolling 0x%x", g_vars.tilemap.x, g_vars.tilemap.y, g_res.level.scrolling_mask);
if ((g_res.level.scrolling_mask & 2) == 0) {
const int x = (g_vars.objects_tbl[1].x_pos >> 4) - g_vars.tilemap.x;
if (x >= 12) {
for (int i = 0; i < 10; ++i) {
level_adjust_hscroll_right();
}
}
}
g_vars.tilemap.redraw_flag2 = 1;
g_vars.tilemap.prev_x = _undefined;
g_vars.tilemap.prev_y = _undefined;
level_draw_tilemap();
video_transition_open();
}
void level_player_die() {
g_vars.restart_level_flag = 2;
if (g_vars.player_lifes != 0) {
if ((g_options.cheats & CHEATS_UNLIMITED_LIFES) == 0) {
--g_vars.player_lifes;
g_vars.player_energy = 0;
}
} else {
g_vars.player_death_flag = 1;
}
}
static void level_player_reset() {
if (g_vars.player_nojump_counter > 0) {
--g_vars.player_nojump_counter;
}
g_vars.player_anim2_counter = 0;
g_vars.player_tile_flags = 2;
g_vars.player_prev_y_pos = g_vars.objects_tbl[1].y_pos;
}
static void level_init_object_hit_from_player_pos() {
struct object_t *obj = g_vars.current_hit_object;
obj->x_pos = g_vars.objects_tbl[1].x_pos;
obj->y_pos = g_vars.objects_tbl[1].y_pos;
obj->spr_num = 53;
--obj;
if (obj < &g_vars.objects_tbl[6]) {
obj = &g_vars.objects_tbl[10];
}
g_vars.current_hit_object = obj;
}
static void level_init_object_hit_from_xy_pos(int16_t x_pos, int16_t y_pos) {
struct object_t *obj = g_vars.current_hit_object;
obj->x_pos = x_pos;
obj->y_pos = y_pos;
obj->spr_num = 53;
--obj;
if (obj < &g_vars.objects_tbl[6]) {
obj = &g_vars.objects_tbl[10];
}
g_vars.current_hit_object = obj;
}
static void level_update_tile_type_2() {
if (g_vars.level_num == 14) {
g_vars.player_death_flag = 0xFF;
return;
}
if (g_options.cheats & CHEATS_NO_HIT) {
return;
}
level_player_die();
g_vars.restart_level_flag = 2;
}
static int level_get_tile_player_offset(uint8_t attr) {
if ((attr & 0x30) == 0) {
return attr;
}
int x = (g_vars.objects_tbl[1].x_pos & 15) / 3;
if (attr & 0x10) {
x = (attr & 15) + x;
} else {
x = (attr & 15) - x;
}
return x;
}
static void level_update_tile_attr1_helper(uint16_t offset) {
g_vars.objects_tbl[1].x_friction = 0;
if (g_vars.objects_tbl[1].data.p.y_velocity < 0) {
g_vars.player_tile_flags |= 1;
return;
}
g_vars.player_gravity_flag = 0;
g_vars.objects_tbl[1].y_pos &= ~15;
uint8_t al = level_get_tile(offset);
al = g_res.level.tile_attributes3[al];
if (al != 0) {
int dy = level_get_tile_player_offset(al);
int bx = g_vars.objects_tbl[1].data.p.y_velocity >> 4;
if (bx > 0 && dy >= bx) {
dy = bx;
}
g_vars.objects_tbl[1].y_pos += dy;
} else {
al = level_get_tile(offset - 0x100);
al = g_res.level.tile_attributes3[al];
if (al != 0) {
int ax = level_get_tile_player_offset(al);
if (ax < 16) {
ax -= 16;
g_vars.objects_tbl[1].y_pos += ax;
}
}
}
if (g_vars.player_jumping_counter > 4) {
level_init_object_hit_from_player_pos();
const int dy = g_vars.objects_tbl[1].y_pos - g_vars.player_prev_y_pos;
if (dy >= 32 && g_vars.objects_tbl[1].data.p.y_velocity >= 80) {
g_vars.player_prev_y_pos = g_vars.objects_tbl[1].y_pos;
if (g_vars.player_jumping_counter >= 20 && g_vars.objects_tbl[1].data.p.y_velocity > 160) {
g_vars.shake_screen_counter = 8;
}
if (g_vars.player_jumping_counter > 10) {
if ((g_res.level.scrolling_mask & 1) == 0) {
g_vars.objects_tbl[1].data.p.y_velocity = -32;
}
g_vars.objects_tbl[1].spr_num = (g_vars.objects_tbl[1].spr_num & 0xE000) | 12;
g_vars.player_jumping_counter = 0;
return;
}
}
}
g_vars.objects_tbl[1].data.p.y_velocity = 0;
level_player_reset();
}
static void level_update_tile_attr1_type_1(uint16_t offset) {
level_update_tile_attr1_helper(offset);
}
static void level_update_tile_attr1_type_2(uint16_t offset) {
level_update_tile_attr1_helper(offset);
g_vars.objects_tbl[1].x_friction = 1;
}
static void level_update_tile_attr1_type_3(uint16_t offset) {
level_update_tile_attr1_helper(offset);
g_vars.objects_tbl[1].x_friction = 2;
}
static void level_update_tile_attr1_type_4(uint16_t offset) {
level_update_tile_attr1_helper(offset);
g_vars.objects_tbl[1].x_friction = 3;
}
static void level_update_tile_attr1_type_5(uint16_t offset) {
g_vars.objects_tbl[1].x_friction = 0;
if (g_vars.player_action_counter == 0) {
level_update_tile_attr1_helper(offset);
} else {
g_vars.player_tile_flags |= 1;
}
}
static void level_update_tile_attr1_type_0(uint16_t offset) {
if (g_vars.objects_tbl[1].data.p.y_velocity == 0) {
uint8_t al = level_get_tile(offset + 0x100);
al = g_res.level.tile_attributes3[al];
if (al != 0 && level_get_tile_player_offset(al) < 16) {
offset += 0x100;
g_vars.objects_tbl[1].y_pos += 16;
level_update_tile_attr1_type_1(offset);
return;
}
}
g_vars.player_tile_flags |= 1;
}
static void level_update_tile_attr2_type1() {
if (g_vars.objects_tbl[1].data.p.y_velocity != 0) {
g_vars.objects_tbl[1].data.p.y_velocity = 0;
g_vars.objects_tbl[1].y_pos &= ~15;
g_vars.objects_tbl[1].y_pos += 16;
return;
}
const uint8_t spr_num = g_vars.objects_tbl[1].spr_num;
if (spr_num == 10 || spr_num == 21) {
return;
}
static int16_t data[6];
const uint8_t bh = (data[1] >> 4) & 255;
const uint8_t bl = (data[0] >> 4) & 255;
uint16_t offset = (bh << 8) | bl;
uint8_t tile_num = level_get_tile(offset);
if (g_res.level.tile_attributes0[tile_num] & 1) {
int dx = 16;
tile_num = level_get_tile(offset - 1);
if ((g_res.level.tile_attributes0[tile_num] & 1) == 0) {
dx = -dx;
}
data[0] += dx;
}
}
static void level_update_player_jump();
static void level_update_tile0(uint16_t offset) {
if (g_vars.objects_tbl[1].y_pos <= -1) {
level_update_player_jump();
g_vars.player_tile_flags = 0xFF;
return;
}
const uint16_t offset_nextline = offset + 0x100;
int tile_num = level_get_tile(offset_nextline);
const uint8_t attr1 = g_res.level.tile_attributes1[tile_num];
if (g_vars.decor_tile0_offset != offset_nextline) {
/* update tiles below the player */
if (g_vars.decor_tile0_offset != _undefined) {
tile_num = level_get_tile(g_vars.decor_tile0_offset);
while (1) {
--tile_num;
if ((g_res.level.tile_attributes2[tile_num] & 0x20) == 0) {
g_vars.decor_tile0_offset = _undefined;
break;
}
level_set_tile(g_vars.decor_tile0_offset, tile_num);
}
}
tile_num = level_get_tile(offset_nextline);
if (g_res.level.tile_attributes2[tile_num] & 0x20) {
g_vars.decor_tile0_offset = offset_nextline;
++tile_num;
level_set_tile(g_vars.decor_tile0_offset, tile_num);
}
}
switch (attr1) {
case 0:
level_update_tile_attr1_type_0(offset_nextline);
break;
case 1:
level_update_tile_attr1_type_1(offset_nextline);
break;
case 2:
level_update_tile_attr1_type_2(offset_nextline);
break;
case 3:
level_update_tile_attr1_type_3(offset_nextline);
break;
case 4:
level_update_tile_attr1_type_4(offset_nextline);
break;
case 5:
level_update_tile_attr1_type_5(offset_nextline);
break;
case 6:
/* spikes */
level_update_tile_type_2();
break;
default:
print_warning("Unhandled level_update_tile0 attr1 %d", attr1);
break;
}
if (offset < 0x100 || g_vars.objects_tbl[1].data.p.y_velocity >= 0) {
return;
}
offset -= 0x100;
uint8_t ah = level_get_tile(offset);
uint8_t al = level_get_tile(offset + 0x100);
al = g_res.level.tile_attributes0[al];
SWAP(ah, al);
al = g_res.level.tile_attributes2[al] & 15;
switch (al) {
case 0:
break;
case 1:
level_update_tile_attr2_type1();
break;
case 2:
level_update_tile_type_2();
break;
default:
print_warning("Unhandled level_update_tile0 attr2 %d", al);
break;
}
if ((ah & 1) == 0 || g_vars.objects_tbl[1].y_pos <= 0) {
return;
}
int dx = (g_vars.objects_tbl[1].x_velocity > 0) ? -1 : 1;
offset += dx;
al = level_get_tile(offset + 0x100);
al = g_res.level.tile_attributes0[al];
if (al != 0) {
dx = -dx;
offset += 2 * dx;
al = level_get_tile(offset + 0x100);
al = g_res.level.tile_attributes0[al];
if (al != 0) {
return;
}
}
g_vars.objects_tbl[1].x_pos += 2 * dx;
}
static void level_update_tile_type_0(uint16_t offset) {
const int tile_num = level_get_tile(offset);
if ((g_res.level.tile_attributes2[tile_num] & 0x10) == 0) {
return;
}
for (int i = 0; i < 20; ++i) {
struct fly_t *p = &g_vars.fly_tbl[i];
if (p->x_pos != _undefined) {
continue;
}
p->x_pos = g_vars.objects_tbl[1].x_pos << 3;
p->y_pos = g_vars.objects_tbl[1].y_pos << 3;
p->x_delta = 0;
p->y_delta = 0;
p->unk7 = 0;
break;
}
}
static void level_update_tile_type_1(uint16_t offset) {
g_vars.objects_tbl[1].x_pos -= g_vars.objects_tbl[1].x_velocity >> 4;
g_vars.objects_tbl[1].x_velocity = 0;
}
static void level_update_tile1(uint16_t offset) {
const int tile_num = level_get_tile(offset);
const uint8_t type = g_res.level.tile_attributes0[tile_num];
switch (type) {
case 0:
level_update_tile_type_0(offset);
break;
case 1:
level_update_tile_type_1(offset);
break;
case 2:
level_update_tile_type_2(offset);
break;
default:
print_warning("Unhandled level_update_tile1 type %d", type);
break;
}
}
static void level_update_tile2(uint16_t offset) {
const int tile_num = level_get_tile(offset);
const uint8_t type = g_res.level.tile_attributes0[tile_num];
if (type == 2 || type == 4) {
switch (type) {
case 2:
level_update_tile_type_2();
break;
default:
print_warning("Unhandled level_update_tile2 type %d", type);
break;
}
}
}
static void level_reset_objects() {
memset(&g_vars.objects_tbl[1], 0, sizeof(struct object_t) * (OBJECTS_COUNT - 1));
for (int i = 0; i < OBJECTS_COUNT; ++i) {
struct object_t *obj = &g_vars.objects_tbl[i];
obj->spr_num = 0xFFFF;
obj->hit_counter = 0;
}
g_vars.objects_tbl[1].x_pos = (g_options.start_xpos16 < 0) ? g_res.level.start_x_pos : (g_options.start_xpos16 << 4);
g_vars.objects_tbl[1].y_pos = (g_options.start_ypos16 < 0) ? g_res.level.start_y_pos : (g_options.start_ypos16 << 4);
}
static void level_reset() {
g_vars.tilemap_noscroll_flag = 0;
g_vars.player_nojump_counter = 0;
g_vars.player_action_counter = 0;
g_vars.restart_level_flag = 0;
g_vars.player_death_flag = 0;
g_vars.level_completed_flag = 0;
g_vars.light.palette_flag1 = 0;
g_vars.light.palette_flag2 = 0;
g_vars.objects_tbl[1].data.p.special_anim_num = 0;
g_vars.tilemap.prev_x = _undefined;
g_vars.current_hit_object = &g_vars.objects_tbl[6];
level_reset_objects();
set_level_palette();
for (int i = 0; i < 256; ++i) {
/* const uint8_t dh = */ random_get_number();
const uint8_t al = random_get_number();
/* this matches disassembly but is likely a typo and should rather be '(dh << 8) | al' */
g_vars.snow.random_tbl[i] = (al << 8) | al;
}
for (int i = 0; i < 20; ++i) {
g_vars.fly_tbl[i].x_pos = _undefined;
}
level_reset_columns_tiles();
for (int i = 0; i < 20; ++i) {
g_vars.orb_tbl[i].x_pos = 0xFFFF;
}
memset(g_vars.boss_level5.leaf_tbl, 0xFF, sizeof(g_vars.boss_level5.leaf_tbl));
g_vars.player_energy = 3;
memset(&g_vars.boss_level9, 0, sizeof(g_vars.boss_level9));
g_vars.decor_tile0_offset = _undefined;
g_vars.tilemap_yscroll_diff = 0;
}
static uint16_t level_get_player_tile_pos() {
const int y = (g_vars.objects_tbl[1].y_pos) >> 4;
const int x = (g_vars.objects_tbl[1].x_pos) >> 4;
return (y << 8) | x;
}
static struct object_t *level_add_object75_score(struct object_t *ref_obj, int num) {
const int score_index = num - 74;
if (score_index >= 0 && score_index <= 16) {
g_vars.score += score_tbl[score_index];
}
for (int i = 0; i < 16; ++i) {
struct object_t *obj = &g_vars.objects_tbl[75 + i];
if (obj->spr_num == 0xFFFF) {
obj->spr_num = num;
obj->x_pos = ref_obj->x_pos;
obj->y_pos = ref_obj->y_pos;
obj->data.t.counter = 44;
if (ref_obj >= &g_vars.objects_tbl[23]) {
struct level_item_t *item = ref_obj->data.t.ref;
if (item) {
assert(item >= &g_res.level.items_tbl[0] && item < &g_res.level.items_tbl[MAX_LEVEL_ITEMS]);
item->spr_num = 0xFFFF;
}
}
return obj;
}
}
return 0;
}
static void level_update_object_anim(const uint8_t *anim) {
int16_t num = READ_LE_UINT16(anim);
if (num < 0) {
anim += num;
num = READ_LE_UINT16(anim);
}
g_vars.player_current_anim_type = num >> 8;
g_vars.objects_tbl[1].spr_num = (num & 0x1FFF) | ((g_vars.objects_tbl[1].data.p.hdir < 0) ? 0x8000 : 0);
g_vars.objects_tbl[1].data.p.anim = anim + 2;
}
static void level_update_objects_hit_animation() {
struct object_t *obj = g_vars.current_hit_object;
for (int i = 0; i < 5; ++i) {
const int num = (obj->spr_num & 0x1FFF) + 1;
--obj->y_pos;
if (num < 58) {
obj->spr_num = num;
} else {
obj->spr_num = 0xFFFF;
}
--obj;
if (obj < &g_vars.objects_tbl[6]) {
obj = &g_vars.objects_tbl[10];
}
}
}
void level_add_object23_bonus(int x_vel, int y_vel, int count) {
int counter = 0;
for (int i = 0; i < 32; ++i) {
struct object_t *obj = &g_vars.objects_tbl[23 + i];
if (obj->spr_num == 0xFFFF) {
obj->spr_num = g_vars.current_bonus.spr_num;
obj->hit_counter = 0;
obj->data.t.counter = 198;
obj->x_pos = g_vars.current_bonus.x_pos;
obj->y_pos = g_vars.current_bonus.y_pos;
obj->x_velocity = x_vel;
obj->data.t.y_velocity = y_vel;
obj->data.t.ref = 0;
x_vel = -x_vel;
++counter;
if ((counter & 1) == 0) {
if (counter > 12) {
x_vel = 0;
}
x_vel -= 16;
y_vel -= 16;
}
--count;
if (count == 0) {
return;
}
}
}
}
bool level_objects_collide(const struct object_t *si, const struct object_t *di) {
const int dx = abs(si->x_pos - di->x_pos);
if (dx >= 64) {
return false;
}
const int dy = abs(si->y_pos - di->y_pos);
if (dy >= 70) {
return false;
}
int num = si->spr_num;
int a = si->y_pos;
int d = di->y_pos;
if (a < d) {
num = di->spr_num;
SWAP(a, d);
SWAP(si, di);
}
num &= 0x1FFF;
int b = spr_size_tbl[num * 2 + 1];
a -= b;
if (a >= d) {
return false;
}
if (g_vars.player_using_club_flag == 0) {
d -= a;
if (g_vars.objects_tbl[1].data.p.y_velocity >= 128 || (d <= (b >> 1) && si != &g_vars.objects_tbl[1])) {
++g_vars.player_jump_monster_flag;
g_vars.monster.collide_y_dist = d;
}
}
d = si->x_pos - spr_offs_tbl[(si->spr_num & 0x1FFF) * 2];
a = di->x_pos - spr_offs_tbl[(di->spr_num & 0x1FFF) * 2];
b = spr_size_tbl[(di->spr_num & 0x1FFF) * 2];
if (a >= d) {
SWAP(a, d);
b = spr_size_tbl[(si->spr_num & 0x1FFF) * 2];
}
if (g_vars.player_using_club_flag == 0) {
b >>= 1;
}
return (a + b > d);
}
static void level_monster_update_anim(struct object_t *obj) {
const uint8_t *p = obj->data.m.anim;
do {
p += 2;
} while (READ_LE_UINT16(p) != 0x7D00);
obj->data.m.anim = p + 2;
}
static void level_monster_die(struct object_t *obj, struct level_monster_t *m, struct object_t *obj_player) {
const int num = m->score + 74;
static const uint8_t data[] = { 1, 2, 3, 4, 6, 8 };
int count = data[(obj->data.m.hit_jump_counter >> 3) & 7];
const int x_pos = obj->x_pos;
const int y_pos = obj->y_pos;
do {
struct object_t *score_obj = level_add_object75_score(obj, num);
if (score_obj) {
score_obj->data.t.counter = count << 2;
}
obj->y_pos += 7;
obj->x_pos += 9;
} while (--count != 0);
obj->x_pos = x_pos;
obj->y_pos = y_pos;
obj->data.m.state = 0xFF;
if ((m->flags & 1) == 0) {
g_vars.current_bonus.x_pos = obj->x_pos;
g_vars.current_bonus.y_pos = obj->y_pos;
g_vars.current_bonus.spr_num = 0x2046; /* bones */
level_add_object23_bonus(48, -128, 6);
} else {
level_monster_update_anim(obj);
if ((m->flags & ~0x37) != 0x88) {
m->flags &= ~8;
}
int dy = MIN(g_vars.player_club_power, 25);
dy = (-dy) << 3;
obj->data.m.y_velocity = dy;
int dx = dy >> 1;
if ((obj_player->spr_num & 0x8000) == 0) {
dx = -dx;
}
obj->data.m.x_velocity = dx;
}
}
static bool level_collide_axe_monsters(struct object_t *axe_obj) {
for (int i = 0; i < MONSTERS_COUNT; ++i) {
struct object_t *obj = &g_vars.objects_tbl[11 + i];
if (obj->spr_num == 0xFFFF) {
continue;
}
if (obj->data.m.state == 0xFF) {
continue;
}
struct level_monster_t *m = obj->data.m.ref;
if (m->flags & 0x10) {
continue;
}
if (!level_objects_collide(axe_obj, obj)) {
continue;
}
obj->data.m.flags |= 0x40;
obj->data.m.energy -= g_vars.player_club_power;
if (obj->data.m.energy < 0) {
play_sound(2);
level_monster_die(obj, m, axe_obj);
} else {
obj->x_pos -= obj->data.m.x_velocity >> 2;
}
axe_obj->spr_num = 0xFFFF;
return true;
}
return false;
}
static uint16_t level_get_random_bonus_spr_num() {
uint8_t num;
while (1) {
num = random_get_number() & 0x7F;
if (num < 0x5F) {
break;
}
}
return 0x2080 + num;
}
void level_add_bonuses_4x() {
int x_vel = 32;
int y_vel = -160;
for (int i = 0; i < 4; ++i) {
g_vars.current_bonus.spr_num = level_get_random_bonus_spr_num();
level_add_object23_bonus(x_vel, y_vel, 4);
x_vel = -x_vel;
if (x_vel >= 0) {
x_vel -= 16;
y_vel -= 16;
}
}
}
static bool level_update_found_bonus_tile(struct level_bonus_t *bonus) {
const uint16_t pos = bonus->pos;
bonus->pos = 0xFFFF;
level_set_tile(pos, bonus->tile_num1);
int8_t al = (pos & 0xFF) - g_vars.tilemap.x;
if (al < 0 || al >= (TILEMAP_SCREEN_W / 16)) {
return false;
}
int8_t ah = (pos >> 8) - g_vars.tilemap.y;
if (ah < 0 || ah >= (TILEMAP_SCREEN_H / 16) + 1) {
return false;
}
return false;
}
static bool level_handle_bonuses_found(struct object_t *obj, struct level_bonus_t *bonus) {
const uint16_t pos = bonus->pos;
const int y_pos = ((pos >> 8) << 4) + 8;
const int x_pos = ((pos & 0xFF) << 4) + 12;
level_init_object_hit_from_xy_pos(x_pos, y_pos);
if (bonus->count & 0x80) {
--bonus->count;
if (bonus->count & 0x80) {
return false;
}
g_vars.current_bonus.x_pos = (pos & 0xFF) << 4;
g_vars.current_bonus.y_pos = (pos >> 8) << 4;
int num = 0;
while (1) {
num = random_get_number() & 7;
if (num != 0) {
break;
}
}
g_vars.current_bonus.spr_num = 110 + num;
g_vars.current_bonus.y_pos -= 112;
level_add_object23_bonus(0, 0, 1);
++g_vars.level_current_secrets_count;
} else {
static uint8_t draw_counter = 0;
const int diff = abs(g_vars.level_draw_counter - draw_counter);
draw_counter = g_vars.level_draw_counter;
if (diff < 6) {
return true;
}
g_vars.current_bonus.x_pos = (pos & 0xFF) << 4;
g_vars.current_bonus.y_pos = (pos >> 8) << 4;
int x_vel, count = 1;
if (bonus->count & 0x40) {
if (bonus->count == 64) {
bonus->count = 0;
if (g_vars.level_num == 3) {
g_vars.current_bonus.spr_num = 306;
} else if (g_vars.level_num == 7 || g_vars.level_num == 6) {
g_vars.current_bonus.spr_num = 300;
} else {
g_vars.current_bonus.spr_num = 308;
}
level_add_object23_bonus(32, -48, 2);
if (g_vars.level_num == 8) {
g_vars.current_bonus.spr_num = 310;
count = 2;
} else {
g_vars.current_bonus.spr_num = 229;
count = 4;
}
} else {
if (g_vars.level_num == 3) {
g_vars.current_bonus.spr_num = 306;
} else if (g_vars.level_num == 7 || g_vars.level_num == 6) {
g_vars.current_bonus.spr_num = 300;
} else {
g_vars.current_bonus.spr_num = 308;
}
level_add_object23_bonus(48, -96, 4);
goto decrement_bonus;
}
} else {
g_vars.current_bonus.spr_num = level_get_random_bonus_spr_num();
}
x_vel = 48;
if (obj < &g_vars.objects_tbl[1]) {
if (g_vars.objects_tbl[1].data.p.hdir >= 0) {
x_vel = -x_vel;
}
} else if (obj->x_velocity >= 0) {
x_vel = -x_vel;
}
level_add_object23_bonus(x_vel, -112, count);
decrement_bonus:
--bonus->count;
if ((bonus->count & 0x80) == 0) {
return true;
}
}
return level_update_found_bonus_tile(bonus);
}
static bool level_collide_axe_bonuses(struct object_t *obj) {
const int obj_x = obj->x_pos >> 4;
const int obj_y = obj->y_pos - 16;
for (int i = 0; i < MAX_LEVEL_BONUSES; ++i) {
struct level_bonus_t *bonus = &g_res.level.bonuses_tbl[i];
if (bonus->pos == 0xFFFF) {
continue;
}
const int bonus_x = bonus->pos & 0xFF;
if (abs(bonus_x - obj_x) > 1) {
continue;
}
const int bonus_y = bonus->pos >> 8;
if (abs((bonus_y << 4) - obj_y) >= 16) {
continue;
}
obj->spr_num = 0xFFFF;
if (level_handle_bonuses_found(obj, bonus)) {
continue;
}
memset(g_vars.level_bonuses_count_tbl, 0, 80);
int count = 0;
const uint16_t pos = bonus->pos;
for (int j = 0; j < MAX_LEVEL_BONUSES; ++j) {
struct level_bonus_t *bonus2 = &g_res.level.bonuses_tbl[j];
if (bonus2->pos == 0xFFFF || bonus2->pos == pos) {
continue;
}
if (abs((bonus2->pos & 0xFF) - bonus_x) > 1) {
continue;
}
if (abs((bonus2->pos >> 8) - bonus_y) > 1) {
continue;
}
if (g_vars.level_bonuses_count_tbl[j] == 0) {
++g_vars.level_bonuses_count_tbl[j];
++g_vars.level_current_secrets_count;
++count;
}
}
if (count == 0) {
return true;
}
}
return false;
}
static void level_update_objects_axe() {
g_vars.player_using_club_flag = true;
for (int i = 0; i < 4; ++i) {
struct object_t *obj = &g_vars.objects_tbl[2 + i];
if (obj->spr_num == 0xFFFF) {
continue;
}
if (level_collide_axe_monsters(obj) || level_collide_axe_bonuses(obj)) {
continue;
}
}
if (g_vars.player_flying_flag == 0) {
struct object_t *obj = &g_vars.objects_tbl[0];
if (obj->spr_num != 0xFFFF) {
if (level_collide_axe_monsters(obj) || level_collide_axe_bonuses(obj)) {
if (g_vars.objects_tbl[1].data.p.y_velocity != 0) {
g_vars.objects_tbl[1].data.p.y_velocity = -80;
}
}
}
g_vars.player_using_club_flag = false;
}
}
static int level_get_tile_monster_offset(uint8_t tile_num, struct object_t *obj) {
const uint8_t attr = g_res.level.tile_attributes1[tile_num];
if ((attr & 0x30) == 0) {
return attr;
}
int x = (obj->x_pos & 15) / 3;
if (attr & 0x10) {
x = (attr & 15) + x;
} else {
x = (attr & 15) - x;
}
return x;
}
static void level_update_monster_pos(struct object_t *obj, struct level_monster_t *m) {
const uint16_t pos = ((obj->y_pos >> 4) << 8) | (obj->x_pos >> 4);
uint8_t dl = level_get_tile(pos);
uint8_t dh = level_get_tile(pos - 0x100);
int x_vel = obj->data.m.x_velocity;
if (x_vel != 0 && x_vel <= 1) {
x_vel = -x_vel;
}
uint8_t al = level_get_tile(pos + x_vel - 0x100);
al = g_res.level.tile_attributes0[al];
if ((m->flags & 0x40) != 0 && (m->flags & 0x80) != 0) {
if (al != 0) {
obj->x_pos -= obj->data.m.x_velocity >> 4;
} else {
monster_change_prev_anim(obj);
obj->data.m.y_velocity = 0;
m->flags &= ~0x80;
obj->y_pos -= 16;
}
} else {
if (al != 0) {
if (m->flags & 0x40) {
monster_change_next_anim(obj);
m->flags |= 0x80;
obj->data.m.y_velocity &= ~15;
obj->x_pos += obj->data.m.x_velocity >> 2;
return;
}
obj->data.m.x_velocity = -obj->data.m.x_velocity;
obj->x_pos += obj->data.m.x_velocity >> 4;
}
obj->y_pos -= 16;
SWAP(dl, dh);
al = g_res.level.tile_attributes1[dl];
if (al == 0) {
obj->y_pos += 16;
dl = dh;
al = g_res.level.tile_attributes1[dl];
if (al == 0) {
if (obj->data.m.y_velocity < 256) {
obj->data.m.y_velocity += 16;
}
return;
}
}
const int dy = level_get_tile_monster_offset(dl, obj);
obj->y_pos &= ~15;
obj->y_pos += dy;
if ((m->flags & 0x20) == 0) {
int y_vel = (-obj->data.m.y_velocity) >> 1;
if (abs(y_vel) <= 32) {
y_vel = 0;
}
obj->data.m.y_velocity = y_vel;
} else {
obj->data.m.y_velocity = 0;
}
}
}
extern void boss_update();
extern void monster_func1(int type, struct object_t *obj); /* update */
extern bool monster_func2(int type, struct level_monster_t *m); /* init */
static void level_update_objects_monsters() {
boss_update();
for (int i = 0; i < MONSTERS_COUNT; ++i) {
struct object_t *obj = &g_vars.objects_tbl[11 + i];
if (obj->spr_num == 0xFFFF) {
continue;
}
print_debug(DBG_GAME, "monster #%d pos %d,%d spr %d", i, obj->x_pos, obj->y_pos, obj->spr_num);
obj->y_pos += obj->data.m.y_velocity >> 4;
if (obj->data.m.x_velocity != -1) {
obj->x_pos += obj->data.m.x_velocity >> 4;
}
struct level_monster_t *m = obj->data.m.ref;
if (m->flags & 8) {
level_update_monster_pos(obj, m);
}
const uint8_t *p = obj->data.m.anim;
int16_t num;
while (1) {
num = READ_LE_UINT16(p);
if (num >= 0) {
break;
}
p += num;
}
uint16_t dx = g_res.spr_monsters_offset + (num & 0x1FFF);
g_vars.monster.hit_mask = ((num >> 8) & 0xE0) | (g_vars.player_hit_monster_counter & 0xFF);
if (g_vars.player_hit_monster_counter == 0) {
obj->data.m.anim = p + 2;
} else {
if (g_vars.player_hit_monster_counter == 7) {
g_vars.shake_screen_counter = 9;
}
const uint16_t *q = monster_spr_tbl;
const uint16_t *end = &monster_spr_tbl[48];
dx &= 0x1FFF;
while (q < end) {
if (dx < q[0]) {
obj->data.m.anim = p + 2;
break;
}
if (dx <= q[1]) {
dx = q[2] + 53;
break;
}
q += 3;
}
if (q >= end) {
print_warning("level_update_objects_monsters spr %d hit %d not found", dx, g_vars.player_hit_monster_counter);
continue;
}
}
dx &= 0x1FFF;
if (obj->data.m.x_velocity < 0) {
dx |= 0x8000;
}
obj->spr_num &= 0x6000;
obj->spr_num |= dx;
const int type = (m->type & 0x7F);
monster_func1(type, obj);
}
for (int i = 0; i < g_res.level.monsters_count; ++i) {
struct level_monster_t *m = &g_res.level.monsters_tbl[i];
if (m->spr_num != 0xFFFF && (m->flags & 4) == 0) {
const int type = m->type & 0x7F;
if (!monster_func2(type, m)) {
continue;
}
/* monster type */
const uint8_t *p = monster_anim_tbl;
const uint8_t *end = &monster_anim_tbl[1100];
do {
p += 2;
} while (p < end && (READ_LE_UINT16(p) != 0x7D01 || READ_LE_UINT16(p + 2) != type));
p += 4;
/* monster sprite */
const int spr_num = m->spr_num - g_res.spr_monsters_offset;
while (p < end && READ_LE_UINT16(p) != spr_num) {
p += 2;
}
if (p >= end) {
print_warning("level_update_objects_monsters type %d spr %d not found", type, spr_num);
continue;
}
g_vars.monster.current_object->data.m.anim = p;
}
}
}
static void level_update_objects_club_projectiles() {
for (int i = 0; i < 4; ++i) {
struct object_t *obj = &g_vars.objects_tbl[2 + i];
if (obj->spr_num == 0xFFFF) {
continue;
}
if ((obj->spr_num & 0x2000) == 0) {
obj->spr_num = 0xFFFF;
continue;
}
obj->x_pos += obj->x_velocity >> 4;
obj->y_pos += obj->data.c.y_velocity >> 4;
const uint8_t *anim = obj->data.c.anim;
int16_t num = READ_LE_UINT16(anim);
if (num < 0) {
anim += num;
num = READ_LE_UINT16(anim);
}
obj->data.c.anim = anim + 2;
obj->spr_num = num | ((obj->x_velocity < 0) ? 0x8000 : 0);
switch (obj->x_friction) {
case 0:
obj->data.c.y_velocity += 32;
break;
case 1:
obj->data.c.y_velocity -= 16;
break;
default:
print_warning("Unhandled level_update_objects_club_projectiles type %d", obj->x_friction);
break;
}
}
}
static void level_update_objects_bonuses() {
for (int i = 0; i < 32; ++i) {
struct object_t *obj = &g_vars.objects_tbl[23 + i];
if (obj->spr_num == 0xFFFF) {
continue;
}
--obj->data.t.counter;
if (obj->data.t.counter == 0) {
obj->hit_counter = 15;
continue;
}
if (obj->data.t.counter < 0) {
if (obj->hit_counter == 0) {
obj->spr_num = 0xFFFF;
}
continue;
}
obj->x_pos += obj->x_velocity >> 4;
if (obj->x_pos < 0) {
obj->x_pos = 0;
obj->x_velocity = -obj->x_velocity;
}
obj->y_pos += (obj->data.t.y_velocity >> 4);
const int dy = obj->data.t.y_velocity + 9;
if (dy < 256) {
obj->data.t.y_velocity = dy;
}
const int num = obj->spr_num & 0x1FFF;
if (num == 229) {
continue;
}
if (num == 300 || num == 306 || num == 308 || num == 310) {
if (obj->data.t.counter > 50) {
obj->data.t.counter = 50;
}
continue;
}
const uint16_t pos = ((obj->y_pos >> 4) << 8) | (obj->x_pos >> 4);
if (dy > 0) {
const int tile_num = level_get_tile(pos);
uint8_t al = g_res.level.tile_attributes1[tile_num];
if (al != 0) {
/* bounce on the ground */
obj->data.t.y_velocity = -obj->data.t.y_velocity;
obj->data.t.y_velocity >>= 1;
const bool x_direction = (obj->x_velocity < 0);
const int dx = (obj->x_velocity < 0) ? -8 : 8;
obj->x_velocity -= dx;
if (x_direction != (obj->x_velocity < 0)) {
obj->x_velocity = 0;
}
}
} else {
const int tile_num = level_get_tile(pos - 0x100);
uint8_t al = g_res.level.tile_attributes0[tile_num];
if (al != 0) {
obj->x_velocity = -obj->x_velocity;
obj->x_pos += obj->x_velocity >> 4;
}
}
if (g_vars.level_draw_counter & 1) {
continue;
}
if (obj->x_velocity == 0) {
continue;
}
if (num < 73) {
obj->spr_num = num + 1;
} else if (num == 73) {
obj->spr_num = 70;
}
}
}
static void level_update_objects_bonus_scores() {
for (int i = 0; i < 16; ++i) {
struct object_t *obj = &g_vars.objects_tbl[75 + i];
if (obj->spr_num != 0xFFFF) {
--obj->y_pos;
--obj->data.t.counter;
if (obj->data.t.counter == 0) {
obj->spr_num = 0xFFFF;
}
}
}
}
static bool level_update_objects_decors_helper(struct object_t *obj) {
if (g_vars.level_force_x_scroll_flag != 0) {
return false;
}
if (obj->y_pos <= g_vars.objects_tbl[1].y_pos) {
return false;
}
const int prev_y_pos = g_vars.objects_tbl[1].y_pos;
if (g_vars.current_platform_dy >= 0) {
g_vars.objects_tbl[1].y_pos += g_vars.current_platform_dy;
}
const int prev_spr_num = g_vars.objects_tbl[1].spr_num;
g_vars.objects_tbl[1].spr_num = 7;
const bool ret = level_objects_collide(&g_vars.objects_tbl[1], obj);
g_vars.objects_tbl[1].y_pos = prev_y_pos;
g_vars.objects_tbl[1].spr_num = prev_spr_num;
if (!ret) {
return false;
}
g_vars.level_force_x_scroll_flag = 1;
g_vars.objects_tbl[1].x_friction = 0;
g_vars.objects_tbl[1].x_pos += g_vars.current_platform_dx;
level_player_reset();
const int y = obj->y_pos - spr_size_tbl[(obj->spr_num & 0x1FFF) * 2 + 1];
if (g_vars.objects_tbl[1].y_pos > y) {
g_vars.objects_tbl[1].y_pos = y + 1;
g_vars.objects_tbl[1].data.p.y_velocity = 1;
} else {
g_vars.objects_tbl[1].data.p.y_velocity = g_vars.current_platform_dy << 4;
}
return true;
}
static void level_update_objects_decors() {
g_vars.level_force_x_scroll_flag = 0;
int count = 7;
struct object_t *obj = &g_vars.objects_tbl[91];
for (int i = 0; i < MAX_LEVEL_PLATFORMS; ++i) {
struct level_platform_t *platform = &g_res.level.platforms_tbl[i];
if (platform->spr_num == 0xFFFF) {
continue;
}
if ((platform->flags & 15) == 8) {
g_vars.current_platform_dx = 0;
platform->y_pos -= platform->type8.y_delta;
if (platform->type8.state == 0) {
int a = platform->type8.y_delta - 8;
if (a < 0) {
a = 0;
platform->type8.y_velocity = 0;
}
platform->type8.y_delta = a;
if (platform->flags & 0x40) {
if (platform->type8.y_velocity != 0 && --platform->type8.counter == 0) {
platform->type8.state = 1;
platform->type8.y_velocity = 0;
}
}
} else if (platform->type8.state == 1) {
int y = platform->type8.y_velocity;
if (y < 192) {
platform->type8.y_velocity += 8;
}
y >>= 4;
g_vars.current_platform_dy = y;
platform->type8.y_delta += y;
const int tile_x = platform->x_pos >> 4;
const int tile_y = (platform->y_pos + platform->type8.y_delta) >> 4;
const int y2 = g_vars.tilemap.h - 1 - tile_y;
if (y2 < 0) {
if ((-y2) >= 3) {
platform->type8.state = 2;
platform->type8.counter = 22;
}
} else {
const uint8_t tile_num = level_get_tile((tile_y << 8) | tile_x);
const uint8_t tile_attr1 = g_res.level.tile_attributes1[tile_num];
if (tile_attr1 != 0 && tile_attr1 != 6) {
platform->type8.state = 2;
platform->type8.counter = 22;
}
}
} else if (platform->type8.state == 2) {
if ((platform->flags & 0x40) == 0 && --platform->type8.counter == 0) {
platform->type8.state = 0;
platform->type8.counter = platform->type8.unk9;
}
}
platform->y_pos += platform->type8.y_delta;
} else {
g_vars.current_platform_dx = 0;
g_vars.current_platform_dy = 0;
if (platform->other.velocity != 0 || platform->other.max_velocity < 0 || (platform->flags & 0xC0) != 0) {
if (platform->other.max_velocity > platform->other.velocity) {
++platform->other.velocity;
} else if (platform->other.max_velocity < platform->other.velocity) {
--platform->other.velocity;
}
int al = platform->other.velocity;
int ah = platform->other.velocity;
const int type = platform->flags & 7;
if (type == 0) {
al = 0;
ah = -ah;
} else if (type == 1) {
ah = -ah;
} else if (type == 2) {
ah = 0;
} else if (type == 4) {
al = 0;
} else if (type == 5) {
al = -al;
} else if (type == 6) {
al = -al;
ah = 0;
} else if (type == 7) {
al = -al;
ah = -ah;
}
g_vars.current_platform_dx = al;
platform->x_pos += al;
g_vars.current_platform_dy = ah;
platform->y_pos += ah;
if (platform->other.max_velocity == platform->other.velocity) {
uint16_t ax = platform->other.counter + 1;
if (platform->other.unkA == ax) {
platform->other.max_velocity = -platform->other.max_velocity;
ax = 0;
}
platform->other.counter = ax;
}
}
}
const int x_pos = platform->x_pos - (g_vars.tilemap.x << 4);
if (x_pos >= TILEMAP_SCREEN_W + 32 || x_pos <= -32) {
continue;
}
const int y_pos = platform->y_pos - (g_vars.tilemap.y << 4);
if (y_pos >= TILEMAP_SCREEN_H + 32 || y_pos <= -32) {
continue;
}
obj->x_pos = platform->x_pos;
obj->y_pos = platform->y_pos;
obj->spr_num = platform->spr_num;
obj->data.t.ref = platform;
if (g_vars.objects_tbl[1].data.p.y_velocity > -16) {
platform->flags |= 0x40;
if (level_update_objects_decors_helper(obj)) {
++obj;
--count;
if (count == 0) {
return;
}
continue;
}
}
platform->flags &= ~0x40;
obj->y_pos -= 2;
++obj;
--count;
if (count == 0) {
return;
}
}
do {
obj->spr_num = 0xFFFF;
++obj;
} while (--count != 0);
}
static void level_update_player_x_velocity() {
bool left = false;
int x_vel = g_vars.objects_tbl[1].x_velocity;
if (x_vel < 0) {
x_vel = -x_vel;
left = true;
}
x_vel -= 12 >> g_vars.objects_tbl[1].x_friction;
if (x_vel < 0) {
x_vel = 0;
}
if (left) {
x_vel = -x_vel;
}
g_vars.objects_tbl[1].x_velocity = x_vel;
}
static void level_update_player_hdir_x_velocity(int x_vel) {
int16_t f = 0;
if (g_vars.input.key_hdir) {
f = g_vars.objects_tbl[1].data.p.hdir << 4;
}
f >>= g_vars.objects_tbl[1].x_friction;
const int16_t dx = g_vars.objects_tbl[1].x_velocity + f;
if (dx < x_vel) {
x_vel = -x_vel;
if (dx > x_vel) {
x_vel = dx;
}
}
g_vars.objects_tbl[1].x_velocity = x_vel;
}
static void level_update_screen_x_velocity() {
if ((g_options.cheats & CHEATS_NO_WIND) == 0) {
g_vars.objects_tbl[1].x_velocity -= g_vars.snow.value >> 3;
}
if (g_vars.objects_tbl[1].x_velocity < -96) {
g_vars.objects_tbl[1].x_velocity = -96;
}
}
static void level_update_player_y_velocity(int y_vel) {
int f = 16;
if (g_vars.player_gravity_flag == 1) {
f = 4;
y_vel >>= 3;
}
const int y = g_vars.objects_tbl[1].data.p.y_velocity + f;
if (y < y_vel) {
y_vel = y;
}
g_vars.objects_tbl[1].data.p.y_velocity = y_vel;
}
static void level_update_player_jump() {
level_update_player_hdir_x_velocity(80);
level_update_player_y_velocity(192);
uint8_t num;
if (g_vars.player_flying_flag != 0) {
num = 45;
if (g_vars.objects_tbl[1].data.p.y_velocity >= 0) {
++num;
}
} else {
if (g_vars.objects_tbl[1].data.p.y_velocity <= 0) {
return;
}
g_vars.player_nojump_counter = 6;
if (g_vars.player_anim_0x40_flag != 0) {
return;
}
num = 12;
if (g_vars.player_jumping_counter >= 12) {
++num;
}
}
g_vars.objects_tbl[1].spr_num = num | ((g_vars.objects_tbl[1].data.p.hdir < 0) ? 0x8000 : 0);
}
static const uint8_t *level_update_player_anim1_num(uint8_t num, uint16_t anim) {
assert((anim & 1) == 0);
assert(anim == num * 2);
if (g_vars.objects_tbl[1].data.p.special_anim_num != num) {
g_vars.objects_tbl[1].data.p.special_anim_num = num;
g_vars.objects_tbl[1].data.p.anim = object_anim_tbl[anim / 2];
}
return g_vars.objects_tbl[1].data.p.anim;
}
static const uint8_t *level_update_player_anim2_num(uint8_t num, uint16_t anim) {
assert((anim & 1) == 0);
assert(anim == num * 2);
if (g_vars.objects_tbl[1].data.p.current_anim_num != num) {
g_vars.objects_tbl[1].data.p.current_anim_num = num;
g_vars.objects_tbl[1].data.p.anim = object_anim_tbl[anim / 2];
}
return g_vars.objects_tbl[1].data.p.anim;
}
static struct object_t *level_find_object_club_projectile() {
for (int i = 0; i < 4; ++i) {
struct object_t *obj = &g_vars.objects_tbl[2 + i];
if (obj->spr_num == 0xFFFF) {
return obj;
}
}
return 0;
}
static void level_update_player_anim_3_6_7(uint8_t al) {
const uint8_t *p = level_update_player_anim2_num(al, al * 2);
level_update_object_anim(p);
level_update_player_x_velocity();
if (g_vars.player_moving_counter < UCHAR_MAX) {
++g_vars.player_moving_counter;
}
al = club_anim_tbl[g_vars.player_club_type].power;
if (g_vars.player_club_powerup_duration != 0) {
al <<= 2;
}
g_vars.player_club_power = al;
g_vars.player_anim_0x40_flag = (g_vars.player_current_anim_type & 0x40) ^ 0x40;
if (g_vars.player_anim_0x40_flag == 0) {
g_vars.player_club_anim_duration = club_anim_tbl[g_vars.player_club_type].a;
if (g_vars.player_club_type == 0) {
play_sound(5);
} else if (g_vars.player_club_type == 1) {
play_sound(0);
} else {
play_sound(10);
}
int16_t dy = 0;
al = g_vars.objects_tbl[1].data.p.current_anim_num;
if (al != 6) {
dy = -32;
if (al != 3) {
dy = -48;
if (g_vars.level_draw_counter & 3) {
level_init_object_hit_from_player_pos();
}
}
}
if (g_vars.level_force_x_scroll_flag == 0) {
/* off the ground when using the club */
g_vars.objects_tbl[1].data.p.y_velocity += dy;
}
al = club_anim_tbl[g_vars.player_club_type].c;
if (al & 1) {
/* club with projectile */
struct object_t *obj = level_find_object_club_projectile();
if (obj) {
obj->x_friction = (al >> 1) & 3;
const uint8_t *p = club_anim_tbl[g_vars.player_club_type].anim;
do {
p += 2;
} while (READ_LE_UINT16(p) != 0x55AA);
p += 6;
obj->data.c.anim = p;
int num = READ_LE_UINT16(p);
int16_t y_vel = READ_LE_UINT16(p - 2);
int16_t x_vel = READ_LE_UINT16(p - 4);
obj->data.c.y_velocity = y_vel;
if (g_vars.objects_tbl[1].data.p.hdir < 0) {
num |= 0x8000;
x_vel = -x_vel;
}
obj->spr_num = num;
obj->x_velocity = x_vel;
obj->x_pos = g_vars.objects_tbl[1].x_pos + (x_vel >> 4);
obj->y_pos = g_vars.objects_tbl[1].y_pos + (y_vel >> 4);
g_vars.objects_tbl[0].spr_num = 0xFFFF;
return;
}
}
if (g_vars.player_jumping_counter != 0) {
g_vars.objects_tbl[0].spr_num = 0xFFFF;
return;
}
}
const uint16_t spr_num = g_vars.objects_tbl[1].spr_num;
p = club_anim_tbl[g_vars.player_club_type].anim;
while (READ_LE_UINT16(p) != 0x55AA) {
if (READ_LE_UINT16(p) == (spr_num & 0x1FFF)) {
int16_t num = READ_LE_UINT16(p + 2);
int16_t x = READ_LE_UINT16(p + 4);
if (spr_num & 0x8000) {
x = -x;
}
int16_t y = READ_LE_UINT16(p + 6);
g_vars.objects_tbl[0].spr_num = num | (spr_num & 0x8000);
g_vars.objects_tbl[0].x_pos = g_vars.objects_tbl[1].x_pos + (g_vars.objects_tbl[1].x_velocity >> 4) - x;
g_vars.objects_tbl[0].y_pos = g_vars.objects_tbl[1].y_pos + (g_vars.objects_tbl[1].data.p.y_velocity >> 4) - y;
break;
}
p += 8;
}
}
static void level_update_player_anim_0(uint8_t al) {
if (g_vars.player_anim_0x40_flag != 0) {
level_update_player_anim_3_6_7(g_vars.objects_tbl[1].data.p.current_anim_num);
return;
}
g_vars.player_unk_counter1 = 0;
level_update_screen_x_velocity();
level_update_player_x_velocity();
if (g_vars.level_force_x_scroll_flag == 0 && g_vars.objects_tbl[1].data.p.y_velocity != 0) {
if (g_vars.player_anim2_counter > 4) {
level_update_screen_x_velocity();
}
return;
}
const int x_vel = abs(g_vars.objects_tbl[1].x_velocity);
if (x_vel >= 8) {
const bool same_direction = ((g_vars.objects_tbl[1].spr_num & 0x8000) != 0) && (g_vars.objects_tbl[1].x_velocity < 0);
if (same_direction) {
const uint8_t *anim = level_update_player_anim1_num(18, 36);
level_update_object_anim(anim);
if ((g_vars.level_draw_counter & 3) == 0) {
level_init_object_hit_from_player_pos(&g_vars.objects_tbl[1]);
}
g_vars.objects_tbl[1].data.p.current_anim_num = 0;
return;
}
} else if (x_vel == 0) {
if (g_vars.player_moving_counter >= 30) {
if ((g_vars.input.key_right & g_vars.input.key_left) == 0) {
/* player stopped moving, show exhausted animation */
g_vars.player_moving_counter -= 3;
const uint8_t *anim = level_update_player_anim1_num(16, 32);
level_update_object_anim(anim);
g_vars.objects_tbl[1].data.p.current_anim_num = 0;
return;
}
} else {
if ((g_vars.input.key_right & g_vars.input.key_left) != 0) {
const uint8_t *anim = level_update_player_anim1_num(19, 38);
level_update_object_anim(anim);
if ((g_res.level.scrolling_mask & 2) == 0 && g_vars.tilemap_noscroll_flag == 0) {
const int dx = (g_vars.objects_tbl[1].x_pos >> 4) - g_vars.tilemap.x;
if ((g_vars.objects_tbl[1].spr_num & 0x8000) == 0) {
if (dx > 2) {
level_adjust_hscroll_right();
}
} else {
if (dx < 17) {
level_adjust_hscroll_left();
}
}
}
g_vars.objects_tbl[1].data.p.current_anim_num = 0;
return;
}
/* show idle animation */
static const uint16_t data[] = { 16, 96, 128, 176, 256, 512 };
const uint16_t timer = timer_get_counter() & 511;
int offset = 0;
while (1) {
if (timer < data[offset]) {
break;
}
++offset;
if (timer < data[offset]) {
const uint8_t *anim = level_update_player_anim1_num(17, 34);
level_update_object_anim(anim);
g_vars.objects_tbl[1].data.p.current_anim_num = 0;
return;
}
++offset;
}
}
}
const uint8_t *p = object_anim_tbl[al];
g_vars.objects_tbl[1].data.p.anim = p;
g_vars.objects_tbl[1].spr_num = READ_LE_UINT16(p) | ((g_vars.objects_tbl[1].data.p.hdir < 0) ? 0x8000 : 0);
g_vars.objects_tbl[1].data.p.special_anim_num = 0;
g_vars.objects_tbl[1].data.p.current_anim_num = 0;
}
static void level_update_player_anim_1(uint8_t al) {
if (g_vars.player_anim_0x40_flag != 0) {
level_update_player_anim_3_6_7(g_vars.objects_tbl[1].data.p.current_anim_num);
return;
}
const int x_vel = abs(g_vars.objects_tbl[1].x_velocity);
if (x_vel >= 64 && g_vars.player_flying_flag != 0) {
if (g_vars.player_unk_counter1 < UCHAR_MAX) {
++g_vars.player_unk_counter1;
}
if (g_vars.player_unk_counter1 == 23) {
level_init_object_hit_from_player_pos();
}
}
if (g_vars.player_moving_counter < UCHAR_MAX) {
++g_vars.player_moving_counter;
}
level_update_player_hdir_x_velocity(80);
level_update_screen_x_velocity();
const uint8_t *p = level_update_player_anim2_num(al, al * 2);
level_update_object_anim(p);
}
static void level_update_player_anim_2(uint8_t al) {
if (g_vars.player_anim_0x40_flag != 0) {
level_update_player_anim_3_6_7(g_vars.objects_tbl[1].data.p.current_anim_num);
return;
}
if (g_vars.player_nojump_counter != 0) {
level_update_player_anim_0(al);
return;
}
g_vars.level_force_x_scroll_flag = 0;
uint8_t value = g_vars.player_anim2_counter;
++g_vars.player_anim2_counter;
if (value < 9) {
static const int8_t y_tbl[] = { -65, -51, -35, -20, -10, -5, -2, -1, 0 };
int16_t ax = y_tbl[value];
if (g_vars.player_flying_flag != 0) {
ax >>= 1;
}
g_vars.objects_tbl[1].data.p.y_velocity += ax;
} else {
level_update_player_y_velocity(192);
}
if (g_vars.objects_tbl[1].x_velocity >= 48) {
level_update_player_x_velocity();
} else {
level_update_player_hdir_x_velocity(48);
}
const uint8_t *p = level_update_player_anim2_num(2, 4);
level_update_object_anim(p);
level_update_screen_x_velocity();
level_update_screen_x_velocity();
}
static void level_update_player_club_power() {
if (g_vars.player_club_powerup_duration <= 48) {
g_vars.player_club_powerup_duration += 2;
}
}
static void level_update_player_anim_4(uint8_t al) {
if (g_vars.player_anim_0x40_flag != 0) {
level_update_player_anim_3_6_7(g_vars.objects_tbl[1].data.p.current_anim_num);
return;
}
g_vars.player_moving_counter = 0;
g_vars.player_action_counter = 4;
level_update_player_club_power();
const int x_vel = abs(g_vars.objects_tbl[1].x_velocity);
if (x_vel > 32) {
level_update_player_anim_0(al);
} else {
level_update_player_hdir_x_velocity(32);
const uint8_t *p = level_update_player_anim2_num(al, al * 2);
level_update_object_anim(p);
}
}
static void level_update_player_anim_5(uint8_t al) {
if (g_vars.player_anim_0x40_flag != 0) {
level_update_player_anim_3_6_7(g_vars.objects_tbl[1].data.p.current_anim_num);
return;
}
g_vars.player_unk_counter1 = 0;
g_vars.player_action_counter = 4;
level_update_player_club_power();
const uint8_t *p = level_update_player_anim2_num(al, al * 2);
level_update_object_anim(p);
level_update_player_x_velocity();
level_update_player_club_power();
}
static void level_update_player_anim_8(uint8_t al) {
level_update_screen_x_velocity();
level_update_player_x_velocity();
const uint8_t *p = level_update_player_anim2_num(al, al * 2);
level_update_object_anim(p);
}
static void level_update_player_decor() {
const int y_pos = (g_vars.objects_tbl[1].y_pos >> 4) - 1;
const int spr_num = g_vars.objects_tbl[1].spr_num & 0x1FFF;
int spr_h = spr_size_tbl[spr_num * 2 + 1];
int dx = 9;
if (g_vars.objects_tbl[1].x_velocity < 0) {
dx = -9;
} else if (g_vars.objects_tbl[1].x_velocity == 0) {
dx = 0;
}
const int x_pos = g_vars.objects_tbl[1].x_pos >> 4;
const int player_ypos_diff = abs((g_vars.objects_tbl[1].y_pos >> 4) - g_vars.tilemap.y);
if (player_ypos_diff > (TILEMAP_SCREEN_H / 16)) {
level_update_tile_type_2();
} else {
const int player_xpos_diff = abs((g_vars.objects_tbl[1].x_pos >> 4) - g_vars.tilemap.x);
if (player_xpos_diff > (TILEMAP_SCREEN_W / 16)) {
level_update_tile_type_2();
} else if ((g_res.level.scrolling_mask & 4) != 0 && g_vars.objects_tbl[1].y_pos < (g_vars.tilemap.y << 4)) {
level_update_tile_type_2();
} else if (g_vars.objects_tbl[1].y_pos >= 0 && g_vars.objects_tbl[1].y_pos > ((g_vars.tilemap.h + 1) << 4)) {
level_update_tile_type_2();
}
}
g_vars.player_tile_flags = 0;
level_update_tile0((y_pos << 8) | x_pos);
if (g_vars.player_tile_flags == 1) {
if (g_vars.level_force_x_scroll_flag != 0) {
level_player_reset();
g_vars.player_jumping_counter = 0;
} else {
level_update_player_jump();
if (g_vars.objects_tbl[1].data.p.y_velocity > 0) {
++g_vars.player_jumping_counter;
}
}
} else {
g_vars.player_jumping_counter = 0;
}
if (g_vars.objects_tbl[1].y_pos <= 0) {
return;
}
int pos = (y_pos << 8) | ((dx + g_vars.objects_tbl[1].x_pos) >> 4);
level_update_tile1(pos);
while (1) {
pos -= 0x100;
if (pos < 0) {
break;
}
spr_h -= 16;
if (spr_h <= 0) {
break;
}
level_update_tile2(pos);
}
}
static void level_update_player_flying() {
if (g_vars.player_flying_flag == 0) {
return;
}
if (g_vars.player_gravity_flag != 0) {
g_vars.objects_tbl[1].spr_num &= 0x8000;
const int x_vel = abs(g_vars.objects_tbl[1].x_velocity);
int num = 48;
if (x_vel < 64) {
++num;
if (x_vel < 32) {
++num;
}
}
if (g_vars.player_flying_anim_index < 3) {
num = 51 - g_vars.player_flying_anim_index;
}
g_vars.objects_tbl[1].spr_num |= num;
}
const uint8_t *p = &player_flying_anim_data[14];
if ((g_vars.input.key_up | g_vars.input.key_down) == 0 && g_vars.player_flying_anim_index != 3) {
if (g_vars.player_flying_anim_index < 3) {
++g_vars.player_flying_anim_index;
} else {
--g_vars.player_flying_anim_index;
}
}
const uint16_t player_spr_num = g_vars.objects_tbl[1].spr_num;
for (uint16_t num; (num = READ_LE_UINT16(p)) != 0; p += 6) {
if (num != (player_spr_num & 0x1FFF)) {
continue;
}
int x_delta = (int8_t)p[4];
int spr_num = READ_LE_UINT16(p + 2);
if (spr_num >= 121) {
spr_num = READ_LE_UINT16(player_flying_anim_data + g_vars.player_flying_anim_index * 2);
}
if (player_spr_num & 0x8000) {
spr_num |= 0x8000;
x_delta = -x_delta;
}
if (g_vars.player_unk_counter1 > 24 && (spr_num & 0x1FFF) < 121) {
++spr_num;
}
g_vars.objects_tbl[0].spr_num = spr_num;
g_vars.objects_tbl[0].x_pos += x_delta;
g_vars.objects_tbl[0].y_pos += (int8_t)p[5];
break;
}
}
static void level_update_player() {
g_vars.objects_tbl[0].spr_num = 0xFFFF;
if (g_vars.input.keystate[0x3B]) {
if (g_vars.restart_level_flag == 0) {
level_player_die();
g_vars.restart_level_flag = 1;
return;
}
}
if (g_vars.input.keystate[0x3C]) {
g_vars.player_death_flag = 1;
return;
}
input_check_ctrl_alt_w();
g_vars.input.key_vdir = g_vars.input.key_up | g_vars.input.key_down;
g_vars.input.key_hdir = g_vars.input.key_left | g_vars.input.key_right;
if (g_vars.input.key_right != 0) {
if (g_vars.input.key_left == 0) {
if (g_vars.objects_tbl[1].data.p.hdir != 1) {
g_vars.objects_tbl[1].data.p.hdir = 1;
g_vars.player_update_counter = 0;
}
}
} else {
if (g_vars.input.key_left != 0) {
if (g_vars.objects_tbl[1].data.p.hdir != -1) {
g_vars.objects_tbl[1].data.p.hdir = -1;
g_vars.player_update_counter = 0;
}
}
}
uint16_t mask = 0;
mask |= g_vars.input.key_right & 1;
mask <<= 1;
mask |= g_vars.input.key_left & 1;
mask <<= 1;
mask |= g_vars.input.key_up & 1;
mask <<= 1;
mask |= g_vars.input.key_down & 1;
mask <<= 1;
mask |= g_vars.input.key_space & 1;
if (g_vars.player_club_anim_duration != 0) {
mask = 0;
}
uint8_t dl = g_vars.objects_tbl[1].hit_counter;
g_vars.objects_tbl[0].hit_counter = dl;
uint8_t al = player_anim_lut[mask];
if (dl >= 22) {
al = 8;
}
if (g_vars.objects_tbl[1].data.p.current_anim_num != al) {
g_vars.player_update_counter = 0;
g_vars.objects_tbl[1].data.p.special_anim_num = 0;
}
if (g_vars.player_update_counter < USHRT_MAX) {
++g_vars.player_update_counter;
}
if (g_vars.player_flying_flag != 0) {
mask += 0x40;
if ((g_vars.player_flying_flag &= 1) != 0) {
if (g_vars.input.key_up) {
if (g_vars.player_flying_anim_index == 6) {
if (g_vars.objects_tbl[1].data.p.y_velocity > 16) {
g_vars.player_flying_flag |= 2;
}
} else {
++g_vars.player_flying_anim_index;
}
if (g_vars.player_flying_counter != 0) {
--g_vars.player_flying_counter;
if (g_vars.player_flying_anim_index >= 4) {
g_vars.objects_tbl[1].data.p.y_velocity = -64;
}
goto update_pos;
}
}
if (g_vars.input.key_down) {
if (g_vars.player_flying_counter != 0) {
--g_vars.player_flying_counter;
}
goto update_pos;
} else {
if (g_vars.player_flying_anim_index != 0) {
--g_vars.player_flying_anim_index;
}
g_vars.player_flying_flag |= 2;
if (g_vars.player_flying_anim_index <= 1) {
const int x = abs(g_vars.objects_tbl[1].x_velocity >> 4);
if (g_vars.player_flying_counter < x * 5) {
g_vars.player_flying_counter += x;
}
}
goto update_pos;
}
} else {
if (g_vars.objects_tbl[1].data.p.y_velocity > 160) {
g_vars.player_flying_flag = 1;
}
}
}
switch (al) {
case 0:
level_update_player_anim_0(al);
break;
case 1:
level_update_player_anim_1(al);
break;
case 2:
level_update_player_anim_2(al);
break;
case 3:
case 6:
case 7:
level_update_player_anim_3_6_7(al);
break;
case 4:
level_update_player_anim_4(al);
break;
case 5:
level_update_player_anim_5(al);
break;
case 8:
level_update_player_anim_8(al);
break;
default:
print_warning("Unhandled anim_lut %d mask %d", al, mask);
break;
}
update_pos:
{
const int x_pos = (g_vars.objects_tbl[1].x_velocity >> 4) + g_vars.objects_tbl[1].x_pos;
const int end_x = (g_res.level.tilemap_w + 20) << 4;
if (end_x > x_pos && x_pos >= 8 && x_pos < 511 * 8) {
g_vars.objects_tbl[1].x_pos = x_pos;
}
}
g_vars.objects_tbl[1].y_pos += g_vars.objects_tbl[1].data.p.y_velocity >> 4;
level_update_player_decor();
level_update_player_flying();
if (g_vars.player_club_powerup_duration > 0) {
--g_vars.player_club_powerup_duration;
}
if (g_vars.player_club_anim_duration > 0) {
--g_vars.player_club_anim_duration;
}
if (g_vars.shake_screen_counter > 0) {
--g_vars.shake_screen_counter;
}
if (g_vars.restart_level_flag > 0) {
--g_vars.restart_level_flag;
}
if (g_vars.player_action_counter > 0) {
--g_vars.player_action_counter;
}
if (g_vars.player_bonus_letters_blinking_counter > 0) {
--g_vars.player_bonus_letters_blinking_counter;
}
if (g_vars.player_hit_monster_counter > 0) {
--g_vars.player_hit_monster_counter;
}
}
static void level_add_object23_bones() {
g_vars.current_bonus.x_pos = g_vars.objects_tbl[1].x_pos;
g_vars.current_bonus.y_pos = g_vars.objects_tbl[1].y_pos - 48;
const int count = g_vars.player_energy * 6 + g_vars.bonus_energy_counter;
if (count != 0) {
g_vars.player_energy = 0;
g_vars.bonus_energy_counter = 0;
g_vars.current_bonus.spr_num = 0x2046; /* bones */
level_add_object23_bonus(48, -128, count);
}
}
static void level_clear_item(struct object_t *obj) {
struct level_item_t *item = obj->data.t.ref;
if (item) {
assert(item >= &g_res.level.items_tbl[0] && item < &g_res.level.items_tbl[MAX_LEVEL_ITEMS]);
item->spr_num = 0xFFFF;
}
}
static void level_update_player_collision() {
struct object_t *obj_player = &g_vars.objects_tbl[1];
/* monsters */
if (g_vars.objects_tbl[1].hit_counter == 0) {
for (int i = 0; i < MONSTERS_COUNT; ++i) {
struct object_t *obj = &g_vars.objects_tbl[11 + i];
if (obj->spr_num == 0xFFFF || (obj->spr_num & 0x2000) == 0) {
continue;
}
struct level_monster_t *m = obj->data.m.ref;
if (m->flags & 0x10) {
continue;
}
if (obj->data.m.state == 0xFF) {
continue;
}
if (g_options.cheats & CHEATS_NO_HIT) {
continue;
}
if (!level_objects_collide(obj_player, obj)) {
continue;
}
if (g_vars.player_hit_monster_counter != 0) {
level_monster_die(obj, m, &g_vars.objects_tbl[1]);
continue;
}
if (!g_vars.player_jump_monster_flag || g_vars.objects_tbl[1].data.p.y_velocity < 0) {
play_sound(9);
m->flags &= ~1;
g_vars.objects_tbl[1].hit_counter = 44;
g_vars.player_anim_0x40_flag = 0;
g_vars.objects_tbl[1].data.p.y_velocity = -128;
g_vars.objects_tbl[1].x_velocity = -(g_vars.objects_tbl[1].x_velocity << 2);
g_vars.player_gravity_flag = 0;
if (g_vars.player_flying_flag != 0) {
g_vars.player_flying_flag = 0;
} else {
if ((g_options.cheats & CHEATS_UNLIMITED_ENERGY) == 0) {
--g_vars.player_energy;
if (g_vars.player_energy < 0) {
level_player_die();
}
}
}
return;
}
if (!g_vars.player_gravity_flag) {
/* jumping on a monster */
play_sound(3);
int num = obj->data.m.hit_jump_counter >> 2;
if (num != 11) {
obj->data.m.hit_jump_counter += 4;
++num;
if ((num & 1) == 0) {
static const uint16_t data[] = { 0xFF46, 0xE0, 0xE1, 0x12D, 0x12E, 0x12F };
level_add_object75_score(obj_player, (int16_t)data[num >> 1]);
}
}
g_vars.objects_tbl[1].data.p.y_velocity = (g_vars.input.key_up != 0) ? -224 : -64;
g_vars.player_jumping_counter = 0;
g_vars.objects_tbl[1].y_pos -= g_vars.monster.collide_y_dist;
} else if (g_vars.objects_tbl[1].data.p.y_velocity <= 32) {
g_vars.objects_tbl[1].data.p.y_velocity = -96;
g_vars.player_jumping_counter = 0;
g_vars.objects_tbl[1].y_pos -= g_vars.monster.collide_y_dist;
} else {
int num = (obj->data.m.hit_jump_counter) & 3;
level_add_object75_score(obj_player, 82 + (num << 1));
obj->spr_num |= 0x4000;
if (num == 2) {
obj->data.m.state = 0xFF;
level_monster_update_anim(obj);
m->flags &= ~8;
obj->data.m.y_velocity = -200;
int delta = abs(g_vars.objects_tbl[1].data.p.y_velocity);
if (obj->x_pos <= g_vars.objects_tbl[1].x_pos) {
delta = -delta;
}
obj->data.m.x_velocity = delta * 3;
} else {
++obj->data.m.hit_jump_counter;
g_vars.objects_tbl[1].data.p.y_velocity = -96;
g_vars.player_jumping_counter = 0;
g_vars.objects_tbl[1].y_pos -= g_vars.monster.collide_y_dist;
}
}
return;
}
}
/* bonuses */
for (int i = 0; i < 52; ++i) {
struct object_t *obj = &g_vars.objects_tbl[23 + i];
if (obj->spr_num == 0xFFFF || (obj->spr_num & 0x2000) == 0) {
continue;
}
if (obj->data.t.counter > 188) {
continue;
}
if (!level_objects_collide(obj, obj_player)) {
continue;
}
g_vars.current_bonus.spr_num = obj->spr_num;
const int num = (obj->spr_num & 0x1FFF) - 53;
obj->spr_num = 0xFFFF;
if (num == 226) {
if (g_vars.level_num == 2) {
g_vars.level_num = 12;
} else if (g_vars.level_num == 13) {
g_vars.level_num = 2;
} else if (g_vars.level_num == 6) {
g_vars.level_num = 14;
} else if (g_vars.level_num == 15) {
g_vars.level_num = 6;
}
g_vars.level_completed_flag = 1;
return;
} else if (num == 258) {
g_vars.level_completed_flag = 0xFF; /* game completed */
return;
} else if (num == 228) { /* checkpoint */
g_vars.tilemap_start_x_pos = g_vars.objects_tbl[1].x_pos;
g_vars.tilemap_start_y_pos = g_vars.objects_tbl[1].y_pos;
for (int i = 0; i < MAX_LEVEL_ITEMS; ++i) {
struct level_item_t *item = &g_res.level.items_tbl[i];
if (item->spr_num == 280) {
++item->spr_num;
}
}
struct level_item_t *item = obj->data.t.ref;
if (item) {
assert(item >= &g_res.level.items_tbl[0] && item < &g_res.level.items_tbl[MAX_LEVEL_ITEMS]);
item->spr_num -= 1;
}
} else if (num == 174) {
++g_vars.player_lifes;
play_sound(4);
level_add_object75_score(&g_vars.objects_tbl[1], 227);
level_clear_item(obj);
} else if (num == 13) {
play_sound(8);
g_vars.player_club_type = 0;
level_clear_item(obj);
} else if (num == 182) {
play_sound(8);
g_vars.player_club_type = 1;
level_clear_item(obj);
} else if (num == 44) {
play_sound(8);
g_vars.player_club_type = 2;
level_clear_item(obj);
} else if (num == 224) {
play_sound(8);
g_vars.player_club_type = 3;
level_clear_item(obj);
} else if (num <= 20) {
play_sound(8);
level_clear_item(obj);
++g_vars.bonus_energy_counter;
if (g_vars.bonus_energy_counter >= 6) {
if (g_vars.player_energy != 3) {
++g_vars.player_energy;
g_vars.bonus_energy_counter = 0;
level_add_object75_score(obj, 226);
}
}
} else if (num <= 44) {
play_sound(8);
const int index = num - 39;
if (index >= 0 && index <= 4) {
g_vars.player_bonus_letters_mask |= (1 << index);
level_clear_item(obj);
}
} else if (num <= 50) {
play_sound(8);
g_vars.player_utensils_mask |= 1 << (num - 45);
for (int j = 0; j < MAX_LEVEL_ITEMS; ++j) {
struct level_item_t *item = &g_res.level.items_tbl[j];
if (item->spr_num == 278) { /* end of level semaphore */
++item->spr_num;
}
}
level_clear_item(obj);
} else if (num <= 64) { /* food */
play_sound(4);
if (obj->data.t.y_velocity >= 128) {
obj->data.t.y_velocity = -obj->data.t.y_velocity;
int x = 32;
if ((random_get_number() & 1) != 0) {
x = -x;
g_vars.shake_screen_counter = 7;
}
obj->x_velocity = x;
obj->spr_num = g_vars.current_bonus.spr_num;
} else {
const int index = num - 57;
++g_vars.level_items_count_tbl[index];
++g_vars.level_items_total_count;
level_add_object75_score(obj, score_spr_lut[index] + 74);
if (obj->data.t.ref) {
++g_vars.level_complete_bonuses_count;
}
}
} else if (num <= 74) {
play_sound(8);
if (g_vars.player_flying_flag == 0) {
g_vars.player_flying_flag = 1;
g_vars.objects_tbl[1].data.p.current_anim_num = 0xFF;
level_clear_item(obj);
}
} else if (num <= 166) {
play_sound(8);
if (num == 145) { /* tap */
for (int i = 0; i < 20; ++i) {
g_vars.fly_tbl[i].x_pos = _undefined;
}
}
const int index = num - 57;
++g_vars.level_items_count_tbl[index];
++g_vars.level_items_total_count;
level_add_object75_score(obj, score_spr_lut[index] + 74);
} else if (num == 167 || num == 168) {
play_sound(1);
g_vars.objects_tbl[1].hit_counter = 44;
g_vars.objects_tbl[1].data.p.special_anim_num = 0;
g_vars.objects_tbl[1].data.p.current_anim_num = 8;
level_add_object23_bones();
g_vars.shake_screen_counter = 7;
level_clear_item(obj);
level_add_object75_score(obj, 228);
} else if (num == 173) {
play_sound(4);
if (g_vars.player_energy < 3) {
++g_vars.player_energy;
level_clear_item(obj);
}
} else if (num == 169) {
play_sound(0);
for (int i = 0; i < MONSTERS_COUNT; ++i) {
struct object_t *obj = &g_vars.objects_tbl[11 + i];
if (obj->spr_num == 0xFFFF) {
continue;
}
struct level_monster_t *m = obj->data.m.ref;
if (m->flags & 0x10) {
continue;
}
if ((obj->spr_num & 0x2000) == 0) {
continue;
}
level_monster_die(obj, m, obj_player);
}
g_vars.shake_screen_counter = 9;
level_clear_item(obj);
level_add_object75_score(obj, 230);
} else if (num == 170) { /* bomb */
play_sound(0);
for (int i = 0; i < MONSTERS_COUNT; ++i) {
struct object_t *obj = &g_vars.objects_tbl[11 + i];
if (obj->spr_num == 0xFFFF) {
continue;
}
struct level_monster_t *m = obj->data.m.ref;
if (m->flags & 0x10) {
continue;
}
if ((obj->spr_num & 0x2000) == 0) {
continue;
}
g_vars.current_bonus.x_pos = obj->x_pos;
g_vars.current_bonus.y_pos = obj->y_pos;
obj->data.m.state = 0xFF;
obj->spr_num = 0xFFFF;
level_add_bonuses_4x();
}
level_clear_item(obj);
} else if (num == 181) { /* light off */
if (g_vars.light.state != 1) {
play_sound(1);
g_vars.light.palette_flag2 = 0;
g_vars.light.palette_flag1 = 1;
g_vars.light.palette_counter = 0;
g_vars.light.state = 1;
}
level_clear_item(obj);
} else if (num == 180) { /* light on */
if (g_vars.light.state != 0) {
g_vars.light.palette_flag1 = 0;
g_vars.light.palette_flag2 = 1;
g_vars.light.palette_counter = 0;
g_vars.light.state = 0;
}
level_clear_item(obj);
} else if (num == 458 || num == 459) { /* boss projectiles */
if (g_options.cheats & CHEATS_UNLIMITED_ENERGY) {
continue;
}
if (g_vars.player_energy < 1) {
level_player_die();
} else {
play_sound(1);
g_vars.objects_tbl[1].hit_counter = 44;
g_vars.objects_tbl[1].data.p.special_anim_num = 0;
g_vars.objects_tbl[1].data.p.current_anim_num = 8;
--g_vars.player_energy;
const uint8_t energy = g_vars.player_energy;
g_vars.player_energy = 1;
level_add_object23_bones();
g_vars.player_energy = energy;
}
}
}
}
static void level_update_objects_items() {
struct object_t *obj = &g_vars.objects_tbl[55];
int count = 20;
for (int i = 0; i < MAX_LEVEL_ITEMS; ++i) {
struct level_item_t *level_item = &g_res.level.items_tbl[i];
if (level_item->spr_num == 0xFFFF) {
continue;
}
const int16_t x = (level_item->x_pos >> 4) - g_vars.tilemap.x;
if (x < 0 || x > 22) {
continue;
}
const int16_t y = (level_item->y_pos >> 4) - g_vars.tilemap.y;
if (y < 0 || y > 43) {
continue;
}
obj->x_pos = level_item->x_pos;
int16_t dy_pos = 0;
if (g_vars.level_draw_counter & 1) {
dy_pos = level_item->y_delta + 1;
level_item->y_delta = dy_pos;
if (dy_pos >= 4) {
dy_pos = 1 - dy_pos;
level_item->y_delta = dy_pos;
}
}
level_item->y_pos += dy_pos;
obj->y_pos = level_item->y_pos;
obj->spr_num = level_item->spr_num;
obj->data.t.ref = level_item;
++obj;
if (--count == 0) {
return;
}
}
do {
obj->spr_num = 0xFFFF;
++obj;
} while (--count != 0);
}
static void level_update_gates() {
if (g_vars.player_action_counter == 0) {
return;
}
if (g_vars.player_flying_flag != 0) {
return;
}
uint16_t pos = level_get_player_tile_pos();
for (int i = 0; i < MAX_LEVEL_GATES; ++i) {
struct level_gate_t *gate = &g_res.level.gates_tbl[i];
if (gate->enter_pos == pos) {
g_vars.objects_tbl[1].x_velocity = 0;
g_vars.objects_tbl[1].data.p.y_velocity = 0;
video_transition_close();
g_vars.tilemap.scroll_dy = 0;
const uint8_t tmp = g_res.level.tilemap_w;
g_res.level.tilemap_w = 256 - 20;
const uint16_t dst_pos = gate->dst_pos;
g_vars.objects_tbl[1].x_pos = (dst_pos & 255) << 4;
g_vars.objects_tbl[1].y_pos = (dst_pos >> 8) << 4;
const uint8_t tilemap_y = gate->tilemap_pos >> 8;
while (g_vars.tilemap.y != tilemap_y) {
if (g_vars.tilemap.y > tilemap_y) {
level_adjust_vscroll_up(16);
} else {
level_adjust_vscroll_down(16);
}
}
const uint8_t tilemap_x = gate->tilemap_pos & 255;
while (g_vars.tilemap.x != tilemap_x) {
if (g_vars.tilemap.x > tilemap_x) {
level_adjust_hscroll_left();
} else {
level_adjust_hscroll_right();
}
}
g_res.level.tilemap_w = tmp;
g_vars.tilemap_noscroll_flag = gate->scroll_flag;
g_vars.player_action_counter = 0;
if (g_vars.level_num == 5) {
/* exit to boss (tree) */
g_res.level.scrolling_mask &= 1;
g_vars.boss_level5.unk1 = 0;
g_vars.boss_level5.energy = 10;
g_vars.boss_level5.state = 0;
g_vars.boss_level5.spr103_pos = 0;
g_vars.boss_level5.spr106_pos = 1;
g_vars.boss_level5.unk6 = 0;
g_vars.boss_level5.tick_counter = 110;
g_vars.boss_level5.idle_counter = 8;
memset(&g_vars.objects_tbl[91], 0xFF, sizeof(struct object_t) * 6);
}
level_draw_tilemap();
level_update_objects_decors();
level_update_objects_items();
level_update_objects_monsters();
video_transition_open();
break;
}
}
}
static void level_update_columns() {
const uint16_t player_pos = level_get_player_tile_pos();
for (int i = 0; i < MAX_LEVEL_COLUMNS; ++i) {
struct level_column_t *column = &g_res.level.columns_tbl[i];
uint16_t pos = column->trigger_pos;
if (pos == 0xFFFF) {
continue;
}
if (pos != 0xFFFE) {
const int x = -(pos - player_pos);
if (x <= 8) {
column->trigger_pos = 0xFFFE;
g_vars.shake_screen_counter = 7;
}
continue;
}
g_vars.shake_screen_counter = 7;
if ((g_vars.level_draw_counter & 3) != 0) {
continue;
}
/* scroll the column up */
pos = column->tilemap_pos - 0x100;
for (int y = 0; y < column->h; ++y) {
for (int x = 0; x < column->w; ++x) {
g_res.leveldat[pos + x] = g_res.leveldat[pos + 0x100 + x];
}
pos += 0x100;
}
column->tilemap_pos -= 0x100;
const uint16_t offset = column->tiles_offset_buf;
for (int x = 0; x < column->w; ++x) {
g_res.leveldat[pos + x] = g_vars.columns_tiles_buf[offset + x];
}
column->tiles_offset_buf -= column->w;
--column->y_target;
if (column->y_target == 0) {
column->trigger_pos = 0xFFFF;
}
}
}
static void level_draw_front_tile(uint8_t tile_num, int x, int y) {
const int num = g_res.level.front_tiles_lut[tile_num];
assert(num < (g_res.frontlen / 128));
g_sys.render_add_sprite(RENDER_SPR_FG, num, x * 16 - g_vars.tilemap.scroll_dx, y * 16 - g_vars.tilemap.scroll_dy, 0);
}
static void level_draw_front_tiles() {
if ((g_vars.tile_attr2_flags & 0x40) == 0) { /* no front tiles */
return;
}
uint16_t offset = (g_vars.tilemap.y << 8) | g_vars.tilemap.x;
for (int y = 0; y < (TILEMAP_SCREEN_H / 16) + 1; ++y) {
for (int x = 0; x < (TILEMAP_SCREEN_W / 16) + 1; ++x) {
const uint8_t tile_num = level_get_tile(offset + x);
if (g_res.level.tile_attributes2[tile_num] & 0x40) {
level_draw_front_tile(tile_num, x, y);
}
}
offset += 256;
}
}
static void level_clear_items_spr_num_tbl() {
memset(g_vars.level_items_count_tbl, 0, sizeof(g_vars.level_items_count_tbl));
g_vars.level_items_total_count = 0;
}
static bool level_update_objects_anim() {
if (g_vars.level_completed_flag == 1) {
if (g_vars.level_num < 10) {
level_completed_bonuses_animation();
}
++g_vars.level_num;
level_reset();
return false;
} else if (g_vars.level_completed_flag & 0x80) {
if (g_vars.level_num < 10) {
g_vars.level_num = next_level_tbl[g_vars.level_num];
} else {
int num = 0;
while (next_level_tbl[num] != g_vars.level_num) {
++num;
}
g_vars.level_num = num;
if (num < 10) {
level_completed_bonuses_animation();
} else {
++g_vars.level_num;
}
}
level_reset();
return false;
} else if (g_vars.restart_level_flag == 1) {
level_player_death_animation();
if (g_vars.player_death_flag == 0) {
uint16_t spr_num_tbl[MAX_LEVEL_ITEMS];
for (int i = 0; i < MAX_LEVEL_ITEMS; ++i) {
spr_num_tbl[i] = g_res.level.items_tbl[i].spr_num;
}
for (int i = 0; i < MAX_LEVEL_BONUSES; ++i) {
g_vars.level_bonuses_count_tbl[i] = (g_res.level.bonuses_tbl[i].pos != 0xFFFF) ? 1 : 0;
}
level_reset();
g_vars.objects_tbl[1].x_pos = g_vars.tilemap_start_x_pos;
g_vars.objects_tbl[1].y_pos = g_vars.tilemap_start_y_pos;
level_init_tilemap();
for (int i = 0; i < MAX_LEVEL_ITEMS; ++i) {
const uint16_t spr_num = spr_num_tbl[i];
const uint16_t num = spr_num - 53;
if (num == 13 || num == 44 || num == 65 || num == 169 || num == 170 || num == 182 || num == 224) {
continue;
}
g_res.level.items_tbl[i].spr_num = spr_num;
}
for (int i = 0; i < MAX_LEVEL_BONUSES; ++i) {
if (g_vars.level_bonuses_count_tbl[i] == 0) {
g_res.level.bonuses_tbl[i].pos = 0xFFFF;
}
}
level_clear_items_spr_num_tbl();
return true;
}
} else if (g_vars.player_death_flag == 1) {
level_player_death_animation();
} else if (g_vars.player_death_flag == 0xFF) {
do_theend_screen();
return false;
} else {
return true;
}
input_check_ctrl_alt_e();
play_music(17);
g_vars.objects_tbl[1].spr_num = 13;
g_vars.level_num = 0;
g_vars.score = 0;
g_vars.score_extra_life = 0;
level_clear_items_spr_num_tbl();
return false;
}
static void level_clear_panel() {
g_vars.panel.score = 0xFFFFFFFF;
g_vars.panel.lifes = 0xFF;
g_vars.panel.energy = 0xFF;
g_vars.panel.bonus_letters_mask = 0xFF;
const uint8_t *src = g_res.allfonts + 41 * 48;
video_draw_panel(src);
}
static void level_draw_panel() {
const uint8_t *src = g_res.allfonts + 41 * 48;
video_draw_panel(src);
if (g_vars.player_lifes != g_vars.panel.lifes || _redraw_panel) {
g_vars.panel.lifes = g_vars.player_lifes;
video_draw_panel_number(0x1CED, MIN(g_vars.panel.lifes, 9));
}
if (g_vars.score != g_vars.panel.score || _redraw_panel) {
g_vars.panel.score = g_vars.score;
const int score_digits = _score_8_digits ? 8 : 7;
const int offset = _score_8_digits ? 0x1CF0 : 0x1CF1;
int score = g_vars.score * 10;
for (int i = 0; i < score_digits; ++i) {
const int digit = score % 10;
score /= 10;
video_draw_panel_number(offset + (score_digits - 1 - i) * 16 / 8, digit);
}
}
if (g_vars.player_energy != g_vars.panel.energy || _redraw_panel) {
g_vars.panel.energy = g_vars.player_energy;
for (int i = 0; i < g_vars.player_energy; ++i) {
video_draw_panel_number(0x1D01 + i * 16 / 8, 10);
}
if (g_vars.player_energy > 3) {
video_draw_panel_number(0x1D01 + 3 * 16 / 8, 11);
}
}
uint8_t mask;
if (g_vars.player_bonus_letters_blinking_counter != 0) {
g_vars.panel.bonus_letters_mask = 0xFF;
mask = 0x1F;
if ((g_vars.level_draw_counter & 1) == 0) {
mask = 0;
}
} else {
mask = g_vars.player_bonus_letters_mask;
if (g_vars.player_bonus_letters_mask != g_vars.panel.bonus_letters_mask) {
g_vars.panel.bonus_letters_mask = g_vars.player_bonus_letters_mask;
}
}
static const uint16_t panel_bonus_letters_pos_tbl[] = { 0x1C91, 0x1BF2, 0x1CE3, 0x1C6C, 0x1C1D };
for (int i = 0; i < 5; ++i) {
if ((mask & (1 << i)) != 0) {
video_draw_panel_number(panel_bonus_letters_pos_tbl[i], 12 + i);
}
}
}
static void level_update_panel() {
const int count = (g_vars.score / 25000) - g_vars.score_extra_life;
if (count != 0) {
g_vars.score_extra_life += count;
g_vars.player_lifes += count;
level_add_object75_score(&g_vars.objects_tbl[1], 227);
}
level_draw_panel();
}
static void level_update_light_palette() {
if ((g_vars.light.palette_flag1 | g_vars.light.palette_flag2) != 0) {
++g_vars.light.palette_counter;
uint8_t palette[16 * 3];
const uint8_t *src_pal = palettes_tbl[g_vars.level_num];
const uint8_t *dst_pal = light_palette_data;
bool changed = false;
if (g_vars.light.palette_flag2 != 0) {
SWAP(src_pal, dst_pal);
}
for (int i = 0; i < 16 * 3; ++i) {
int diff = src_pal[i] - dst_pal[i];
int step = g_vars.light.palette_counter;
if (diff < 0) {
diff = -diff;
step = -step;
}
if (diff <= g_vars.light.palette_counter) {
palette[i] = dst_pal[i];
} else {
palette[i] = src_pal[i] - step;
changed = true;
}
}
if (!changed) {
g_vars.light.palette_flag1 = 0;
g_vars.light.palette_flag2 = 0;
}
g_sys.set_screen_palette(palette, 0, 16, 6);
}
}
static void level_sync() {
update_input();
g_sys.update_screen(g_res.vga, 1);
g_sys.render_clear_sprites();
const int diff = (g_vars.timestamp + (1000 / 30)) - g_sys.get_timestamp();
g_sys.sleep(MAX(diff, 10));
g_vars.timestamp = g_sys.get_timestamp();
}
static void level_draw_objects() {
++g_vars.level_draw_counter;
for (int i = OBJECTS_COUNT - 1; i >= 0; --i) {
struct object_t *obj = &g_vars.objects_tbl[i];
if (obj->spr_num == 0xFFFF) {
continue;
}
if (obj->hit_counter != 0) {
--obj->hit_counter;
}
if (obj->hit_counter != 0 && (g_vars.level_draw_counter & 3) != 0) {
continue;
}
const int spr_num = obj->spr_num & 0x1FFF;
const bool spr_hflip = (obj->spr_num & 0x8000) != 0;
int spr_y_pos = obj->y_pos - ((g_vars.tilemap.y << 4) + g_vars.tilemap.scroll_dy);
int spr_h = spr_size_tbl[2 * spr_num + 1];
spr_y_pos -= spr_h;
if (spr_y_pos > TILEMAP_SCREEN_H || spr_y_pos + spr_h < 0) {
continue;
}
int spr_x_pos = obj->x_pos - ((g_vars.tilemap.x << 4) + g_vars.tilemap.scroll_dx);
int spr_w = spr_offs_tbl[2 * spr_num];
if (spr_hflip) {
spr_w = spr_size_tbl[2 * spr_num] - spr_w;
}
spr_x_pos -= spr_w;
if (spr_x_pos > TILEMAP_SCREEN_W || spr_x_pos + spr_w < 0) {
continue;
}
video_draw_sprite(spr_num, spr_x_pos, spr_y_pos, spr_hflip);
obj->spr_num |= 0x2000;
obj->spr_num &= ~0x4000;
}
}
static void level_draw_orbs() {
for (int i = 0; i < 20; ++i) {
struct orb_t *p = &g_vars.orb_tbl[i];
if (p->x_pos == 0xFFFF) {
continue;
}
const int rx = ((int8_t)cos_tbl[p->index_tbl]) >> 2;
p->x_pos += (rx * p->radius) >> 4;
const int ry = ((int8_t)sin_tbl[p->index_tbl]) >> 2;
p->y_pos += (ry * p->radius) >> 4;
const int y_pos = p->y_pos - g_vars.tilemap.scroll_dy - (g_vars.tilemap.y << 4);
if (y_pos >= 0 && y_pos < TILEMAP_SCREEN_H) {
const int x_pos = p->x_pos - g_vars.tilemap.scroll_dx - (g_vars.tilemap.x << 4);
if (x_pos >= 0 && x_pos < TILEMAP_SCREEN_W) {
video_put_pixel(x_pos, y_pos, 15);
}
}
p->x_pos = 0xFFFF;
}
}
static void level_draw_flies() {
for (int i = 0; i < 20; ++i) {
struct fly_t *p = &g_vars.fly_tbl[i];
if (p->x_pos == _undefined) {
continue;
}
--p->unk6;
if (p->unk6 & 0x80) {
p->unk6 = (random_get_number2() & 7) + 3;
}
int x_vel = random_get_number() & 15;
if (g_vars.objects_tbl[1].x_pos < (p->x_pos >> 3)) {
x_vel = -x_vel;
}
if (p->unk7 & 7) {
x_vel = -x_vel;
}
int y_vel = random_get_number() & 15;
if (g_vars.objects_tbl[1].y_pos < (p->y_pos >> 3)) {
y_vel = -y_vel;
}
if (p->unk7 & 7) {
y_vel = -y_vel;
}
p->x_delta = random_get_number2() & 31;
if (x_vel < 0) {
p->x_delta = -p->x_delta;
}
if (x_vel == 0) {
p->y_delta = 2;
} else {
p->y_delta = MIN((abs(y_vel) << 3) / abs(x_vel), 32);
}
if (y_vel < 0) {
p->y_delta = -p->y_delta;
}
if (p->unk7 & 7) {
--p->unk7;
}
p->x_pos += p->x_delta;
p->y_pos += p->y_delta;
if (p->unk6) {
} else {
}
const int x_pos = (p->x_pos >> 3) - ((g_vars.tilemap.x << 4) + g_vars.tilemap.scroll_dx);
if (x_pos < 0 || x_pos >= TILEMAP_SCREEN_W) {
continue;
}
const int y_pos = (p->y_pos >> 3) - ((g_vars.tilemap.y << 4) + g_vars.tilemap.scroll_dy);
if (y_pos < 0 || y_pos >= TILEMAP_SCREEN_H) {
continue;
}
video_put_pixel(x_pos, y_pos, 15);
}
}
static void level_draw_snow() {
++g_vars.snow.counter;
if ((g_vars.level_draw_counter & 3) == 0) {
const uint16_t *p = g_vars.snow.pattern;
if (p[0] != 0xFFFF) {
if (p[0] < g_vars.snow.counter) {
g_vars.snow.value += p[1];
if (p[3] < g_vars.snow.counter) {
g_vars.snow.counter += 3;
}
}
g_vars.snow.value = MIN(g_vars.snow.value, p[2]);
}
}
if (g_vars.snow.value == 0) {
return;
}
const int half = g_vars.snow.value >> 1;
uint16_t *p = g_vars.snow.random_tbl;
for (int i = 0; i < g_vars.snow.value; ++i) {
p[i] += 79;
uint8_t al = p[i];
uint8_t cl = ((al << 1) | (al >> 7)) & 3;
uint16_t pos = (p[i] - g_vars.tilemap.x) & 0x1FFF;
if (pos >= 7000) {
pos -= 7000;
p[i] = pos;
}
const int y_pos = (pos / 40);
const int x_pos = (pos % 40) * 8 + cl * 2;
video_put_pixel(x_pos, y_pos, 15);
if ((g_vars.snow.value - i) > half) {
video_put_pixel(x_pos, y_pos + 1, 15);
}
}
const uint8_t num = random_get_number();
const uint8_t hi = random_get_number();
const uint8_t lo = random_get_number();
g_vars.snow.random_tbl[num] = (hi << 8) | lo;
}
static void level_update_player_bonuses() {
if (g_vars.player_bonus_letters_mask == 0x1F) { /* found the 5 bonuses */
g_vars.current_bonus.x_pos = g_vars.objects_tbl[1].x_pos;
g_vars.current_bonus.y_pos = g_vars.objects_tbl[1].y_pos - 112;
g_vars.current_bonus.spr_num = 110;
level_add_object23_bonus(0, 0, 1);
g_vars.player_bonus_letters_mask = 0;
g_vars.player_bonus_letters_blinking_counter = 44; /* blink the letters in the panel */
} else if ((g_vars.player_utensils_mask & 0x38) == 0x38) {
g_vars.player_utensils_mask &= ~0x38;
g_vars.player_hit_monster_counter = 660;
}
}
static void level_shake_screen() {
if (g_vars.shake_screen_counter < 1) {
return;
} else if (g_vars.shake_screen_counter == 1) {
g_vars.shake_screen_voffset = 0;
} else if ((g_vars.level_draw_counter & 1) == 0) {
g_vars.shake_screen_voffset = 0;
} else {
if (g_vars.objects_tbl[1].data.p.current_anim_num != 5 && g_vars.objects_tbl[1].data.p.current_anim_num != 32) {
g_vars.objects_tbl[1].y_pos -= 12;
}
++g_vars.shake_screen_counter;
g_vars.shake_screen_voffset = g_vars.shake_screen_counter;
}
}
static void level_player_death_animation() {
play_sound(7);
g_vars.objects_tbl[1].hit_counter = 0;
g_vars.objects_tbl[1].spr_num = 33;
g_vars.objects_tbl[1].data.p.y_velocity = 15;
g_vars.objects_tbl[1].x_velocity = (g_vars.objects_tbl[1].x_pos < ((g_vars.tilemap.x + 10) << 4)) ? 5 : -5;
for (int i = 0; i < 60; ++i) {
g_vars.objects_tbl[0].spr_num = 0xFFFF;
level_update_objects_hit_animation();
level_update_objects_monsters();
level_update_objects_club_projectiles();
level_update_objects_bonuses();
level_update_objects_bonus_scores();
level_update_tilemap();
level_draw_tilemap();
level_draw_panel();
level_draw_orbs();
level_draw_objects();
level_draw_front_tiles();
level_draw_flies();
level_draw_snow();
level_sync();
g_vars.objects_tbl[1].x_pos += g_vars.objects_tbl[1].x_velocity;
const int y_velocity = MAX(g_vars.objects_tbl[1].data.p.y_velocity - 1, -16);
g_vars.objects_tbl[1].y_pos -= y_velocity;
g_vars.objects_tbl[1].data.p.y_velocity = y_velocity;
}
video_transition_close();
}
static void level_completed_bonuses_animation_draw_score() {
const int score_digits = _score_8_digits ? 8 : 7;
video_draw_string2(0x230, "SCORE");
int score = g_vars.score * 10;
for (int i = 0; i < score_digits; ++i) {
const int digit = score % 10;
score /= 10;
video_draw_number(0x23C + (score_digits - 1 - i) * 16 / 8, digit);
}
if (g_res.dos_demo) {
return;
}
video_draw_string2(0x410, "LEVEL COMPLETED");
int percentage = 100;
const int total = g_vars.level_complete_secrets_count + g_vars.level_complete_bonuses_count;
if (total != 0) {
const int current = g_vars.level_current_secrets_count + g_vars.level_current_bonuses_count;
percentage = (current * 100) / total;
}
for (int i = 0; i < 3; ++i) {
const int digit = percentage % 10;
percentage /= 10;
video_draw_number(0x430 + (2 - i) * 16 / 8, digit);
if (percentage == 0) {
break;
}
}
video_draw_character_spr(0x436, 0x1A);
}
static void level_completed_bonuses_animation_fixup_object4_spr_num() {
if (g_vars.level_draw_counter & 3) {
return;
}
int spr_num = (g_vars.objects_tbl[4].spr_num & 0x1FFF) + 1;
if (spr_num >= 110) {
spr_num = 104;
}
g_vars.objects_tbl[4].spr_num = spr_num;
}
static int level_completed_bonuses_animation_helper() {
int bp = 0;
do {
level_update_object_anim(g_vars.objects_tbl[1].data.p.anim);
video_clear();
level_completed_bonuses_animation_fixup_object4_spr_num();
level_draw_objects();
level_completed_bonuses_animation_draw_score();
level_sync();
for (int i = 0; i < 20; ++i) {
struct object_t *obj = &g_vars.objects_tbl[55 + i];
if (obj->spr_num == 0xFFFF) {
continue;
}
int y_velocity = obj->data.t.y_velocity;
if (y_velocity < 128) {
y_velocity += 8;
obj->data.t.y_velocity = y_velocity;
}
obj->y_pos += y_velocity >> 4;
++bp;
if (obj->y_pos >= 145) {
const int spr_num = obj->spr_num & 0x1FFF;
g_vars.score += score_tbl[score_spr_lut[spr_num - 110]];
obj->spr_num = 0xFFFF;
play_sound(8);
}
}
} while ((g_vars.level_draw_counter & 7) != 0);
return bp;
}
static void level_completed_bonuses_animation() {
if (g_vars.light.state != 0) {
g_vars.light.palette_flag1 = 0;
g_vars.light.palette_flag2 = 1;
g_vars.light.palette_counter = 0;
}
play_music(15);
g_vars.objects_tbl[1].y_pos -= g_vars.tilemap.y << 4;
g_vars.objects_tbl[1].x_pos -= g_vars.tilemap.x << 4;
g_vars.tilemap.y = 0;
g_vars.tilemap.x = 0;
g_vars.objects_tbl[1].data.p.hdir = 0;
g_vars.objects_tbl[1].x_velocity = 0;
level_completed_bonuses_animation_draw_score();
g_vars.player_flying_flag = 0;
g_vars.objects_tbl[1].data.p.anim = object_anim_tbl[1];
while (1) {
level_update_object_anim(g_vars.objects_tbl[1].data.p.anim);
bool flag = false;
int x_pos = 60;
int x_offs = 2;
const int dx = g_vars.objects_tbl[1].x_pos - x_pos;
if (dx < 0) {
x_offs = -x_offs;
}
if (dx >= 2) {
x_pos = g_vars.objects_tbl[1].x_pos - x_offs;
flag = true;
}
g_vars.objects_tbl[1].x_pos = x_pos;
int y_pos = 175;
int y_offs = 2;
const int dy = g_vars.objects_tbl[1].y_pos - y_pos;
if (dy < 0) {
y_offs = -y_offs;
}
if (dy >= 2) {
y_pos = g_vars.objects_tbl[1].y_pos - y_offs;
flag = true;
}
g_vars.objects_tbl[1].y_pos = y_pos;
video_clear();
level_completed_bonuses_animation_draw_score();
level_draw_objects();
level_sync();
if (g_sys.input.quit) {
return;
}
if (!flag) {
break;
}
}
g_vars.objects_tbl[2].x_pos = 360;
g_vars.objects_tbl[2].y_pos = 175;
g_vars.objects_tbl[2].spr_num = 100;
g_vars.objects_tbl[3].x_pos = 360;
g_vars.objects_tbl[3].y_pos = 148;
g_vars.objects_tbl[3].spr_num = 98;
g_vars.objects_tbl[4].x_pos = 360;
g_vars.objects_tbl[4].y_pos = 155;
g_vars.objects_tbl[4].spr_num = 104;
do {
level_update_object_anim(g_vars.objects_tbl[1].data.p.anim);
video_clear();
level_completed_bonuses_animation_fixup_object4_spr_num();
level_completed_bonuses_animation_draw_score();
level_draw_objects();
level_sync();
if (g_sys.input.quit) {
return;
}
g_vars.objects_tbl[2].x_pos -= 3;
g_vars.objects_tbl[3].x_pos -= 3;
g_vars.objects_tbl[4].x_pos -= 3;
} while (g_vars.objects_tbl[2].x_pos > 155);
if (g_vars.level_items_total_count != 0) {
g_vars.objects_tbl[1].data.p.anim = object_anim_tbl[18];
g_vars.objects_tbl[1].x_velocity = 64;
g_vars.objects_tbl[1].x_friction = 2;
while (1) {
level_update_object_anim(g_vars.objects_tbl[1].data.p.anim);
video_clear();
level_completed_bonuses_animation_fixup_object4_spr_num();
level_completed_bonuses_animation_draw_score();
level_draw_objects();
level_sync();
if (g_sys.input.quit) {
return;
}
level_update_player_x_velocity();
const int x_velocity = g_vars.objects_tbl[1].x_velocity >> 4;
g_vars.objects_tbl[1].x_pos += x_velocity;
if (x_velocity == 0) {
break;
}
}
g_vars.objects_tbl[1].data.p.anim = object_anim_tbl[17];
uint16_t di = 0;
uint16_t bp = level_completed_bonuses_animation_helper();
uint8_t al = 0;
while (!g_sys.input.quit) {
if (di >= 113) {
di = 0;
}
if (g_vars.level_items_count_tbl[di] != 0) {
for (int i = 0; i < 20; ++i) {
struct object_t *obj = &g_vars.objects_tbl[55 + i];
if (obj->spr_num == 0xFFFF) {
obj->spr_num = 110 + di;
obj->x_pos = 155;
obj->y_pos = 0;
obj->data.t.y_velocity = 0;
--g_vars.level_items_count_tbl[di];
++di;
break;
}
}
bp = level_completed_bonuses_animation_helper();
al = 0;
continue;
}
++al;
if (al < 113) {
++di;
} else {
if (bp == 0) {
break;
}
bp = level_completed_bonuses_animation_helper();
al = 0;
}
}
}
g_vars.objects_tbl[1].data.p.anim = object_anim_tbl[1];
do {
level_update_object_anim(g_vars.objects_tbl[1].data.p.anim);
video_clear();
level_completed_bonuses_animation_fixup_object4_spr_num();
level_completed_bonuses_animation_draw_score();
level_draw_objects();
level_sync();
if (g_sys.input.quit) {
return;
}
g_vars.objects_tbl[2].x_pos -= 2;
g_vars.objects_tbl[3].x_pos -= 2;
g_vars.objects_tbl[4].x_pos -= 2;
if (g_vars.objects_tbl[4].x_pos < 0) {
g_vars.objects_tbl[1].x_pos += 3;
} else {
g_vars.objects_tbl[1].x_pos += 2;
}
} while (g_vars.objects_tbl[2].x_pos > -52);
}
void do_level() {
static const uint8_t music_tbl[] = { 9, 9, 0, 0, 0, 13, 4, 4, 10, 13, 16, 16, 16, 9, 14, 4 };
play_music(music_tbl[g_vars.level_num]);
load_level_data(g_vars.level_num);
set_level_palette();
video_load_sprites();
video_load_front_tiles();
video_clear();
level_reset();
level_reset_objects();
level_init_tilemap();
level_clear_panel();
level_draw_panel();
level_sync();
g_vars.monster.type10_dist = 0;
g_vars.monster.type0_hdir = 0;
random_reset();
while (!g_sys.input.quit) {
level_update_objects_hit_animation();
level_update_objects_axe();
level_update_objects_monsters();
level_update_objects_club_projectiles();
level_update_objects_bonuses();
level_update_objects_bonus_scores();
level_update_objects_decors();
level_update_player();
level_update_player_collision();
level_update_objects_items();
level_update_gates();
level_update_columns();
g_vars.tilemap_adjust_player_pos_flag = false;
level_update_scrolling();
level_update_tilemap();
level_draw_tilemap();
level_draw_panel();
level_draw_orbs();
level_draw_objects();
level_draw_front_tiles();
level_draw_flies();
level_draw_snow();
if (!level_update_objects_anim()) {
break;
}
level_update_panel();
level_sync();
level_update_light_palette();
level_update_player_bonuses();
level_shake_screen();
}
}