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

Merge remote-tracking branch 'refs/remotes/origin/master'

Browse Source 
Merge changes made on visual studio repo.
This commit is contained in:
scawful
2025-01-06 11:13:29 -05:00
parent 698b5a43fa 88198323b3
commit 6bf8b62d64
41 changed files with 700 additions and 501 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -30,12 +30,12 @@ class GameEntity {
kProperties = 7,
kDungeonSprite = 8,
} entity_type_;
int x_;
int y_;
int game_x_;
int game_y_;
int entity_id_;
uint16_t map_id_;
int x_ = 0;
int y_ = 0;
int game_x_ = 0;
int game_y_ = 0;
int entity_id_ = 0;
uint16_t map_id_ = 0;
auto set_x(int x) { x_ = x; }
auto set_y(int y) { y_ = y; }

2
src/app/zelda3/dungeon/object_renderer.cc
View File

@@ -102,7 +102,7 @@ void DungeonObjectRenderer::UpdateObjectBitmap() {
int x = column * 8;
int y = row * 8;
auto sheet = rom()->mutable_gfx_sheets()->at(vram_.sheets[sheet_number]);
auto sheet = GraphicsSheetManager::GetInstance().mutable_gfx_sheets()->at(vram_.sheets[sheet_number]);
// Copy the tile from VRAM using the read tile_id
sheet.Get8x8Tile(tile_id, x, y, tilemap_, tilemap_offset);

2
src/app/zelda3/dungeon/object_renderer.h
View File

@@ -17,7 +17,7 @@ namespace yaze {
namespace zelda3 {
struct PseudoVram {
std::array<uint8_t, 16> sheets;
std::array<uint8_t, 16> sheets = { 0 };
std::vector<gfx::SnesPalette> palettes;
};

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();

67
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());
@@ -281,6 +282,7 @@ absl::Status Overworld::LoadOverworldMaps() {
// Wait for all tasks to complete and check their results
for (auto &future : futures) {
future.wait();
RETURN_IF_ERROR(future.get());
}
return absl::OkStatus();
@@ -293,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;
@@ -307,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);
@@ -323,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() {
@@ -447,13 +454,21 @@ absl::Status Overworld::LoadItems() {
}
absl::Status Overworld::LoadSprites() {
for (int i = 0; i < 3; i++) {
all_sprites_.emplace_back();
}
std::vector<std::future<absl::Status>> futures;
futures.emplace_back(std::async(std::launch::async, [this]() {
return LoadSpritesFromMap(kOverworldSpritesBeginning, 64, 0);
}));
futures.emplace_back(std::async(std::launch::async, [this]() {
return LoadSpritesFromMap(kOverworldSpritesZelda, 144, 1);
}));
futures.emplace_back(std::async(std::launch::async, [this]() {
return LoadSpritesFromMap(kOverworldSpritesAgahnim, 144, 2);
}));
RETURN_IF_ERROR(LoadSpritesFromMap(kOverworldSpritesBeginning, 64, 0));
RETURN_IF_ERROR(LoadSpritesFromMap(kOverworldSpritesZelda, 144, 1));
RETURN_IF_ERROR(LoadSpritesFromMap(kOverworldSpritesAgahnim, 144, 2));
for (auto& future : futures) {
future.wait();
RETURN_IF_ERROR(future.get());
}
return absl::OkStatus();
}
@@ -484,8 +499,8 @@ absl::Status Overworld::LoadSpritesFromMap(int sprites_per_gamestate_ptr,
int realX = ((b2 & 0x3F) * 16) + mapX * 512;
int realY = ((b1 & 0x3F) * 16) + mapY * 512;
auto current_gfx = overworld_maps_[i].current_graphics();
all_sprites_[game_state].emplace_back(current_gfx, (uint8_t)i, b3,
all_sprites_[game_state].emplace_back(*overworld_maps_[i].mutable_current_graphics(),
(uint8_t)i, b3,
(uint8_t)(b2 & 0x3F),
(uint8_t)(b1 & 0x3F), realX, realY);
all_sprites_[game_state][i].Draw();
@@ -659,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()) {
@@ -1322,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)));
@@ -1392,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(

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

@@ -109,16 +109,19 @@ constexpr int NumberOfMap32 = Map32PerScreen * kNumOverworldMaps;
*/
class Overworld : public SharedRom {
public:
Overworld(Rom& rom) : rom_(rom) {}
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();
@@ -143,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;
}
@@ -227,7 +232,7 @@ class Overworld : public SharedRom {
int &ttpos);
void DecompressAllMapTiles();
Rom rom_;
Rom& rom_;
bool is_loaded_ = false;
bool expanded_tile16_ = false;
@@ -240,8 +245,8 @@ class Overworld : public SharedRom {
OverworldMapTiles map_tiles_;
std::array<uint8_t, kNumOverworldMaps> map_parent_;
std::array<uint8_t, kNumTileTypes> all_tiles_types_;
std::array<uint8_t, kNumOverworldMaps> map_parent_ = { 0 };
std::array<uint8_t, kNumTileTypes> all_tiles_types_ = { 0 };
std::vector<gfx::Tile16> tiles16_;
std::vector<gfx::Tile32> tiles32_;
std::vector<uint16_t> tiles32_list_;
@@ -251,7 +256,7 @@ class Overworld : public SharedRom {
std::vector<OverworldEntrance> all_holes_;
std::vector<OverworldExit> all_exits_;
std::vector<OverworldItem> all_items_;
std::vector<std::vector<Sprite>> all_sprites_;
std::array<std::vector<Sprite>, 3> all_sprites_;
std::vector<uint64_t> deleted_entrances_;
std::vector<std::vector<uint8_t>> map_data_p1 =
std::vector<std::vector<uint8_t>>(kNumOverworldMaps);

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_];

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

@@ -110,6 +110,7 @@ class OverworldMap : public gfx::GfxContext {
auto static_graphics(int i) const { return static_graphics_[i]; }
auto large_index() const { return large_index_; }
auto mutable_current_graphics() { return &current_gfx_; }
auto mutable_area_graphics() { return &area_graphics_; }
auto mutable_area_palette() { return &area_palette_; }
auto mutable_sprite_graphics(int i) { return &sprite_graphics_[i]; }

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

@@ -17,10 +17,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;

2
src/app/zelda3/sprite/sprite.h
View File

@@ -279,7 +279,7 @@ static const std::string kSpriteDefaultNames[]{
class Sprite : public GameEntity {
public:
Sprite() = default;
Sprite(std::vector<uint8_t> src, uint8_t overworld_map_id, uint8_t id,
Sprite(const std::vector<uint8_t>& src, uint8_t overworld_map_id, uint8_t id,
uint8_t x, uint8_t y, int map_x, int map_y)
: map_id_(static_cast<int>(overworld_map_id)),
id_(id),