scawful/yaze
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor Overworld blockset types and update related function signatures

Browse Source
This commit is contained in:
scawful
2024-12-31 16:40:01 -05:00
parent 9f67e0c399
commit 6d2de44b94
8 changed files with 86 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/app/editor/graphics/tile16_editor.cc
View File

@@ -51,7 +51,7 @@ using ImGui::Text;
absl::Status Tile16Editor::InitBlockset( absl::Status Tile16Editor::InitBlockset(
const gfx::Bitmap& tile16_blockset_bmp, const gfx::Bitmap& current_gfx_bmp, const gfx::Bitmap& tile16_blockset_bmp, const gfx::Bitmap& current_gfx_bmp,
const std::vector<gfx::Bitmap>& tile16_individual, const std::vector<gfx::Bitmap>& tile16_individual,
uint8_t all_tiles_types[0x200]) { std::array<uint8_t, 0x200>& all_tiles_types) {
all_tiles_types_ = all_tiles_types; all_tiles_types_ = all_tiles_types;
tile16_blockset_bmp_ = tile16_blockset_bmp; tile16_blockset_bmp_ = tile16_blockset_bmp;
tile16_individual_ = tile16_individual; tile16_individual_ = tile16_individual;

4
src/app/editor/graphics/tile16_editor.h
View File

@@ -23,7 +23,7 @@ class Tile16Editor : public gfx::GfxContext, public SharedRom {
absl::Status InitBlockset(const gfx::Bitmap& tile16_blockset_bmp, absl::Status InitBlockset(const gfx::Bitmap& tile16_blockset_bmp,
const gfx::Bitmap& current_gfx_bmp, const gfx::Bitmap& current_gfx_bmp,
const std::vector<gfx::Bitmap>& tile16_individual, const std::vector<gfx::Bitmap>& tile16_individual,
uint8_t all_tiles_types[0x200]); std::array<uint8_t, 0x200>& all_tiles_types);
absl::Status Update(); absl::Status Update();
absl::Status DrawMenu(); absl::Status DrawMenu();
@@ -62,7 +62,7 @@ class Tile16Editor : public gfx::GfxContext, public SharedRom {
bool priority_tile; bool priority_tile;
int tile_size; int tile_size;
uint8_t* all_tiles_types_; std::array<uint8_t, 0x200> all_tiles_types_;
// Tile16 blockset for selecting the tile to edit // Tile16 blockset for selecting the tile to edit
gui::Canvas blockset_canvas_{"blocksetCanvas", ImVec2(0x100, 0x4000), gui::Canvas blockset_canvas_{"blocksetCanvas", ImVec2(0x100, 0x4000),

2
src/app/editor/overworld/overworld_editor.h
View File

@@ -259,7 +259,7 @@ class OverworldEditor : public Editor,
gfx::BitmapTable sprite_previews_; gfx::BitmapTable sprite_previews_;
zelda3::Overworld overworld_; zelda3::Overworld overworld_;
zelda3::OWBlockset refresh_blockset_; zelda3::OverworldBlockset refresh_blockset_;
zelda3::Sprite current_sprite_; zelda3::Sprite current_sprite_;

18
src/app/zelda3/common.h
View File

@@ -1,32 +1,18 @@
#ifndef YAZE_APP_ZELDA3_COMMON_H #ifndef YAZE_APP_ZELDA3_COMMON_H
#define YAZE_APP_ZELDA3_COMMON_H #define YAZE_APP_ZELDA3_COMMON_H
#include <vector>
#include <cstdint> #include <cstdint>
#include <string> #include <string>
#include <string_view>
namespace yaze { namespace yaze {
/** /**
* @namespace yaze::zelda3 * @namespace yaze::zelda3
* @brief Zelda 3 specific classes and functions. * @brief Zelda 3 specific classes and functions.
*/ */
namespace zelda3 { namespace zelda3 {
/**
* @brief Represents tile32 data for the overworld.
*/
using OWBlockset = std::vector<std::vector<uint16_t>>;
/**
* @brief Overworld map tile32 data.
*/
struct OWMapTiles {
OWBlockset light_world; // 64 maps
OWBlockset dark_world; // 64 maps
OWBlockset special_world; // 32 maps
};
using OWMapTiles = struct OWMapTiles;
/** /**
* @class GameEntity * @class GameEntity
* @brief Base class for all overworld and dungeon entities. * @brief Base class for all overworld and dungeon entities.

52
src/app/zelda3/overworld/overworld.cc
View File

@@ -124,18 +124,18 @@ absl::Status Overworld::AssembleMap32Tiles() {
for (int k = 0; k < 4; k++) { for (int k = 0; k < 4; k++) {
// Generate the 16-bit tile for the current quadrant of the current // Generate the 16-bit tile for the current quadrant of the current
// 32x32 pixel tile. // 32x32 pixel tile.
ASSIGN_OR_RETURN(uint16_t tl, ASSIGN_OR_RETURN(
GetTile16ForTile32(i, k, (int)Dimension::map32TilesTL, uint16_t tl,
map32address)); GetTile16ForTile32(i, k, (int)Dimension::map32TilesTL, map32address));
ASSIGN_OR_RETURN(uint16_t tr, ASSIGN_OR_RETURN(
GetTile16ForTile32(i, k, (int)Dimension::map32TilesTR, uint16_t tr,
map32address)); GetTile16ForTile32(i, k, (int)Dimension::map32TilesTR, map32address));
ASSIGN_OR_RETURN(uint16_t bl, ASSIGN_OR_RETURN(
GetTile16ForTile32(i, k, (int)Dimension::map32TilesBL, uint16_t bl,
map32address)); GetTile16ForTile32(i, k, (int)Dimension::map32TilesBL, map32address));
ASSIGN_OR_RETURN(uint16_t br, ASSIGN_OR_RETURN(
GetTile16ForTile32(i, k, (int)Dimension::map32TilesBR, uint16_t br,
map32address)); GetTile16ForTile32(i, k, (int)Dimension::map32TilesBR, map32address));
// Add the generated 16-bit tiles to the tiles32 vector. // Add the generated 16-bit tiles to the tiles32 vector.
tiles32_unique_.emplace_back(gfx::Tile32(tl, tr, bl, br)); tiles32_unique_.emplace_back(gfx::Tile32(tl, tr, bl, br));
@@ -177,7 +177,7 @@ void Overworld::AssembleMap16Tiles() {
} }
void Overworld::AssignWorldTiles(int x, int y, int sx, int sy, int tpos, void Overworld::AssignWorldTiles(int x, int y, int sx, int sy, int tpos,
OWBlockset &world) { OverworldBlockset &world) {
int position_x1 = (x * 2) + (sx * 32); int position_x1 = (x * 2) + (sx * 32);
int position_y1 = (y * 2) + (sy * 32); int position_y1 = (y * 2) + (sy * 32);
int position_x2 = (x * 2) + 1 + (sx * 32); int position_x2 = (x * 2) + 1 + (sx * 32);
@@ -572,8 +572,7 @@ absl::Status Overworld::SaveOverworldMaps() {
if ((pos + size_a) >= 0x6411F && (pos + size_a) <= 0x70000) { if ((pos + size_a) >= 0x6411F && (pos + size_a) <= 0x70000) {
core::Logger::log("Pos set to overflow region for map " + core::Logger::log("Pos set to overflow region for map " +
std::to_string(i) + " at " + std::to_string(i) + " at " + core::HexLong(pos));
core::HexLong(pos));
pos = OverworldMapDataOverflow; // 0x0F8780; pos = OverworldMapDataOverflow; // 0x0F8780;
} }
@@ -610,8 +609,7 @@ absl::Status Overworld::SaveOverworldMaps() {
int snes_pos = core::PcToSnes(pos); int snes_pos = core::PcToSnes(pos);
map_pointers1[i] = snes_pos; map_pointers1[i] = snes_pos;
core::Logger::log("Saving map pointers1 and compressed data for map " + core::Logger::log("Saving map pointers1 and compressed data for map " +
core::HexByte(i) + " at " + core::HexByte(i) + " at " + core::HexLong(snes_pos));
core::HexLong(snes_pos));
RETURN_IF_ERROR(rom()->WriteLong( RETURN_IF_ERROR(rom()->WriteLong(
rom()->version_constants().kCompressedAllMap32PointersLow + (3 * i), rom()->version_constants().kCompressedAllMap32PointersLow + (3 * i),
snes_pos)); snes_pos));
@@ -620,9 +618,8 @@ absl::Status Overworld::SaveOverworldMaps() {
} else { } else {
// Save pointer for map1 // Save pointer for map1
int snes_pos = map_pointers1[map_pointers1_id[i]]; int snes_pos = map_pointers1[map_pointers1_id[i]];
core::Logger::log("Saving map pointers1 for map " + core::Logger::log("Saving map pointers1 for map " + core::HexByte(i) +
core::HexByte(i) + " at " + " at " + core::HexLong(snes_pos));
core::HexLong(snes_pos));
RETURN_IF_ERROR(rom()->WriteLong( RETURN_IF_ERROR(rom()->WriteLong(
rom()->version_constants().kCompressedAllMap32PointersLow + (3 * i), rom()->version_constants().kCompressedAllMap32PointersLow + (3 * i),
snes_pos)); snes_pos));
@@ -634,8 +631,7 @@ absl::Status Overworld::SaveOverworldMaps() {
if ((pos + b.size()) >= 0x6411F && (pos + b.size()) <= 0x70000) { if ((pos + b.size()) >= 0x6411F && (pos + b.size()) <= 0x70000) {
core::Logger::log("Pos set to overflow region for map " + core::Logger::log("Pos set to overflow region for map " +
core::HexByte(i) + " at " + core::HexByte(i) + " at " + core::HexLong(pos));
core::HexLong(pos));
pos = OverworldMapDataOverflow; pos = OverworldMapDataOverflow;
} }
@@ -645,8 +641,7 @@ absl::Status Overworld::SaveOverworldMaps() {
int snes_pos = core::PcToSnes(pos); int snes_pos = core::PcToSnes(pos);
map_pointers2[i] = snes_pos; map_pointers2[i] = snes_pos;
core::Logger::log("Saving map pointers2 and compressed data for map " + core::Logger::log("Saving map pointers2 and compressed data for map " +
core::HexByte(i) + " at " + core::HexByte(i) + " at " + core::HexLong(snes_pos));
core::HexLong(snes_pos));
RETURN_IF_ERROR(rom()->WriteLong( RETURN_IF_ERROR(rom()->WriteLong(
rom()->version_constants().kCompressedAllMap32PointersHigh + (3 * i), rom()->version_constants().kCompressedAllMap32PointersHigh + (3 * i),
snes_pos)); snes_pos));
@@ -655,9 +650,8 @@ absl::Status Overworld::SaveOverworldMaps() {
} else { } else {
// Save pointer for map2 // Save pointer for map2
int snes_pos = map_pointers2[map_pointers2_id[i]]; int snes_pos = map_pointers2[map_pointers2_id[i]];
core::Logger::log("Saving map pointers2 for map " + core::Logger::log("Saving map pointers2 for map " + core::HexByte(i) +
core::HexByte(i) + " at " + " at " + core::HexLong(snes_pos));
core::HexLong(snes_pos));
RETURN_IF_ERROR(rom()->WriteLong( RETURN_IF_ERROR(rom()->WriteLong(
rom()->version_constants().kCompressedAllMap32PointersHigh + (3 * i), rom()->version_constants().kCompressedAllMap32PointersHigh + (3 * i),
snes_pos)); snes_pos));
@@ -989,13 +983,13 @@ absl::Status Overworld::SaveLargeMaps() {
} }
namespace { namespace {
std::vector<uint64_t> GetAllTile16(OWMapTiles &map_tiles_) { std::vector<uint64_t> GetAllTile16(OverworldMapTiles &map_tiles_) {
std::vector<uint64_t> all_tile_16; // Ensure it's 64 bits std::vector<uint64_t> all_tile_16; // Ensure it's 64 bits
int sx = 0; int sx = 0;
int sy = 0; int sy = 0;
int c = 0; int c = 0;
OWBlockset tiles_used; OverworldBlockset tiles_used;
for (int i = 0; i < kNumOverworldMaps; i++) { for (int i = 0; i < kNumOverworldMaps; i++) {
if (i < 64) { if (i < 64) {
tiles_used = map_tiles_.light_world; tiles_used = map_tiles_.light_world;

15
src/app/zelda3/overworld/overworld.h
View File

@@ -156,7 +156,7 @@ public:
} }
} }
OWBlockset &GetMapTiles(int world_type) { OverworldBlockset &GetMapTiles(int world_type) {
switch (world_type) { switch (world_type) {
case 0: case 0:
return map_tiles_.light_world; return map_tiles_.light_world;
@@ -220,12 +220,14 @@ private:
absl::Status AssembleMap32Tiles(); absl::Status AssembleMap32Tiles();
void AssembleMap16Tiles(); void AssembleMap16Tiles();
void AssignWorldTiles(int x, int y, int sx, int sy, int tpos, void AssignWorldTiles(int x, int y, int sx, int sy, int tpos,
OWBlockset &world); OverworldBlockset &world);
void OrganizeMapTiles(std::vector<uint8_t> &bytes, void OrganizeMapTiles(std::vector<uint8_t> &bytes,
std::vector<uint8_t> &bytes2, int i, int sx, int sy, std::vector<uint8_t> &bytes2, int i, int sx, int sy,
int &ttpos); int &ttpos);
absl::Status DecompressAllMapTiles(); absl::Status DecompressAllMapTiles();
Rom rom_;
bool is_loaded_ = false; bool is_loaded_ = false;
bool expanded_tile16_ = false; bool expanded_tile16_ = false;
bool expanded_tile32_ = false; bool expanded_tile32_ = false;
@@ -234,13 +236,11 @@ private:
int game_state_ = 0; int game_state_ = 0;
int current_map_ = 0; int current_map_ = 0;
int current_world_ = 0; int current_world_ = 0;
uchar map_parent_[160];
Rom rom_; OverworldMapTiles map_tiles_;
OWMapTiles map_tiles_;
uint8_t all_tiles_types_[0x200];
std::array<uint8_t, 160> map_parent_;
std::array<uint8_t, 0x200> all_tiles_types_;
std::vector<gfx::Tile16> tiles16_; std::vector<gfx::Tile16> tiles16_;
std::vector<gfx::Tile32> tiles32_; std::vector<gfx::Tile32> tiles32_;
std::vector<uint16_t> tiles32_list_; std::vector<uint16_t> tiles32_list_;
@@ -251,7 +251,6 @@ private:
std::vector<OverworldExit> all_exits_; std::vector<OverworldExit> all_exits_;
std::vector<OverworldItem> all_items_; std::vector<OverworldItem> all_items_;
std::vector<std::vector<Sprite>> all_sprites_; std::vector<std::vector<Sprite>> all_sprites_;
std::vector<uint64_t> deleted_entrances_; std::vector<uint64_t> deleted_entrances_;
std::vector<std::vector<uint8_t>> map_data_p1 = std::vector<std::vector<uint8_t>> map_data_p1 =

4
src/app/zelda3/overworld/overworld_map.cc
View File

@@ -30,7 +30,7 @@ OverworldMap::OverworldMap(int index, Rom& rom, bool load_custom_data)
absl::Status OverworldMap::BuildMap(int count, int game_state, int world, absl::Status OverworldMap::BuildMap(int count, int game_state, int world,
std::vector<gfx::Tile16>& tiles16, std::vector<gfx::Tile16>& tiles16,
OWBlockset& world_blockset) { OverworldBlockset& world_blockset) {
game_state_ = game_state; game_state_ = game_state;
world_ = world; world_ = world;
if (large_map_) { if (large_map_) {
@@ -718,7 +718,7 @@ absl::Status OverworldMap::BuildTiles16Gfx(std::vector<gfx::Tile16>& tiles16,
return absl::OkStatus(); return absl::OkStatus();
} }
absl::Status OverworldMap::BuildBitmap(OWBlockset& world_blockset) { absl::Status OverworldMap::BuildBitmap(OverworldBlockset& world_blockset) {
if (bitmap_data_.size() != 0) { if (bitmap_data_.size() != 0) {
bitmap_data_.clear(); bitmap_data_.clear();
} }

34
src/app/zelda3/overworld/overworld_map.h
View File

@@ -1,6 +1,7 @@
#ifndef YAZE_APP_ZELDA3_OVERWORLD_MAP_H #ifndef YAZE_APP_ZELDA3_OVERWORLD_MAP_H
#define YAZE_APP_ZELDA3_OVERWORLD_MAP_H #define YAZE_APP_ZELDA3_OVERWORLD_MAP_H
#include <array>
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
#include <vector> #include <vector>
@@ -54,6 +55,20 @@ constexpr int OverworldCustomTileGFXGroupArray = 0x140480;
// 1 byte, not 0 if enabled // 1 byte, not 0 if enabled
constexpr int OverworldCustomTileGFXGroupEnabled = 0x140148; constexpr int OverworldCustomTileGFXGroupEnabled = 0x140148;
/**
* @brief Represents tile32 data for the overworld.
*/
using OverworldBlockset = std::vector<std::vector<uint16_t>>;
/**
* @brief Overworld map tile32 data.
*/
typedef struct OverworldMapTiles {
OverworldBlockset light_world; // 64 maps
OverworldBlockset dark_world; // 64 maps
OverworldBlockset special_world; // 32 maps
} OverworldMapTiles;
/** /**
* @brief Represents a single Overworld map screen. * @brief Represents a single Overworld map screen.
*/ */
@@ -64,13 +79,13 @@ class OverworldMap : public gfx::GfxContext {
absl::Status BuildMap(int count, int game_state, int world, absl::Status BuildMap(int count, int game_state, int world,
std::vector<gfx::Tile16>& tiles16, std::vector<gfx::Tile16>& tiles16,
OWBlockset& world_blockset); OverworldBlockset& world_blockset);
void LoadAreaGraphics(); void LoadAreaGraphics();
absl::Status LoadPalette(); absl::Status LoadPalette();
absl::Status BuildTileset(); absl::Status BuildTileset();
absl::Status BuildTiles16Gfx(std::vector<gfx::Tile16>& tiles16, int count); absl::Status BuildTiles16Gfx(std::vector<gfx::Tile16>& tiles16, int count);
absl::Status BuildBitmap(OWBlockset& world_blockset); absl::Status BuildBitmap(OverworldBlockset& world_blockset);
void DrawAnimatedTiles(); void DrawAnimatedTiles();
@@ -148,6 +163,8 @@ class OverworldMap : public gfx::GfxContext {
int index, int previous_index, int index, int previous_index,
int limit); int limit);
Rom rom_;
bool built_ = false; bool built_ = false;
bool large_map_ = false; bool large_map_ = false;
bool initialized_ = false; bool initialized_ = false;
@@ -167,19 +184,18 @@ class OverworldMap : public gfx::GfxContext {
uint8_t animated_gfx_ = 0; // Custom Overworld Animated ID uint8_t animated_gfx_ = 0; // Custom Overworld Animated ID
uint16_t subscreen_overlay_ = 0; // Custom Overworld Subscreen Overlay ID uint16_t subscreen_overlay_ = 0; // Custom Overworld Subscreen Overlay ID
uint8_t custom_gfx_ids_[8]; std::array<uint8_t, 8> custom_gfx_ids_;
uchar sprite_graphics_[3]; std::array<uint8_t, 3> sprite_graphics_;
uchar sprite_palette_[3]; std::array<uint8_t, 3> sprite_palette_;
uchar area_music_[4]; std::array<uint8_t, 4> area_music_;
uchar static_graphics_[16]; std::array<uint8_t, 16> static_graphics_;
Rom rom_;
std::vector<uint8_t> all_gfx_; std::vector<uint8_t> all_gfx_;
std::vector<uint8_t> current_blockset_; std::vector<uint8_t> current_blockset_;
std::vector<uint8_t> current_gfx_; std::vector<uint8_t> current_gfx_;
std::vector<uint8_t> bitmap_data_; std::vector<uint8_t> bitmap_data_;
OWMapTiles map_tiles_;
OverworldMapTiles map_tiles_;
gfx::SnesPalette current_palette_; gfx::SnesPalette current_palette_;
}; };