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

refactor overworld: add constants for exits, items, entrances, and map IDs

Browse Source
This commit is contained in:
scawful
2025-01-01 19:30:36 -05:00
parent 92d6738a5c
commit ca702d62e3
7 changed files with 177 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -18,20 +18,18 @@ absl::Status Overworld::Load(Rom &rom) {
rom_ = rom; rom_ = rom;
RETURN_IF_ERROR(AssembleMap32Tiles()); RETURN_IF_ERROR(AssembleMap32Tiles());
AssembleMap16Tiles(); RETURN_IF_ERROR(AssembleMap16Tiles());
RETURN_IF_ERROR(DecompressAllMapTiles()) DecompressAllMapTiles();
const bool load_custom_overworld =
core::ExperimentFlags::get().overworld.kLoadCustomOverworld;
for (int map_index = 0; map_index < kNumOverworldMaps; ++map_index) for (int map_index = 0; map_index < kNumOverworldMaps; ++map_index)
overworld_maps_.emplace_back(map_index, rom_, load_custom_overworld); overworld_maps_.emplace_back(map_index, rom_);
FetchLargeMaps(); FetchLargeMaps();
LoadEntrances(); LoadEntrances();
RETURN_IF_ERROR(LoadExits()); RETURN_IF_ERROR(LoadExits());
RETURN_IF_ERROR(LoadItems()); RETURN_IF_ERROR(LoadItems());
RETURN_IF_ERROR(LoadSprites()); RETURN_IF_ERROR(LoadSprites());
RETURN_IF_ERROR(LoadOverworldMaps()) RETURN_IF_ERROR(LoadOverworldMaps());
is_loaded_ = true; is_loaded_ = true;
return absl::OkStatus(); return absl::OkStatus();
@@ -154,7 +152,7 @@ absl::Status Overworld::AssembleMap32Tiles() {
return absl::OkStatus(); return absl::OkStatus();
} }
void Overworld::AssembleMap16Tiles() { absl::Status Overworld::AssembleMap16Tiles() {
int tpos = kMap16Tiles; int tpos = kMap16Tiles;
int num_tile16 = kNumTile16Individual; int num_tile16 = kNumTile16Individual;
if (rom()->data()[kMap16ExpandedFlagPos] != 0x0F && if (rom()->data()[kMap16ExpandedFlagPos] != 0x0F &&
@@ -165,16 +163,21 @@ void Overworld::AssembleMap16Tiles() {
} }
for (int i = 0; i < num_tile16; i += 1) { for (int i = 0; i < num_tile16; i += 1) {
gfx::TileInfo t0 = gfx::GetTilesInfo(rom()->toint16(tpos)); ASSIGN_OR_RETURN(auto t0_data, rom()->ReadWord(tpos));
gfx::TileInfo t0 = gfx::GetTilesInfo(t0_data);
tpos += 2; tpos += 2;
gfx::TileInfo t1 = gfx::GetTilesInfo(rom()->toint16(tpos)); ASSIGN_OR_RETURN(auto t1_data, rom()->ReadWord(tpos));
gfx::TileInfo t1 = gfx::GetTilesInfo(t1_data);
tpos += 2; tpos += 2;
gfx::TileInfo t2 = gfx::GetTilesInfo(rom()->toint16(tpos)); ASSIGN_OR_RETURN(auto t2_data, rom()->ReadWord(tpos));
gfx::TileInfo t2 = gfx::GetTilesInfo(t2_data);
tpos += 2; tpos += 2;
gfx::TileInfo t3 = gfx::GetTilesInfo(rom()->toint16(tpos)); ASSIGN_OR_RETURN(auto t3_data, rom()->ReadWord(tpos));
gfx::TileInfo t3 = gfx::GetTilesInfo(t3_data);
tpos += 2; tpos += 2;
tiles16_.emplace_back(t0, t1, t2, t3); tiles16_.emplace_back(t0, t1, t2, t3);
} }
return absl::OkStatus();
} }
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,
@@ -196,9 +199,9 @@ void Overworld::OrganizeMapTiles(std::vector<uint8_t> &bytes,
for (int x = 0; x < 16; x++) { for (int x = 0; x < 16; x++) {
auto tidD = (uint16_t)((bytes2[ttpos] << 8) + bytes[ttpos]); auto tidD = (uint16_t)((bytes2[ttpos] << 8) + bytes[ttpos]);
if (int tpos = tidD; tpos < tiles32_unique_.size()) { if (int tpos = tidD; tpos < tiles32_unique_.size()) {
if (i < 64) { if (i < kDarkWorldMapIdStart) {
AssignWorldTiles(x, y, sx, sy, tpos, map_tiles_.light_world); AssignWorldTiles(x, y, sx, sy, tpos, map_tiles_.light_world);
} else if (i < 128 && i >= 64) { } else if (i < kSpecialWorldMapIdStart && i >= kDarkWorldMapIdStart) {
AssignWorldTiles(x, y, sx, sy, tpos, map_tiles_.dark_world); AssignWorldTiles(x, y, sx, sy, tpos, map_tiles_.dark_world);
} else { } else {
AssignWorldTiles(x, y, sx, sy, tpos, map_tiles_.special_world); AssignWorldTiles(x, y, sx, sy, tpos, map_tiles_.special_world);
@@ -209,7 +212,7 @@ void Overworld::OrganizeMapTiles(std::vector<uint8_t> &bytes,
} }
} }
absl::Status Overworld::DecompressAllMapTiles() { void Overworld::DecompressAllMapTiles() {
const auto get_ow_map_gfx_ptr = [this](int index, uint32_t map_ptr) { const auto get_ow_map_gfx_ptr = [this](int index, uint32_t map_ptr) {
int p = (rom()->data()[map_ptr + 2 + (3 * index)] << 16) + int p = (rom()->data()[map_ptr + 2 + (3 * index)] << 16) +
(rom()->data()[map_ptr + 1 + (3 * index)] << 8) + (rom()->data()[map_ptr + 1 + (3 * index)] << 8) +
@@ -257,7 +260,6 @@ absl::Status Overworld::DecompressAllMapTiles() {
c = 0; c = 0;
} }
} }
return absl::OkStatus();
} }
absl::Status Overworld::LoadOverworldMaps() { absl::Status Overworld::LoadOverworldMaps() {
@@ -265,9 +267,9 @@ absl::Status Overworld::LoadOverworldMaps() {
std::vector<std::future<absl::Status>> futures; std::vector<std::future<absl::Status>> futures;
for (int i = 0; i < kNumOverworldMaps; ++i) { for (int i = 0; i < kNumOverworldMaps; ++i) {
int world_type = 0; int world_type = 0;
if (i >= 64 && i < 0x80) { if (i >= kDarkWorldMapIdStart && i < kSpecialWorldMapIdStart) {
world_type = 1; world_type = 1;
} else if (i >= 0x80) { } else if (i >= kSpecialWorldMapIdStart) {
world_type = 2; world_type = 2;
} }
auto task_function = [this, i, size, world_type]() { auto task_function = [this, i, size, world_type]() {
@@ -641,9 +643,7 @@ absl::Status Overworld::SaveOverworldMaps() {
return absl::AbortedError("Too many maps data " + std::to_string(pos)); return absl::AbortedError("Too many maps data " + std::to_string(pos));
} }
// Save large maps
RETURN_IF_ERROR(SaveLargeMaps()) RETURN_IF_ERROR(SaveLargeMaps())
return absl::OkStatus(); return absl::OkStatus();
} }
@@ -685,9 +685,11 @@ absl::Status Overworld::SaveLargeMaps() {
RETURN_IF_ERROR(rom()->WriteByte( RETURN_IF_ERROR(rom()->WriteByte(
kOverworldScreenSizeForLoading + i + offset, 0x04)); kOverworldScreenSizeForLoading + i + offset, 0x04));
RETURN_IF_ERROR(rom()->WriteByte( RETURN_IF_ERROR(rom()->WriteByte(
kOverworldScreenSizeForLoading + i + offset + 64, 0x04)); kOverworldScreenSizeForLoading + i + offset + kDarkWorldMapIdStart,
RETURN_IF_ERROR(rom()->WriteByte( 0x04));
kOverworldScreenSizeForLoading + i + offset + 128, 0x04)); RETURN_IF_ERROR(rom()->WriteByte(kOverworldScreenSizeForLoading + i +
offset + kSpecialWorldMapIdStart,
0x04));
} }
// Check 5 and 6 // Check 5 and 6
@@ -871,10 +873,10 @@ absl::Status Overworld::SaveLargeMaps() {
RETURN_IF_ERROR( RETURN_IF_ERROR(
rom()->WriteByte(kOverworldScreenSizeForLoading + i, 0x02)); rom()->WriteByte(kOverworldScreenSizeForLoading + i, 0x02));
RETURN_IF_ERROR( RETURN_IF_ERROR(rom()->WriteByte(
rom()->WriteByte(kOverworldScreenSizeForLoading + i + 64, 0x02)); kOverworldScreenSizeForLoading + i + kDarkWorldMapIdStart, 0x02));
RETURN_IF_ERROR( RETURN_IF_ERROR(rom()->WriteByte(
rom()->WriteByte(kOverworldScreenSizeForLoading + i + 128, 0x02)); kOverworldScreenSizeForLoading + i + kSpecialWorldMapIdStart, 0x02));
RETURN_IF_ERROR(rom()->WriteShort( RETURN_IF_ERROR(rom()->WriteShort(
kOverworldScreenTileMapChangeByScreen1 + (i * 2), 0x0060)); kOverworldScreenTileMapChangeByScreen1 + (i * 2), 0x0060));
@@ -974,9 +976,9 @@ std::vector<uint64_t> GetAllTile16(OverworldMapTiles &map_tiles_) {
int c = 0; int c = 0;
OverworldBlockset tiles_used; OverworldBlockset tiles_used;
for (int i = 0; i < kNumOverworldMaps; i++) { for (int i = 0; i < kNumOverworldMaps; i++) {
if (i < 64) { if (i < kDarkWorldMapIdStart) {
tiles_used = map_tiles_.light_world; tiles_used = map_tiles_.light_world;
} else if (i < 128 && i >= 64) { } else if (i < kSpecialWorldMapIdStart && i >= kDarkWorldMapIdStart) {
tiles_used = map_tiles_.dark_world; tiles_used = map_tiles_.dark_world;
} else { } else {
tiles_used = map_tiles_.special_world; tiles_used = map_tiles_.special_world;
@@ -1353,7 +1355,18 @@ absl::Status Overworld::SaveMap16Tiles() {
absl::Status Overworld::SaveEntrances() { absl::Status Overworld::SaveEntrances() {
core::logf("Saving Entrances"); core::logf("Saving Entrances");
for (int i = 0; i < 129; i++) { int ow_entrance_map_ptr = kOverworldEntranceMap;
int ow_entrance_pos_ptr = kOverworldEntrancePos;
int ow_entrance_id_ptr = kOverworldEntranceEntranceId;
int num_entrances = kNumOverworldEntrances;
if (expanded_entrances_) {
ow_entrance_map_ptr = kOverworldEntranceMapExpanded;
ow_entrance_pos_ptr = kOverworldEntrancePosExpanded;
ow_entrance_id_ptr = kOverworldEntranceEntranceIdExpanded;
expanded_entrances_ = true;
}
for (int i = 0; i < kNumOverworldEntrances; i++) {
RETURN_IF_ERROR(rom()->WriteShort(kOverworldEntranceMap + (i * 2), RETURN_IF_ERROR(rom()->WriteShort(kOverworldEntranceMap + (i * 2),
all_entrances_[i].map_id_)) all_entrances_[i].map_id_))
RETURN_IF_ERROR(rom()->WriteShort(kOverworldEntrancePos + (i * 2), RETURN_IF_ERROR(rom()->WriteShort(kOverworldEntrancePos + (i * 2),
@@ -1362,7 +1375,7 @@ absl::Status Overworld::SaveEntrances() {
all_entrances_[i].entrance_id_)) all_entrances_[i].entrance_id_))
} }
for (int i = 0; i < 0x13; i++) { for (int i = 0; i < kNumOverworldHoles; i++) {
RETURN_IF_ERROR( RETURN_IF_ERROR(
rom()->WriteShort(kOverworldHoleArea + (i * 2), all_holes_[i].map_id_)) rom()->WriteShort(kOverworldHoleArea + (i * 2), all_holes_[i].map_id_))
RETURN_IF_ERROR( RETURN_IF_ERROR(
@@ -1376,7 +1389,7 @@ absl::Status Overworld::SaveEntrances() {
absl::Status Overworld::SaveExits() { absl::Status Overworld::SaveExits() {
core::logf("Saving Exits"); core::logf("Saving Exits");
for (int i = 0; i < 0x4F; i++) { for (int i = 0; i < kNumOverworldExits; i++) {
RETURN_IF_ERROR( RETURN_IF_ERROR(
rom()->WriteShort(OWExitRoomId + (i * 2), all_exits_[i].room_id_)); rom()->WriteShort(OWExitRoomId + (i * 2), all_exits_[i].room_id_));
RETURN_IF_ERROR(rom()->Write(OWExitMapId + i, all_exits_[i].map_id_)); RETURN_IF_ERROR(rom()->Write(OWExitMapId + i, all_exits_[i].map_id_));
@@ -1408,7 +1421,6 @@ absl::Status Overworld::SaveExits() {
} }
namespace { namespace {
bool CompareItemsArrays(std::vector<OverworldItem> item_array1, bool CompareItemsArrays(std::vector<OverworldItem> item_array1,
std::vector<OverworldItem> item_array2) { std::vector<OverworldItem> item_array2) {
if (item_array1.size() != item_array2.size()) { if (item_array1.size() != item_array2.size()) {
@@ -1435,13 +1447,13 @@ bool CompareItemsArrays(std::vector<OverworldItem> item_array1,
return true; return true;
} }
} // namespace } // namespace
absl::Status Overworld::SaveItems() { absl::Status Overworld::SaveItems() {
std::vector<std::vector<OverworldItem>> room_items(128); std::vector<std::vector<OverworldItem>> room_items(
kNumOverworldMapItemPointers);
for (int i = 0; i < 128; i++) { for (int i = 0; i < kNumOverworldMapItemPointers; i++) {
room_items[i] = std::vector<OverworldItem>(); room_items[i] = std::vector<OverworldItem>();
for (const OverworldItem &item : all_items_) { for (const OverworldItem &item : all_items_) {
if (item.room_map_id_ == i) { if (item.room_map_id_ == i) {
@@ -1455,10 +1467,10 @@ absl::Status Overworld::SaveItems() {
} }
int data_pos = kOverworldItemsPointers + 0x100; int data_pos = kOverworldItemsPointers + 0x100;
int item_pointers[128]; int item_pointers[kNumOverworldMapItemPointers];
int item_pointers_reuse[128]; int item_pointers_reuse[kNumOverworldMapItemPointers];
int empty_pointer = 0; int empty_pointer = 0;
for (int i = 0; i < 128; i++) { for (int i = 0; i < kNumOverworldMapItemPointers; i++) {
item_pointers_reuse[i] = -1; item_pointers_reuse[i] = -1;
for (int ci = 0; ci < i; ci++) { for (int ci = 0; ci < i; ci++) {
if (room_items[i].empty()) { if (room_items[i].empty()) {
@@ -1478,7 +1490,7 @@ absl::Status Overworld::SaveItems() {
} }
} }
for (int i = 0; i < 128; i++) { for (int i = 0; i < kNumOverworldMapItemPointers; i++) {
if (item_pointers_reuse[i] == -1) { if (item_pointers_reuse[i] == -1) {
item_pointers[i] = data_pos; item_pointers[i] = data_pos;
for (const OverworldItem &item : room_items[i]) { for (const OverworldItem &item : room_items[i]) {
@@ -1519,39 +1531,47 @@ absl::Status Overworld::SaveItems() {
absl::Status Overworld::SaveMapProperties() { absl::Status Overworld::SaveMapProperties() {
core::logf("Saving Map Properties"); core::logf("Saving Map Properties");
for (int i = 0; i < 64; i++) { for (int i = 0; i < kDarkWorldMapIdStart; i++) {
RETURN_IF_ERROR(rom()->WriteByte(kAreaGfxIdPtr + i, RETURN_IF_ERROR(rom()->WriteByte(kAreaGfxIdPtr + i,
overworld_maps_[i].area_graphics())); overworld_maps_[i].area_graphics()));
RETURN_IF_ERROR(rom()->WriteByte(kOverworldMapPaletteIds + i, RETURN_IF_ERROR(rom()->WriteByte(kOverworldMapPaletteIds + i,
overworld_maps_[i].area_palette())); overworld_maps_[i].area_palette()));
RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpriteset + i, RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpriteset + i,
overworld_maps_[i].sprite_graphics(0))); overworld_maps_[i].sprite_graphics(0)));
RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpriteset + 64 + i, RETURN_IF_ERROR(
rom()->WriteByte(kOverworldSpriteset + kDarkWorldMapIdStart + i,
overworld_maps_[i].sprite_graphics(1))); overworld_maps_[i].sprite_graphics(1)));
RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpriteset + 128 + i, RETURN_IF_ERROR(
rom()->WriteByte(kOverworldSpriteset + kSpecialWorldMapIdStart + i,
overworld_maps_[i].sprite_graphics(2))); overworld_maps_[i].sprite_graphics(2)));
RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpritePaletteIds + i, RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpritePaletteIds + i,
overworld_maps_[i].sprite_palette(0))); overworld_maps_[i].sprite_palette(0)));
RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpritePaletteIds + 64 + i, RETURN_IF_ERROR(
rom()->WriteByte(kOverworldSpritePaletteIds + kDarkWorldMapIdStart + i,
overworld_maps_[i].sprite_palette(1))); overworld_maps_[i].sprite_palette(1)));
RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpritePaletteIds + 128 + i, RETURN_IF_ERROR(rom()->WriteByte(
kOverworldSpritePaletteIds + kSpecialWorldMapIdStart + i,
overworld_maps_[i].sprite_palette(2))); overworld_maps_[i].sprite_palette(2)));
} }
for (int i = 64; i < 128; i++) { for (int i = kDarkWorldMapIdStart; i < kSpecialWorldMapIdStart; i++) {
RETURN_IF_ERROR(rom()->WriteByte(kAreaGfxIdPtr + i, RETURN_IF_ERROR(rom()->WriteByte(kAreaGfxIdPtr + i,
overworld_maps_[i].area_graphics())); overworld_maps_[i].area_graphics()));
RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpriteset + i, RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpriteset + i,
overworld_maps_[i].sprite_graphics(0))); overworld_maps_[i].sprite_graphics(0)));
RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpriteset + 64 + i, RETURN_IF_ERROR(
rom()->WriteByte(kOverworldSpriteset + kDarkWorldMapIdStart + i,
overworld_maps_[i].sprite_graphics(1))); overworld_maps_[i].sprite_graphics(1)));
RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpriteset + 128 + i, RETURN_IF_ERROR(
rom()->WriteByte(kOverworldSpriteset + kSpecialWorldMapIdStart + i,
overworld_maps_[i].sprite_graphics(2))); overworld_maps_[i].sprite_graphics(2)));
RETURN_IF_ERROR(rom()->WriteByte(kOverworldMapPaletteIds + i, RETURN_IF_ERROR(rom()->WriteByte(kOverworldMapPaletteIds + i,
overworld_maps_[i].area_palette())); overworld_maps_[i].area_palette()));
RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpritePaletteIds + 64 + i, RETURN_IF_ERROR(
rom()->WriteByte(kOverworldSpritePaletteIds + kDarkWorldMapIdStart + i,
overworld_maps_[i].sprite_palette(0))); overworld_maps_[i].sprite_palette(0)));
RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpritePaletteIds + 128 + i, RETURN_IF_ERROR(rom()->WriteByte(
kOverworldSpritePaletteIds + kSpecialWorldMapIdStart + i,
overworld_maps_[i].sprite_palette(1))); overworld_maps_[i].sprite_palette(1)));
RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpritePaletteIds + 192 + i, RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpritePaletteIds + 192 + i,
overworld_maps_[i].sprite_palette(2))); overworld_maps_[i].sprite_palette(2)));

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

@@ -5,11 +5,8 @@
#include "absl/container/flat_hash_map.h" #include "absl/container/flat_hash_map.h"
#include "absl/status/status.h" #include "absl/status/status.h"
#include "app/core/common.h"
#include "app/core/constants.h"
#include "app/gfx/snes_tile.h" #include "app/gfx/snes_tile.h"
#include "app/rom.h" #include "app/rom.h"
#include "app/zelda3/common.h"
#include "app/zelda3/overworld/overworld_entrance.h" #include "app/zelda3/overworld/overworld_entrance.h"
#include "app/zelda3/overworld/overworld_exit.h" #include "app/zelda3/overworld/overworld_exit.h"
#include "app/zelda3/overworld/overworld_item.h" #include "app/zelda3/overworld/overworld_item.h"
@@ -222,13 +219,13 @@ class Overworld : public SharedRom {
int dimension, int dimension,
const uint32_t *map32address); const uint32_t *map32address);
absl::Status AssembleMap32Tiles(); absl::Status AssembleMap32Tiles();
void AssembleMap16Tiles(); absl::Status 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,
OverworldBlockset &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(); void DecompressAllMapTiles();
Rom rom_; Rom rom_;

3
src/app/zelda3/overworld/overworld_entrance.h
View File

@@ -10,6 +10,9 @@
namespace yaze { namespace yaze {
namespace zelda3 { namespace zelda3 {
constexpr int kNumOverworldEntrances = 129;
constexpr int kNumOverworldHoles = 0x13;
constexpr int kOverworldEntranceMap = 0xDB96F; constexpr int kOverworldEntranceMap = 0xDB96F;
constexpr int kOverworldEntrancePos = 0xDBA71; constexpr int kOverworldEntrancePos = 0xDBA71;
constexpr int kOverworldEntranceEntranceId = 0xDBB73; constexpr int kOverworldEntranceEntranceId = 0xDBB73;

1
src/app/zelda3/overworld/overworld_exit.h
View File

@@ -10,6 +10,7 @@
namespace yaze { namespace yaze {
namespace zelda3 { namespace zelda3 {
constexpr int kNumOverworldExits = 0x4F;
constexpr int OWExitRoomId = 0x15D8A; // 0x15E07 Credits sequences constexpr int OWExitRoomId = 0x15D8A; // 0x15E07 Credits sequences
// 105C2 Ending maps // 105C2 Ending maps
// 105E2 Sprite Group Table for Ending // 105E2 Sprite Group Table for Ending

1
src/app/zelda3/overworld/overworld_item.h
View File

@@ -12,6 +12,7 @@
namespace yaze { namespace yaze {
namespace zelda3 { namespace zelda3 {
constexpr int kNumOverworldMapItemPointers = 0x80;
constexpr int kOverworldItemsPointers = 0xDC2F9; constexpr int kOverworldItemsPointers = 0xDC2F9;
constexpr int kOverworldItemsAddress = 0xDC8B9; // 1BC2F9 constexpr int kOverworldItemsAddress = 0xDC8B9; // 1BC2F9
constexpr int kOverworldItemsBank = 0xDC8BF; constexpr int kOverworldItemsBank = 0xDC8BF;

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

@@ -12,11 +12,11 @@
namespace yaze { namespace yaze {
namespace zelda3 { namespace zelda3 {
OverworldMap::OverworldMap(int index, Rom& rom, bool load_custom_data) OverworldMap::OverworldMap(int index, Rom &rom)
: index_(index), parent_(index), rom_(rom) { : index_(index), parent_(index), rom_(rom) {
LoadAreaInfo(); LoadAreaInfo();
if (load_custom_data) { if (core::ExperimentFlags::get().overworld.kLoadCustomOverworld) {
// If the custom overworld ASM has NOT already been applied, manually set // If the custom overworld ASM has NOT already been applied, manually set
// the vanilla values. // the vanilla values.
uint8_t asm_version = rom_[OverworldCustomASMHasBeenApplied]; uint8_t asm_version = rom_[OverworldCustomASMHasBeenApplied];
@@ -29,14 +29,16 @@ 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,
OverworldBlockset& world_blockset) { OverworldBlockset &world_blockset) {
game_state_ = game_state; game_state_ = game_state;
world_ = world; world_ = world;
if (large_map_) { if (large_map_) {
if (parent_ != index_ && !initialized_) { if (parent_ != index_ && !initialized_) {
if (index_ >= 0x80 && index_ <= 0x8A && index_ != 0x88) { if (index_ >= kSpecialWorldMapIdStart && index_ <= 0x8A &&
area_graphics_ = rom_[kOverworldSpecialGfxGroup + (parent_ - 0x80)]; index_ != 0x88) {
area_graphics_ = rom_[kOverworldSpecialGfxGroup +
(parent_ - kSpecialWorldMapIdStart)];
area_palette_ = rom_[kOverworldSpecialPalGroup + 1]; area_palette_ = rom_[kOverworldSpecialPalGroup + 1];
} else if (index_ == 0x88) { } else if (index_ == 0x88) {
area_graphics_ = 0x51; area_graphics_ = 0x51;
@@ -60,7 +62,7 @@ absl::Status OverworldMap::BuildMap(int count, int game_state, int world,
} }
void OverworldMap::LoadAreaInfo() { void OverworldMap::LoadAreaInfo() {
if (index_ != 0x80) { if (index_ != kSpecialWorldMapIdStart) {
if (index_ <= 128) if (index_ <= 128)
large_map_ = (rom_[kOverworldMapSize + (index_ & 0x3F)] != 0); large_map_ = (rom_[kOverworldMapSize + (index_ & 0x3F)] != 0);
else { else {
@@ -71,7 +73,7 @@ void OverworldMap::LoadAreaInfo() {
message_id_ = rom_.toint16(kOverworldMessageIds + (parent_ * 2)); message_id_ = rom_.toint16(kOverworldMessageIds + (parent_ * 2));
if (index_ < 0x40) { if (index_ < kDarkWorldMapIdStart) {
area_graphics_ = rom_[kAreaGfxIdPtr + parent_]; area_graphics_ = rom_[kAreaGfxIdPtr + parent_];
area_palette_ = rom_[kOverworldMapPaletteIds + parent_]; area_palette_ = rom_[kOverworldMapPaletteIds + parent_];
@@ -81,24 +83,34 @@ void OverworldMap::LoadAreaInfo() {
area_music_[3] = rom_[kOverworldMusicAgahnim + parent_]; area_music_[3] = rom_[kOverworldMusicAgahnim + parent_];
sprite_graphics_[0] = rom_[kOverworldSpriteset + parent_]; sprite_graphics_[0] = rom_[kOverworldSpriteset + parent_];
sprite_graphics_[1] = rom_[kOverworldSpriteset + parent_ + 0x40]; sprite_graphics_[1] =
sprite_graphics_[2] = rom_[kOverworldSpriteset + parent_ + 0x80]; rom_[kOverworldSpriteset + parent_ + kDarkWorldMapIdStart];
sprite_graphics_[2] =
rom_[kOverworldSpriteset + parent_ + kSpecialWorldMapIdStart];
sprite_palette_[0] = rom_[kOverworldSpritePaletteIds + parent_]; sprite_palette_[0] = rom_[kOverworldSpritePaletteIds + parent_];
sprite_palette_[1] = rom_[kOverworldSpritePaletteIds + parent_ + 0x40]; sprite_palette_[1] =
sprite_palette_[2] = rom_[kOverworldSpritePaletteIds + parent_ + 0x80]; rom_[kOverworldSpritePaletteIds + parent_ + kDarkWorldMapIdStart];
} else if (index_ < 0x80) { sprite_palette_[2] =
rom_[kOverworldSpritePaletteIds + parent_ + kSpecialWorldMapIdStart];
} else if (index_ < kSpecialWorldMapIdStart) {
area_graphics_ = rom_[kAreaGfxIdPtr + parent_]; area_graphics_ = rom_[kAreaGfxIdPtr + parent_];
area_palette_ = rom_[kOverworldMapPaletteIds + parent_]; area_palette_ = rom_[kOverworldMapPaletteIds + parent_];
area_music_[0] = rom_[kOverworldMusicDarkWorld + (parent_ - 64)]; area_music_[0] = rom_[kOverworldMusicDarkWorld + (parent_ - 64)];
sprite_graphics_[0] = rom_[kOverworldSpriteset + parent_ + 0x80]; sprite_graphics_[0] =
sprite_graphics_[1] = rom_[kOverworldSpriteset + parent_ + 0x80]; rom_[kOverworldSpriteset + parent_ + kSpecialWorldMapIdStart];
sprite_graphics_[2] = rom_[kOverworldSpriteset + parent_ + 0x80]; sprite_graphics_[1] =
rom_[kOverworldSpriteset + parent_ + kSpecialWorldMapIdStart];
sprite_graphics_[2] =
rom_[kOverworldSpriteset + parent_ + kSpecialWorldMapIdStart];
sprite_palette_[0] = rom_[kOverworldSpritePaletteIds + parent_ + 0x80]; sprite_palette_[0] =
sprite_palette_[1] = rom_[kOverworldSpritePaletteIds + parent_ + 0x80]; rom_[kOverworldSpritePaletteIds + parent_ + kSpecialWorldMapIdStart];
sprite_palette_[2] = rom_[kOverworldSpritePaletteIds + parent_ + 0x80]; sprite_palette_[1] =
rom_[kOverworldSpritePaletteIds + parent_ + kSpecialWorldMapIdStart];
sprite_palette_[2] =
rom_[kOverworldSpritePaletteIds + parent_ + kSpecialWorldMapIdStart];
} else { } else {
if (index_ == 0x94) { if (index_ == 0x94) {
parent_ = 0x80; parent_ = 0x80;
@@ -123,10 +135,13 @@ void OverworldMap::LoadAreaInfo() {
parent_ = 129; parent_ = 129;
} }
area_palette_ = rom_[kOverworldSpecialPalGroup + parent_ - 0x80]; area_palette_ =
if ((index_ >= 0x80 && index_ <= 0x8A && index_ != 0x88) || rom_[kOverworldSpecialPalGroup + parent_ - kSpecialWorldMapIdStart];
if ((index_ >= kSpecialWorldMapIdStart && index_ <= 0x8A &&
index_ != 0x88) ||
index_ == 0x94) { index_ == 0x94) {
area_graphics_ = rom_[kOverworldSpecialGfxGroup + (parent_ - 0x80)]; area_graphics_ =
rom_[kOverworldSpecialGfxGroup + (parent_ - kSpecialWorldMapIdStart)];
area_palette_ = rom_[kOverworldSpecialPalGroup + 1]; area_palette_ = rom_[kOverworldSpecialPalGroup + 1];
} else if (index_ == 0x88) { } else if (index_ == 0x88) {
area_graphics_ = 0x51; area_graphics_ = 0x51;
@@ -137,23 +152,30 @@ void OverworldMap::LoadAreaInfo() {
area_palette_ = rom_[kOverworldMapPaletteIds + parent_]; area_palette_ = rom_[kOverworldMapPaletteIds + parent_];
} }
sprite_graphics_[0] = rom_[kOverworldSpriteset + parent_ + 0x80]; sprite_graphics_[0] =
sprite_graphics_[1] = rom_[kOverworldSpriteset + parent_ + 0x80]; rom_[kOverworldSpriteset + parent_ + kSpecialWorldMapIdStart];
sprite_graphics_[2] = rom_[kOverworldSpriteset + parent_ + 0x80]; sprite_graphics_[1] =
rom_[kOverworldSpriteset + parent_ + kSpecialWorldMapIdStart];
sprite_graphics_[2] =
rom_[kOverworldSpriteset + parent_ + kSpecialWorldMapIdStart];
sprite_palette_[0] = rom_[kOverworldSpritePaletteIds + parent_ + 0x80]; sprite_palette_[0] =
sprite_palette_[1] = rom_[kOverworldSpritePaletteIds + parent_ + 0x80]; rom_[kOverworldSpritePaletteIds + parent_ + kSpecialWorldMapIdStart];
sprite_palette_[2] = rom_[kOverworldSpritePaletteIds + parent_ + 0x80]; sprite_palette_[1] =
rom_[kOverworldSpritePaletteIds + parent_ + kSpecialWorldMapIdStart];
sprite_palette_[2] =
rom_[kOverworldSpritePaletteIds + parent_ + kSpecialWorldMapIdStart];
} }
} }
void OverworldMap::LoadCustomOverworldData() { void OverworldMap::LoadCustomOverworldData() {
// Set the main palette values. // Set the main palette values.
if (index_ < 0x40) { if (index_ < kDarkWorldMapIdStart) {
area_palette_ = 0; area_palette_ = 0;
} else if (index_ >= 0x40 && index_ < 0x80) { } else if (index_ >= kDarkWorldMapIdStart &&
index_ < kSpecialWorldMapIdStart) {
area_palette_ = 1; area_palette_ = 1;
} else if (index_ >= 0x80 && index_ < 0xA0) { } else if (index_ >= kSpecialWorldMapIdStart && index_ < 0xA0) {
area_palette_ = 0; area_palette_ = 0;
} }
@@ -166,31 +188,31 @@ void OverworldMap::LoadCustomOverworldData() {
} }
// Set the mosaic values. // Set the mosaic values.
mosaic_ = index_ == 0x00 || index_ == 0x40 || index_ == 0x80 || mosaic_ = index_ == 0x00 || index_ == kDarkWorldMapIdStart ||
index_ == 0x81 || index_ == 0x88; index_ == kSpecialWorldMapIdStart || index_ == 0x81 ||
index_ == 0x88;
int indexWorld = 0x20; int index_world = 0x20;
if (parent_ >= 0x40 && parent_ < 0x80) // DW if (parent_ >= kDarkWorldMapIdStart &&
parent_ < kSpecialWorldMapIdStart) // DW
{ {
indexWorld = 0x21; index_world = 0x21;
} else if (parent_ == 0x88) // Triforce room } else if (parent_ == 0x88) // Triforce room
{ {
indexWorld = 0x24; index_world = 0x24;
} }
const auto overworld_gfx_groups2 = const auto overworld_gfx_groups2 =
rom_.version_constants().kOverworldGfxGroups2; rom_.version_constants().kOverworldGfxGroups2;
// Main Blocksets // Main Blocksets
for (int i = 0; i < 8; i++) { for (int i = 0; i < 8; i++) {
custom_gfx_ids_[i] = custom_gfx_ids_[i] =
(uint8_t)rom_[overworld_gfx_groups2 + (indexWorld * 8) + i]; (uint8_t)rom_[overworld_gfx_groups2 + (index_world * 8) + i];
} }
const auto overworldgfxGroups = rom_.version_constants().kOverworldGfxGroups1; const auto overworldgfxGroups = rom_.version_constants().kOverworldGfxGroups1;
// Replace the variable tiles with the variable ones. // Replace the variable tiles with the variable ones.
uint8_t temp = rom_[overworldgfxGroups + (area_graphics_ * 4)]; uint8_t temp = rom_[overworldgfxGroups + (area_graphics_ * 4)];
if (temp != 0) { if (temp != 0) {
@@ -232,7 +254,8 @@ void OverworldMap::LoadCustomOverworldData() {
subscreen_overlay_ = 0x00FF; subscreen_overlay_ = 0x00FF;
if (index_ == 0x00 || if (index_ == 0x00 ||
index_ == 0x40) // Add fog 2 to the lost woods and skull woods. index_ ==
kDarkWorldMapIdStart) // Add fog 2 to the lost woods and skull woods.
{ {
subscreen_overlay_ = 0x009D; subscreen_overlay_ = 0x009D;
} else if (index_ == 0x03 || index_ == 0x05 || } else if (index_ == 0x03 || index_ == 0x05 ||
@@ -271,22 +294,22 @@ void OverworldMap::SetupCustomTileset(uint8_t asm_version) {
animated_gfx_ = rom_[OverworldCustomAnimatedGFXArray + index_]; animated_gfx_ = rom_[OverworldCustomAnimatedGFXArray + index_];
} else { } else {
int indexWorld = 0x20; int index_world = 0x20;
if (parent_ >= 0x40 && parent_ < 0x80) // DW if (parent_ >= kDarkWorldMapIdStart &&
parent_ < kSpecialWorldMapIdStart) // DW
{ {
indexWorld = 0x21; index_world = 0x21;
} else if (parent_ == 0x88) // Triforce room } else if (parent_ == 0x88) // Triforce room
{ {
indexWorld = 0x24; index_world = 0x24;
} }
// Main Blocksets // Main Blocksets
for (int i = 0; i < 8; i++) { for (int i = 0; i < 8; i++) {
custom_gfx_ids_[i] = custom_gfx_ids_[i] =
(uint8_t)rom_[rom_.version_constants().kOverworldGfxGroups2 + (uint8_t)rom_[rom_.version_constants().kOverworldGfxGroups2 +
(indexWorld * 8) + i]; (index_world * 8) + i];
} }
const auto overworldgfxGroups = const auto overworldgfxGroups =
@@ -337,9 +360,10 @@ void OverworldMap::SetupCustomTileset(uint8_t asm_version) {
} }
void OverworldMap::LoadMainBlocksetId() { void OverworldMap::LoadMainBlocksetId() {
if (parent_ < 0x40) { if (parent_ < kDarkWorldMapIdStart) {
main_gfx_id_ = 0x20; main_gfx_id_ = 0x20;
} else if (parent_ >= 0x40 && parent_ < 0x80) { } else if (parent_ >= kDarkWorldMapIdStart &&
parent_ < kSpecialWorldMapIdStart) {
main_gfx_id_ = 0x21; main_gfx_id_ = 0x21;
} else if (parent_ == 0x88) { } else if (parent_ == 0x88) {
main_gfx_id_ = 0x24; main_gfx_id_ = 0x24;
@@ -425,7 +449,7 @@ void OverworldMap::LoadAreaGraphics() {
namespace palette_internal { namespace palette_internal {
absl::Status SetColorsPalette(Rom& rom, int index, gfx::SnesPalette& current, absl::Status SetColorsPalette(Rom &rom, int index, gfx::SnesPalette &current,
gfx::SnesPalette main, gfx::SnesPalette animated, gfx::SnesPalette main, gfx::SnesPalette animated,
gfx::SnesPalette aux1, gfx::SnesPalette aux2, gfx::SnesPalette aux1, gfx::SnesPalette aux2,
gfx::SnesPalette hud, gfx::SnesColor bgrcolor, gfx::SnesPalette hud, gfx::SnesColor bgrcolor,
@@ -544,9 +568,8 @@ absl::Status SetColorsPalette(Rom& rom, int index, gfx::SnesPalette& current,
} }
} // namespace palette_internal } // namespace palette_internal
// New helper function to get a palette from the Rom.
absl::StatusOr<gfx::SnesPalette> OverworldMap::GetPalette( absl::StatusOr<gfx::SnesPalette> OverworldMap::GetPalette(
const gfx::PaletteGroup& palette_group, int index, int previous_index, const gfx::PaletteGroup &palette_group, int index, int previous_index,
int limit) { int limit) {
if (index == 255) { if (index == 255) {
index = rom_[rom_.version_constants().kOverworldMapPaletteGroup + index = rom_[rom_.version_constants().kOverworldMapPaletteGroup +
@@ -559,9 +582,9 @@ absl::StatusOr<gfx::SnesPalette> OverworldMap::GetPalette(
} }
absl::Status OverworldMap::LoadPalette() { absl::Status OverworldMap::LoadPalette() {
int previousPalId = int previous_pal_id =
index_ > 0 ? rom_[kOverworldMapPaletteIds + parent_ - 1] : 0; index_ > 0 ? rom_[kOverworldMapPaletteIds + parent_ - 1] : 0;
int previousSprPalId = int previous_spr_pal_id =
index_ > 0 ? rom_[kOverworldSpritePaletteIds + parent_ - 1] : 0; index_ > 0 ? rom_[kOverworldSpritePaletteIds + parent_ - 1] : 0;
area_palette_ = std::min((int)area_palette_, 0xA3); area_palette_ = std::min((int)area_palette_, 0xA3);
@@ -583,20 +606,21 @@ absl::Status OverworldMap::LoadPalette() {
auto ow_aux_pal_group = rom_.palette_group().overworld_aux; auto ow_aux_pal_group = rom_.palette_group().overworld_aux;
ASSIGN_OR_RETURN(gfx::SnesPalette aux1, ASSIGN_OR_RETURN(gfx::SnesPalette aux1,
GetPalette(ow_aux_pal_group, pal1, previousPalId, 20)); GetPalette(ow_aux_pal_group, pal1, previous_pal_id, 20));
ASSIGN_OR_RETURN(gfx::SnesPalette aux2, ASSIGN_OR_RETURN(gfx::SnesPalette aux2,
GetPalette(ow_aux_pal_group, pal2, previousPalId, 20)); GetPalette(ow_aux_pal_group, pal2, previous_pal_id, 20));
// Additional handling of `pal3` and `parent_` // Additional handling of `pal3` and `parent_`
if (pal3 == 255) { if (pal3 == 255) {
pal3 = rom_[rom_.version_constants().kOverworldMapPaletteGroup + pal3 = rom_[rom_.version_constants().kOverworldMapPaletteGroup +
(previousPalId * 4) + 2]; (previous_pal_id * 4) + 2];
} }
if (parent_ < 0x40) { if (parent_ < kDarkWorldMapIdStart) {
pal0 = parent_ == 0x03 || parent_ == 0x05 || parent_ == 0x07 ? 2 : 0; pal0 = parent_ == 0x03 || parent_ == 0x05 || parent_ == 0x07 ? 2 : 0;
ASSIGN_OR_RETURN(bgr, grass_pal_group[0].GetColor(0)); ASSIGN_OR_RETURN(bgr, grass_pal_group[0].GetColor(0));
} else if (parent_ >= 0x40 && parent_ < 0x80) { } else if (parent_ >= kDarkWorldMapIdStart &&
parent_ < kSpecialWorldMapIdStart) {
pal0 = parent_ == 0x43 || parent_ == 0x45 || parent_ == 0x47 ? 3 : 1; pal0 = parent_ == 0x43 || parent_ == 0x45 || parent_ == 0x47 ? 3 : 1;
ASSIGN_OR_RETURN(bgr, grass_pal_group[0].GetColor(1)); ASSIGN_OR_RETURN(bgr, grass_pal_group[0].GetColor(1));
} else if (parent_ >= 128 && parent_ < kNumOverworldMaps) { } else if (parent_ >= 128 && parent_ < kNumOverworldMaps) {
@@ -610,21 +634,21 @@ absl::Status OverworldMap::LoadPalette() {
auto ow_main_pal_group = rom_.palette_group().overworld_main; auto ow_main_pal_group = rom_.palette_group().overworld_main;
ASSIGN_OR_RETURN(gfx::SnesPalette main, ASSIGN_OR_RETURN(gfx::SnesPalette main,
GetPalette(ow_main_pal_group, pal0, previousPalId, 255)); GetPalette(ow_main_pal_group, pal0, previous_pal_id, 255));
auto ow_animated_pal_group = rom_.palette_group().overworld_animated; auto ow_animated_pal_group = rom_.palette_group().overworld_animated;
ASSIGN_OR_RETURN(gfx::SnesPalette animated, ASSIGN_OR_RETURN(gfx::SnesPalette animated,
GetPalette(ow_animated_pal_group, std::min((int)pal3, 13), GetPalette(ow_animated_pal_group, std::min((int)pal3, 13),
previousPalId, 14)); previous_pal_id, 14));
auto hud_pal_group = rom_.palette_group().hud; auto hud_pal_group = rom_.palette_group().hud;
gfx::SnesPalette hud = hud_pal_group[0]; gfx::SnesPalette hud = hud_pal_group[0];
ASSIGN_OR_RETURN(gfx::SnesPalette spr, ASSIGN_OR_RETURN(gfx::SnesPalette spr,
GetPalette(rom_.palette_group().sprites_aux3, pal4, GetPalette(rom_.palette_group().sprites_aux3, pal4,
previousSprPalId, 24)); previous_spr_pal_id, 24));
ASSIGN_OR_RETURN(gfx::SnesPalette spr2, ASSIGN_OR_RETURN(gfx::SnesPalette spr2,
GetPalette(rom_.palette_group().sprites_aux3, pal5, GetPalette(rom_.palette_group().sprites_aux3, pal5,
previousSprPalId, 24)); previous_spr_pal_id, 24));
RETURN_IF_ERROR(palette_internal::SetColorsPalette( RETURN_IF_ERROR(palette_internal::SetColorsPalette(
rom_, parent_, current_palette_, main, animated, aux1, aux2, hud, bgr, rom_, parent_, current_palette_, main, animated, aux1, aux2, hud, bgr,
@@ -638,7 +662,6 @@ absl::Status OverworldMap::LoadPalette() {
return absl::OkStatus(); return absl::OkStatus();
} }
// New helper function to process graphics buffer.
void OverworldMap::ProcessGraphicsBuffer(int index, int static_graphics_offset, void OverworldMap::ProcessGraphicsBuffer(int index, int static_graphics_offset,
int size) { int size) {
for (int i = 0; i < size; i++) { for (int i = 0; i < size; i++) {
@@ -666,7 +689,7 @@ absl::Status OverworldMap::BuildTileset() {
return absl::OkStatus(); return absl::OkStatus();
} }
absl::Status OverworldMap::BuildTiles16Gfx(std::vector<gfx::Tile16>& tiles16, absl::Status OverworldMap::BuildTiles16Gfx(std::vector<gfx::Tile16> &tiles16,
int count) { int count) {
if (current_blockset_.size() == 0) current_blockset_.resize(0x100000, 0x00); if (current_blockset_.size() == 0) current_blockset_.resize(0x100000, 0x00);
@@ -712,7 +735,7 @@ absl::Status OverworldMap::BuildTiles16Gfx(std::vector<gfx::Tile16>& tiles16,
return absl::OkStatus(); return absl::OkStatus();
} }
absl::Status OverworldMap::BuildBitmap(OverworldBlockset& 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();
} }

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

@@ -10,7 +10,6 @@
#include "app/gfx/snes_palette.h" #include "app/gfx/snes_palette.h"
#include "app/gfx/snes_tile.h" #include "app/gfx/snes_tile.h"
#include "app/rom.h" #include "app/rom.h"
#include "app/zelda3/common.h"
namespace yaze { namespace yaze {
namespace zelda3 { namespace zelda3 {
@@ -55,6 +54,9 @@ constexpr int OverworldCustomTileGFXGroupArray = 0x140480;
// 1 byte, not 0 if enabled // 1 byte, not 0 if enabled
constexpr int OverworldCustomTileGFXGroupEnabled = 0x140148; constexpr int OverworldCustomTileGFXGroupEnabled = 0x140148;
constexpr int kDarkWorldMapIdStart = 0x40;
constexpr int kSpecialWorldMapIdStart = 0x80;
/** /**
* @brief Represents tile32 data for the overworld. * @brief Represents tile32 data for the overworld.
*/ */
@@ -75,7 +77,7 @@ typedef struct OverworldMapTiles {
class OverworldMap : public gfx::GfxContext { class OverworldMap : public gfx::GfxContext {
public: public:
OverworldMap() = default; OverworldMap() = default;
OverworldMap(int index, Rom& rom, bool load_custom_data = false); OverworldMap(int index, Rom& rom);
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,