208 lines
6.5 KiB
C++
208 lines
6.5 KiB
C++
#include "zelda3/overworld/overworld_item.h"
|
|
|
|
#include <algorithm>
|
|
#include <cstdint>
|
|
#include <vector>
|
|
|
|
#include "absl/status/status.h"
|
|
#include "absl/status/statusor.h"
|
|
#include "app/rom.h"
|
|
#include "app/snes.h"
|
|
#include "util/log.h"
|
|
#include "util/macro.h"
|
|
#include "zelda3/common.h"
|
|
#include "zelda3/overworld/overworld_map.h"
|
|
|
|
namespace yaze::zelda3 {
|
|
|
|
absl::StatusOr<std::vector<OverworldItem>> LoadItems(
|
|
Rom* rom, std::vector<OverworldMap>& overworld_maps) {
|
|
std::vector<OverworldItem> items;
|
|
|
|
// Version 0x03 of the OW ASM added item support for the SW.
|
|
uint8_t asm_version = (*rom)[OverworldCustomASMHasBeenApplied];
|
|
|
|
// Determine max number of overworld maps based on actual ASM version
|
|
// Only use expanded maps (0xA0) if v3+ ASM is actually applied
|
|
int max_ow =
|
|
(asm_version >= 0x03 && asm_version != 0xFF) ? kNumOverworldMaps : 0x80;
|
|
|
|
ASSIGN_OR_RETURN(uint32_t pointer_snes,
|
|
rom->ReadLong(zelda3::overworldItemsAddress));
|
|
uint32_t item_pointer_address =
|
|
SnesToPc(pointer_snes); // 0x1BC2F9 -> 0x0DC2F9
|
|
|
|
for (int i = 0; i < max_ow; i++) {
|
|
ASSIGN_OR_RETURN(uint8_t bank_byte,
|
|
rom->ReadByte(zelda3::overworldItemsAddressBank));
|
|
int bank = bank_byte & 0x7F;
|
|
|
|
ASSIGN_OR_RETURN(uint8_t addr_low,
|
|
rom->ReadByte(item_pointer_address + (i * 2)));
|
|
ASSIGN_OR_RETURN(uint8_t addr_high,
|
|
rom->ReadByte(item_pointer_address + (i * 2) + 1));
|
|
|
|
uint32_t addr = (bank << 16) + // 1B
|
|
(addr_high << 8) + // F9
|
|
addr_low; // 3C
|
|
addr = SnesToPc(addr);
|
|
|
|
// Check if this is a large map and skip if not the parent
|
|
if (overworld_maps[i].area_size() != zelda3::AreaSizeEnum::SmallArea) {
|
|
if (overworld_maps[i].parent() != (uint8_t)i) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
while (true) {
|
|
ASSIGN_OR_RETURN(uint8_t b1, rom->ReadByte(addr));
|
|
ASSIGN_OR_RETURN(uint8_t b2, rom->ReadByte(addr + 1));
|
|
ASSIGN_OR_RETURN(uint8_t b3, rom->ReadByte(addr + 2));
|
|
|
|
if (b1 == 0xFF && b2 == 0xFF) {
|
|
break;
|
|
}
|
|
|
|
int p = (((b2 & 0x1F) << 8) + b1) >> 1;
|
|
|
|
int x = p % 0x40; // Use 0x40 instead of 64 to match ZS
|
|
int y = p >> 6;
|
|
|
|
int fakeID = i % 0x40; // Use modulo 0x40 to match ZS
|
|
|
|
int sy = fakeID / 8;
|
|
int sx = fakeID - (sy * 8);
|
|
|
|
items.emplace_back(b3, (uint16_t)i, (x * 16) + (sx * 512),
|
|
(y * 16) + (sy * 512), false);
|
|
auto size = items.size();
|
|
|
|
items[size - 1].game_x_ = (uint8_t)x;
|
|
items[size - 1].game_y_ = (uint8_t)y;
|
|
addr += 3;
|
|
}
|
|
}
|
|
return items;
|
|
}
|
|
|
|
absl::Status SaveItems(Rom* rom, const std::vector<OverworldItem>& items) {
|
|
const int pointer_count = zelda3::kNumOverworldMaps;
|
|
|
|
std::vector<std::vector<OverworldItem>> room_items(pointer_count);
|
|
|
|
// Reset bomb door lookup table used by special item (0x86)
|
|
for (int i = 0; i < zelda3::kNumOverworldMaps; ++i) {
|
|
RETURN_IF_ERROR(rom->WriteShort(
|
|
zelda3::kOverworldBombDoorItemLocationsNew + (i * 2), 0x0000));
|
|
}
|
|
|
|
for (const OverworldItem& item : items) {
|
|
if (item.deleted)
|
|
continue;
|
|
|
|
const int map_index = static_cast<int>(item.room_map_id_);
|
|
if (map_index < 0 || map_index >= pointer_count) {
|
|
LOG_WARN(
|
|
"Overworld::SaveItems",
|
|
"Skipping item with map index %d outside pointer table (size=%d)",
|
|
map_index, pointer_count);
|
|
continue;
|
|
}
|
|
|
|
room_items[map_index].push_back(item);
|
|
|
|
if (item.id_ == 0x86) {
|
|
const int lookup_index =
|
|
std::min(map_index, zelda3::kNumOverworldMaps - 1);
|
|
RETURN_IF_ERROR(rom->WriteShort(
|
|
zelda3::kOverworldBombDoorItemLocationsNew + (lookup_index * 2),
|
|
static_cast<uint16_t>((item.game_x_ + (item.game_y_ * 64)) * 2)));
|
|
}
|
|
}
|
|
|
|
// Prepare pointer reuse cache
|
|
std::vector<int> item_pointers(pointer_count, -1);
|
|
std::vector<int> item_pointers_reuse(pointer_count, -1);
|
|
|
|
for (int i = 0; i < pointer_count; ++i) {
|
|
item_pointers_reuse[i] = -1;
|
|
for (int ci = 0; ci < i; ++ci) {
|
|
if (room_items[i].empty()) {
|
|
item_pointers_reuse[i] = -2; // reuse empty terminator
|
|
break;
|
|
}
|
|
|
|
if (CompareItemsArrays(room_items[i], room_items[ci])) {
|
|
item_pointers_reuse[i] = ci;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Item data always lives in the vanilla data block
|
|
int data_pos = zelda3::kOverworldItemsStartDataNew;
|
|
int empty_pointer = -1;
|
|
|
|
for (int i = 0; i < pointer_count; ++i) {
|
|
if (item_pointers_reuse[i] == -1) {
|
|
item_pointers[i] = data_pos;
|
|
for (const OverworldItem& item : room_items[i]) {
|
|
const uint16_t map_pos =
|
|
static_cast<uint16_t>(((item.game_y_ << 6) + item.game_x_) << 1);
|
|
const uint32_t data =
|
|
static_cast<uint32_t>(map_pos & 0xFF) |
|
|
(static_cast<uint32_t>((map_pos >> 8) & 0xFF) << 8) |
|
|
(static_cast<uint32_t>(item.id_) << 16);
|
|
|
|
RETURN_IF_ERROR(rom->WriteLong(data_pos, data));
|
|
data_pos += 3;
|
|
}
|
|
|
|
empty_pointer = data_pos;
|
|
RETURN_IF_ERROR(rom->WriteShort(data_pos, 0xFFFF));
|
|
data_pos += 2;
|
|
} else if (item_pointers_reuse[i] == -2) {
|
|
if (empty_pointer < 0) {
|
|
item_pointers[i] = data_pos;
|
|
empty_pointer = data_pos;
|
|
RETURN_IF_ERROR(rom->WriteShort(data_pos, 0xFFFF));
|
|
data_pos += 2;
|
|
} else {
|
|
item_pointers[i] = empty_pointer;
|
|
}
|
|
} else {
|
|
item_pointers[i] = item_pointers[item_pointers_reuse[i]];
|
|
}
|
|
}
|
|
|
|
if (data_pos > kOverworldItemsEndData) {
|
|
return absl::AbortedError("Too many items");
|
|
}
|
|
|
|
// Update pointer table metadata to the expanded location used by ZScream
|
|
RETURN_IF_ERROR(rom->WriteLong(zelda3::overworldItemsAddress,
|
|
PcToSnes(zelda3::kOverworldItemsPointersNew)));
|
|
RETURN_IF_ERROR(rom->WriteByte(
|
|
zelda3::overworldItemsAddressBank,
|
|
static_cast<uint8_t>(
|
|
(PcToSnes(zelda3::kOverworldItemsStartDataNew) >> 16) & 0xFF)));
|
|
|
|
// Clear pointer table (write zero) to avoid stale values when pointer count shrinks
|
|
for (int i = 0; i < zelda3::kNumOverworldMaps; ++i) {
|
|
RETURN_IF_ERROR(
|
|
rom->WriteShort(zelda3::kOverworldItemsPointersNew + (i * 2), 0x0000));
|
|
}
|
|
|
|
for (int i = 0; i < pointer_count; ++i) {
|
|
const uint32_t snes_addr = PcToSnes(item_pointers[i]);
|
|
RETURN_IF_ERROR(
|
|
rom->WriteShort(zelda3::kOverworldItemsPointersNew + (i * 2),
|
|
static_cast<uint16_t>(snes_addr & 0xFFFF)));
|
|
}
|
|
|
|
util::logf("End of Items : %d", data_pos);
|
|
|
|
return absl::OkStatus();
|
|
}
|
|
|
|
} // namespace yaze::zelda3
|