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

Refactor ROM handling and update Overworld methods

Browse Source 
Updated MessageEditor, RoomEntrance, and Overworld classes to use WriteByte instead of Write for byte values. Refactored ROM class by removing Write and toint16 methods, moving constants, and updating operator[]. Modified Overworld methods to return absl::Status and handle errors. Updated Inventory and OverworldMap methods to use ReadWord instead of toint16.
This commit is contained in:
Justin Scofield
2025-01-05 21:19:53 -05:00
parent 510581ad1f
commit 88198323b3
8 changed files with 116 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/app/editor/message/message_editor.cc
View File

@@ -626,7 +626,7 @@ absl::Status MessageEditor::Save() {
std::vector<uint8_t> backup = rom()->vector();
for (int i = 0; i < 100; i++) {
RETURN_IF_ERROR(rom()->Write(kCharactersWidth + i, width_array[i]));
RETURN_IF_ERROR(rom()->WriteByte(kCharactersWidth + i, width_array[i]));
}
int pos = kTextData;
@@ -634,7 +634,7 @@ absl::Status MessageEditor::Save() {
for (const auto& message : list_of_texts_) {
for (const auto value : message.Data) {
RETURN_IF_ERROR(rom()->Write(pos, value));
RETURN_IF_ERROR(rom()->WriteByte(pos, value));
if (value == kBlockTerminator) {
// Make sure we didn't go over the space available in the first block.
@@ -652,7 +652,7 @@ absl::Status MessageEditor::Save() {
}
RETURN_IF_ERROR(
rom()->Write(pos++, kMessageTerminator)); // , true, "Terminator text"
rom()->WriteByte(pos++, kMessageTerminator)); // , true, "Terminator text"
}
// Verify that we didn't go over the space available for the second block.
@@ -662,7 +662,7 @@ absl::Status MessageEditor::Save() {
return absl::InternalError(DisplayTextOverflowError(pos, false));
}
RETURN_IF_ERROR(rom()->Write(pos, 0xFF)); // , true, "End of text"
RETURN_IF_ERROR(rom()->WriteByte(pos, 0xFF)); // , true, "End of text"
return absl::OkStatus();
}

22
src/app/rom.cc
View File

@@ -231,6 +231,17 @@ absl::Status Rom::LoadFromPointer(uchar *data, size_t length, bool z3_load) {
return absl::OkStatus();
}
absl::Status Rom::LoadFromBytes(const std::vector<uint8_t>& data) {
if (data.empty()) {
return absl::InvalidArgumentError(
"Could not load ROM: parameter `data` is empty.");
}
rom_data_ = data;
size_ = data.size();
is_loaded_ = true;
return absl::OkStatus();
}
absl::Status Rom::LoadZelda3() {
// Check if the ROM has a header
constexpr size_t kBaseRomSize = 1048576; // 1MB
@@ -267,17 +278,6 @@ absl::Status Rom::LoadZelda3() {
return absl::OkStatus();
}
absl::Status Rom::LoadFromBytes(const std::vector<uint8_t> &data) {
if (data.empty()) {
return absl::InvalidArgumentError(
"Could not load ROM: parameter `data` is empty.");
}
rom_data_ = data;
size_ = data.size();
is_loaded_ = true;
return absl::OkStatus();
}
absl::Status Rom::SaveToFile(bool backup, bool save_new, std::string filename) {
absl::Status non_firing_status;
if (rom_data_.empty()) {

65
src/app/rom.h
View File

@@ -27,6 +27,24 @@
#include "app/gfx/snes_tile.h"
namespace yaze {
constexpr uint32_t kNumGfxSheets = 223;
constexpr uint32_t kNumLinkSheets = 14;
constexpr uint32_t kTile16Ptr = 0x78000;
constexpr uint32_t kNormalGfxSpaceStart = 0x87000;
constexpr uint32_t kNormalGfxSpaceEnd = 0xC4200;
constexpr uint32_t kFontSpriteLocation = 0x70000;
constexpr uint32_t kGfxGroupsPointer = 0x6237;
constexpr uint32_t kUncompressedSheetSize = 0x0800;
constexpr uint32_t kNumMainBlocksets = 37;
constexpr uint32_t kNumRoomBlocksets = 82;
constexpr uint32_t kNumSpritesets = 144;
constexpr uint32_t kNumPalettesets = 72;
constexpr uint32_t kEntranceGfxGroup = 0x5D97;
// TODO: Verify what this was used for in ZS
constexpr uint32_t kMaxGraphics = 0xC3FB5;
/**
* @brief Different versions of the game supported by the Rom class.
*/
@@ -111,22 +129,6 @@ static const std::map<Z3_Version, VersionConstants> kVersionConstantsMap = {
{Z3_Version::RANDO, {}},
};
constexpr uint32_t kNumGfxSheets = 223;
constexpr uint32_t kNumLinkSheets = 14;
constexpr uint32_t kTile16Ptr = 0x78000;
constexpr uint32_t kNormalGfxSpaceStart = 0x87000;
constexpr uint32_t kNormalGfxSpaceEnd = 0xC4200;
constexpr uint32_t kFontSpriteLocation = 0x70000;
constexpr uint32_t kGfxGroupsPointer = 0x6237;
constexpr uint32_t kUncompressedSheetSize = 0x0800;
constexpr uint32_t kNumMainBlocksets = 37;
constexpr uint32_t kNumRoomBlocksets = 82;
constexpr uint32_t kNumSpritesets = 144;
constexpr uint32_t kNumPalettesets = 72;
constexpr uint32_t kEntranceGfxGroup = 0x5D97;
// TODO: Verify what this was used for in ZS
constexpr uint32_t kMaxGraphics = 0xC3FB5;
/**
* @brief The Rom class is used to load, save, and modify Rom data.
@@ -206,7 +208,6 @@ class Rom {
return absl::OkStatus();
}
// Read functions
absl::StatusOr<uint8_t> ReadByte(int offset) {
RETURN_IF_ERROR(ReadWritePreconditions());
if (offset >= static_cast<int>(rom_data_.size())) {
@@ -224,10 +225,6 @@ class Rom {
return result;
}
uint16_t toint16(int offset) {
return (uint16_t)(rom_data_[offset] | (rom_data_[offset + 1] << 8));
}
absl::StatusOr<uint32_t> ReadLong(int offset) {
RETURN_IF_ERROR(ReadWritePreconditions());
if (offset + 2 >= static_cast<int>(rom_data_.size())) {
@@ -254,7 +251,7 @@ class Rom {
absl::StatusOr<gfx::Tile16> ReadTile16(uint32_t tile16_id) {
// Skip 8 bytes per tile.
auto tpos = kTile16Ptr + (tile16_id * 0x08);
gfx::Tile16 tile16;
gfx::Tile16 tile16 = {};
ASSIGN_OR_RETURN(auto new_tile0, ReadWord(tpos))
tile16.tile0_ = gfx::WordToTileInfo(new_tile0);
tpos += 2;
@@ -282,17 +279,6 @@ class Rom {
return absl::OkStatus();
}
// Write functions
absl::Status Write(int addr, int value) {
if (addr >= static_cast<int>(rom_data_.size())) {
return absl::InvalidArgumentError(absl::StrFormat(
"Attempt to write %d value failed, address %d out of range", value,
addr));
}
rom_data_[addr] = value;
return absl::OkStatus();
}
absl::Status WriteByte(int addr, uint8_t value) {
RETURN_IF_ERROR(ReadWritePreconditions());
if (addr >= static_cast<int>(rom_data_.size())) {
@@ -392,9 +378,7 @@ class Rom {
uint8_t& operator[](unsigned long i) {
if (i > size_) {
std::cout << "ROM: Index " << i << " out of bounds, size: " << size_
<< std::endl;
return rom_data_[0];
throw std::out_of_range("Rom index out of range");
}
return rom_data_[i];
}
@@ -407,15 +391,10 @@ class Rom {
return is_loaded_;
}
// Full graphical data for the game
std::vector<uint8_t> graphics_buffer() const { return graphics_buffer_; }
auto mutable_graphics_buffer() { return &graphics_buffer_; }
auto title() const { return title_; }
auto size() const { return size_; }
auto data() const { return rom_data_.data(); }
auto mutable_data() { return rom_data_.data(); }
auto begin() { return rom_data_.begin(); }
auto end() { return rom_data_.end(); }
@@ -424,6 +403,8 @@ class Rom {
auto filename() const { return filename_; }
auto set_filename(std::string name) { filename_ = name; }
std::vector<uint8_t> graphics_buffer() const { return graphics_buffer_; }
auto mutable_graphics_buffer() { return &graphics_buffer_; }
auto palette_group() const { return palette_groups_; }
auto mutable_palette_group() { return &palette_groups_; }
auto dungeon_palette(int i) { return palette_groups_.dungeon_main[i]; }
@@ -451,7 +432,7 @@ class Rom {
private:
virtual absl::Status WriteHelper(const WriteAction& action) {
if (std::holds_alternative<uint8_t>(action.value)) {
return Write(action.address, std::get<uint8_t>(action.value));
return WriteByte(action.address, std::get<uint8_t>(action.value));
} else if (std::holds_alternative<uint16_t>(action.value) ||
std::holds_alternative<short>(action.value)) {
return WriteShort(action.address, std::get<uint16_t>(action.value));

64
src/app/zelda3/dungeon/room_entrance.h
View File

@@ -220,37 +220,37 @@ class RoomEntrance {
RETURN_IF_ERROR(rom.WriteShort(
kEntranceCameraYTrigger + (entrance_id * 2), camera_trigger_y_));
RETURN_IF_ERROR(rom.WriteShort(kEntranceExit + (entrance_id * 2), exit_));
RETURN_IF_ERROR(rom.Write(kEntranceBlockset + entrance_id,
RETURN_IF_ERROR(rom.WriteByte(kEntranceBlockset + entrance_id,
(uint8_t)(blockset_ & 0xFF)));
RETURN_IF_ERROR(
rom.Write(kEntranceMusic + entrance_id, (uint8_t)(music_ & 0xFF)));
RETURN_IF_ERROR(rom.Write(kEntranceDungeon + entrance_id,
rom.WriteByte(kEntranceMusic + entrance_id, (uint8_t)(music_ & 0xFF)));
RETURN_IF_ERROR(rom.WriteByte(kEntranceDungeon + entrance_id,
(uint8_t)(dungeon_id_ & 0xFF)));
RETURN_IF_ERROR(
rom.Write(kEntranceDoor + entrance_id, (uint8_t)(door_ & 0xFF)));
rom.WriteByte(kEntranceDoor + entrance_id, (uint8_t)(door_ & 0xFF)));
RETURN_IF_ERROR(
rom.Write(kEntranceFloor + entrance_id, (uint8_t)(floor_ & 0xFF)));
RETURN_IF_ERROR(rom.Write(kEntranceLadderBG + entrance_id,
rom.WriteByte(kEntranceFloor + entrance_id, (uint8_t)(floor_ & 0xFF)));
RETURN_IF_ERROR(rom.WriteByte(kEntranceLadderBG + entrance_id,
(uint8_t)(ladder_bg_ & 0xFF)));
RETURN_IF_ERROR(rom.Write(kEntrancescrolling + entrance_id,
RETURN_IF_ERROR(rom.WriteByte(kEntrancescrolling + entrance_id,
(uint8_t)(scrolling_ & 0xFF)));
RETURN_IF_ERROR(rom.Write(kEntranceScrollQuadrant + entrance_id,
RETURN_IF_ERROR(rom.WriteByte(kEntranceScrollQuadrant + entrance_id,
(uint8_t)(scroll_quadrant_ & 0xFF)));
RETURN_IF_ERROR(rom.Write(kEntranceScrollEdge + 0 + (entrance_id * 8),
RETURN_IF_ERROR(rom.WriteByte(kEntranceScrollEdge + 0 + (entrance_id * 8),
camera_boundary_qn_));
RETURN_IF_ERROR(rom.Write(kEntranceScrollEdge + 1 + (entrance_id * 8),
RETURN_IF_ERROR(rom.WriteByte(kEntranceScrollEdge + 1 + (entrance_id * 8),
camera_boundary_fn_));
RETURN_IF_ERROR(rom.Write(kEntranceScrollEdge + 2 + (entrance_id * 8),
RETURN_IF_ERROR(rom.WriteByte(kEntranceScrollEdge + 2 + (entrance_id * 8),
camera_boundary_qs_));
RETURN_IF_ERROR(rom.Write(kEntranceScrollEdge + 3 + (entrance_id * 8),
RETURN_IF_ERROR(rom.WriteByte(kEntranceScrollEdge + 3 + (entrance_id * 8),
camera_boundary_fs_));
RETURN_IF_ERROR(rom.Write(kEntranceScrollEdge + 4 + (entrance_id * 8),
RETURN_IF_ERROR(rom.WriteByte(kEntranceScrollEdge + 4 + (entrance_id * 8),
camera_boundary_qw_));
RETURN_IF_ERROR(rom.Write(kEntranceScrollEdge + 5 + (entrance_id * 8),
RETURN_IF_ERROR(rom.WriteByte(kEntranceScrollEdge + 5 + (entrance_id * 8),
camera_boundary_fw_));
RETURN_IF_ERROR(rom.Write(kEntranceScrollEdge + 6 + (entrance_id * 8),
RETURN_IF_ERROR(rom.WriteByte(kEntranceScrollEdge + 6 + (entrance_id * 8),
camera_boundary_qe_));
RETURN_IF_ERROR(rom.Write(kEntranceScrollEdge + 7 + (entrance_id * 8),
RETURN_IF_ERROR(rom.WriteByte(kEntranceScrollEdge + 7 + (entrance_id * 8),
camera_boundary_fe_));
} else {
RETURN_IF_ERROR(
@@ -271,45 +271,45 @@ class RoomEntrance {
camera_trigger_y_));
RETURN_IF_ERROR(
rom.WriteShort(kStartingEntranceexit + (entrance_id * 2), exit_));
RETURN_IF_ERROR(rom.Write(kStartingEntranceBlockset + entrance_id,
RETURN_IF_ERROR(rom.WriteByte(kStartingEntranceBlockset + entrance_id,
(uint8_t)(blockset_ & 0xFF)));
RETURN_IF_ERROR(rom.Write(kStartingEntrancemusic + entrance_id,
RETURN_IF_ERROR(rom.WriteByte(kStartingEntrancemusic + entrance_id,
(uint8_t)(music_ & 0xFF)));
RETURN_IF_ERROR(rom.Write(kStartingEntranceDungeon + entrance_id,
RETURN_IF_ERROR(rom.WriteByte(kStartingEntranceDungeon + entrance_id,
(uint8_t)(dungeon_id_ & 0xFF)));
RETURN_IF_ERROR(rom.Write(kStartingEntranceDoor + entrance_id,
RETURN_IF_ERROR(rom.WriteByte(kStartingEntranceDoor + entrance_id,
(uint8_t)(door_ & 0xFF)));
RETURN_IF_ERROR(rom.Write(kStartingEntranceFloor + entrance_id,
RETURN_IF_ERROR(rom.WriteByte(kStartingEntranceFloor + entrance_id,
(uint8_t)(floor_ & 0xFF)));
RETURN_IF_ERROR(rom.Write(kStartingEntranceLadderBG + entrance_id,
RETURN_IF_ERROR(rom.WriteByte(kStartingEntranceLadderBG + entrance_id,
(uint8_t)(ladder_bg_ & 0xFF)));
RETURN_IF_ERROR(rom.Write(kStartingEntrancescrolling + entrance_id,
RETURN_IF_ERROR(rom.WriteByte(kStartingEntrancescrolling + entrance_id,
(uint8_t)(scrolling_ & 0xFF)));
RETURN_IF_ERROR(rom.Write(kStartingEntranceScrollQuadrant + entrance_id,
RETURN_IF_ERROR(rom.WriteByte(kStartingEntranceScrollQuadrant + entrance_id,
(uint8_t)(scroll_quadrant_ & 0xFF)));
RETURN_IF_ERROR(
rom.Write(kStartingEntranceScrollEdge + 0 + (entrance_id * 8),
rom.WriteByte(kStartingEntranceScrollEdge + 0 + (entrance_id * 8),
camera_boundary_qn_));
RETURN_IF_ERROR(
rom.Write(kStartingEntranceScrollEdge + 1 + (entrance_id * 8),
rom.WriteByte(kStartingEntranceScrollEdge + 1 + (entrance_id * 8),
camera_boundary_fn_));
RETURN_IF_ERROR(
rom.Write(kStartingEntranceScrollEdge + 2 + (entrance_id * 8),
rom.WriteByte(kStartingEntranceScrollEdge + 2 + (entrance_id * 8),
camera_boundary_qs_));
RETURN_IF_ERROR(
rom.Write(kStartingEntranceScrollEdge + 3 + (entrance_id * 8),
rom.WriteByte(kStartingEntranceScrollEdge + 3 + (entrance_id * 8),
camera_boundary_fs_));
RETURN_IF_ERROR(
rom.Write(kStartingEntranceScrollEdge + 4 + (entrance_id * 8),
rom.WriteByte(kStartingEntranceScrollEdge + 4 + (entrance_id * 8),
camera_boundary_qw_));
RETURN_IF_ERROR(
rom.Write(kStartingEntranceScrollEdge + 5 + (entrance_id * 8),
rom.WriteByte(kStartingEntranceScrollEdge + 5 + (entrance_id * 8),
camera_boundary_fw_));
RETURN_IF_ERROR(
rom.Write(kStartingEntranceScrollEdge + 6 + (entrance_id * 8),
rom.WriteByte(kStartingEntranceScrollEdge + 6 + (entrance_id * 8),
camera_boundary_qe_));
RETURN_IF_ERROR(
rom.Write(kStartingEntranceScrollEdge + 7 + (entrance_id * 8),
rom.WriteByte(kStartingEntranceScrollEdge + 7 + (entrance_id * 8),
camera_boundary_fe_));
}
return absl::OkStatus();

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

@@ -25,7 +25,8 @@ absl::Status Overworld::Load(Rom &rom) {
overworld_maps_.emplace_back(map_index, rom_);
FetchLargeMaps();
LoadEntrances();
RETURN_IF_ERROR(LoadEntrances());
RETURN_IF_ERROR(LoadHoles());
RETURN_IF_ERROR(LoadExits());
RETURN_IF_ERROR(LoadItems());
RETURN_IF_ERROR(LoadSprites());
@@ -294,7 +295,7 @@ void Overworld::LoadTileTypes() {
}
}
void Overworld::LoadEntrances() {
absl::Status Overworld::LoadEntrances() {
int ow_entrance_map_ptr = kOverworldEntranceMap;
int ow_entrance_pos_ptr = kOverworldEntrancePos;
int ow_entrance_id_ptr = kOverworldEntranceEntranceId;
@@ -308,9 +309,9 @@ void Overworld::LoadEntrances() {
}
for (int i = 0; i < num_entrances; i++) {
short map_id = rom()->toint16(ow_entrance_map_ptr + (i * 2));
uint16_t map_pos = rom()->toint16(ow_entrance_pos_ptr + (i * 2));
uint8_t entrance_id = rom_[ow_entrance_id_ptr + i];
ASSIGN_OR_RETURN(auto map_id, rom()->ReadWord(ow_entrance_map_ptr + (i * 2)));
ASSIGN_OR_RETURN(auto map_pos, rom()->ReadWord(ow_entrance_pos_ptr + (i * 2)));
ASSIGN_OR_RETURN(auto entrance_id, rom()->ReadByte(ow_entrance_id_ptr + i));
int p = map_pos >> 1;
int x = (p % 64);
int y = (p >> 6);
@@ -324,20 +325,25 @@ void Overworld::LoadEntrances() {
deleted);
}
for (int i = 0; i < 0x13; i++) {
auto map_id = (short)((rom_[kOverworldHoleArea + (i * 2) + 1] << 8) +
(rom_[kOverworldHoleArea + (i * 2)]));
auto map_pos = (short)((rom_[kOverworldHolePos + (i * 2) + 1] << 8) +
(rom_[kOverworldHolePos + (i * 2)]));
uint8_t entrance_id = (rom_[kOverworldHoleEntrance + i]);
return absl::OkStatus();
}
absl::Status Overworld::LoadHoles() {
constexpr int kNumHoles = 0x13;
for (int i = 0; i < kNumHoles; i++) {
ASSIGN_OR_RETURN(auto map_id, rom()->ReadWord(kOverworldHoleArea + (i * 2)));
ASSIGN_OR_RETURN(auto map_pos, rom()->ReadWord(kOverworldHolePos + (i * 2)));
ASSIGN_OR_RETURN(auto entrance_id, rom()->ReadByte(kOverworldHoleEntrance + i));
int p = (map_pos + 0x400) >> 1;
int x = (p % 64);
int y = (p >> 6);
all_holes_.emplace_back(
(x * 16) + (((map_id % 64) - (((map_id % 64) / 8) * 8)) * 512),
(y * 16) + (((map_id % 64) / 8) * 512), entrance_id, map_id,
(uint16_t)(map_pos + 0x400), true);
(x * 16) + (((map_id % 64) - (((map_id % 64) / 8) * 8)) * 512),
(y * 16) + (((map_id % 64) / 8) * 512), entrance_id, map_id,
(uint16_t)(map_pos + 0x400), true);
}
return absl::OkStatus();
}
absl::Status Overworld::LoadExits() {
@@ -668,7 +674,7 @@ absl::Status Overworld::SaveLargeMaps() {
// Always write the map parent since it should not matter
RETURN_IF_ERROR(
rom()->Write(kOverworldMapParentId + i, overworld_maps_[i].parent()))
rom()->WriteByte(kOverworldMapParentId + i, overworld_maps_[i].parent()))
if (std::find(checked_map.begin(), checked_map.end(), i) !=
checked_map.end()) {
@@ -1331,10 +1337,10 @@ absl::Status Overworld::SaveMap16Expanded() {
RETURN_IF_ERROR(rom()->WriteShort(core::SnesToPc(0x02FE33),
core::PcToSnes(kMap16TilesExpanded + 6)));
RETURN_IF_ERROR(rom()->Write(
RETURN_IF_ERROR(rom()->WriteByte(
core::SnesToPc(0x02FD28),
static_cast<uint8_t>(core::PcToSnes(kMap16TilesExpanded) >> 16)));
RETURN_IF_ERROR(rom()->Write(
RETURN_IF_ERROR(rom()->WriteByte(
core::SnesToPc(0x02FD39),
static_cast<uint8_t>(core::PcToSnes(kMap16TilesExpanded) >> 16)));
@@ -1401,7 +1407,7 @@ absl::Status Overworld::SaveExits() {
for (int i = 0; i < kNumOverworldExits; i++) {
RETURN_IF_ERROR(
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()->WriteByte(OWExitMapId + i, all_exits_[i].map_id_));
RETURN_IF_ERROR(
rom()->WriteShort(OWExitVram + (i * 2), all_exits_[i].map_pos_));
RETURN_IF_ERROR(

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

@@ -114,13 +114,14 @@ class Overworld : public SharedRom {
absl::Status Load(Rom &rom);
absl::Status LoadOverworldMaps();
void LoadTileTypes();
void LoadEntrances();
absl::Status LoadEntrances();
absl::Status LoadHoles();
absl::Status LoadExits();
absl::Status LoadItems();
absl::Status LoadSprites();
absl::Status LoadSpritesFromMap(int spriteStart, int spriteCount,
int spriteIndex);
absl::Status LoadSpritesFromMap(int sprite_start, int sprite_count,
int sprite_index);
absl::Status Save(Rom &rom);
absl::Status SaveOverworldMaps();
@@ -145,7 +146,9 @@ class Overworld : public SharedRom {
all_entrances_.clear();
all_exits_.clear();
all_items_.clear();
all_sprites_.clear();
for (auto& sprites : all_sprites_) {
sprites.clear();
}
is_loaded_ = false;
}

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

@@ -71,7 +71,13 @@ void OverworldMap::LoadAreaInfo() {
}
}
message_id_ = rom_.toint16(kOverworldMessageIds + (parent_ * 2));
auto message_id = rom_.ReadWord(kOverworldMessageIds + (parent_ * 2));
if (message_id.ok()) {
message_id_ = message_id.value();
} else {
message_id_ = 0;
core::logf("Error reading message id for map %d", parent_);
}
if (index_ < kDarkWorldMapIdStart) {
area_graphics_ = rom_[kAreaGfxIdPtr + parent_];

12
src/app/zelda3/screen/inventory.cc
View File

@@ -19,10 +19,14 @@ absl::Status Inventory::Create() {
}
RETURN_IF_ERROR(BuildTileset())
for (int i = 0; i < 0x500; i += 0x08) {
tiles_.push_back(gfx::GetTilesInfo(rom()->toint16(i + kBowItemPos)));
tiles_.push_back(gfx::GetTilesInfo(rom()->toint16(i + kBowItemPos + 0x02)));
tiles_.push_back(gfx::GetTilesInfo(rom()->toint16(i + kBowItemPos + 0x04)));
tiles_.push_back(gfx::GetTilesInfo(rom()->toint16(i + kBowItemPos + 0x08)));
ASSIGN_OR_RETURN(auto t1, rom()->ReadWord(i + kBowItemPos));
ASSIGN_OR_RETURN(auto t2, rom()->ReadWord(i + kBowItemPos + 0x02));
ASSIGN_OR_RETURN(auto t3, rom()->ReadWord(i + kBowItemPos + 0x04));
ASSIGN_OR_RETURN(auto t4, rom()->ReadWord(i + kBowItemPos + 0x06));
tiles_.push_back(gfx::GetTilesInfo(t1));
tiles_.push_back(gfx::GetTilesInfo(t2));
tiles_.push_back(gfx::GetTilesInfo(t3));
tiles_.push_back(gfx::GetTilesInfo(t4));
}
const int offsets[] = {0x00, 0x08, 0x800, 0x808};
auto xx = 0;