overworld_entrance.cc

Go to the documentation of this file.

#include "zelda3/overworld/overworld_entrance.h"
 
#include <algorithm>
#include <cstddef>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "rom/rom.h"
#include "util/macro.h"
#include "zelda3/overworld/overworld_version_helper.h"
 
namespace yaze::zelda3 {
namespace {
 
bool HasExpandedEntranceTables(const Rom& rom,
                               const core::RomAddressOverrides& addresses) {
  const auto version = OverworldVersionHelper::GetVersion(rom);
  if (version == OverworldVersion::kVanilla) {
    return false;
  }
  const auto flag_addr =
      addresses.GetAddress(core::RomAddressKey::kOverworldEntranceFlagExpanded)
          .value_or(kOverworldEntranceExpandedFlagPos);
  if (flag_addr >= rom.size()) {
    return false;
  }
  return rom.data()[flag_addr] != 0xB8;
}
 
}  // namespace
 
absl::StatusOr<std::vector<OverworldEntrance>> LoadEntrances(Rom* rom) {
  return LoadEntrances(rom, core::RomSettings::Get().address_overrides());
}
 
absl::StatusOr<std::vector<OverworldEntrance>> LoadEntrances(
    Rom* rom, const core::RomAddressOverrides& addresses) {
  std::vector<OverworldEntrance> entrances;
  int ow_entrance_map_ptr = kOverworldEntranceMap;
  int ow_entrance_pos_ptr = kOverworldEntrancePos;
  int ow_entrance_id_ptr = kOverworldEntranceEntranceId;
  int num_entrances = 129;
 
  // Check if expanded entrance data is actually present in ROM
  // The flag position should contain 0xB8 for vanilla, something else for
  // expanded
  if (HasExpandedEntranceTables(*rom, addresses)) {
    // ROM has expanded entrance data - use expanded addresses
    ow_entrance_map_ptr =
        addresses.GetAddress(core::RomAddressKey::kOverworldEntranceMapExpanded)
            .value_or(kOverworldEntranceMapExpanded);
    ow_entrance_pos_ptr =
        addresses.GetAddress(core::RomAddressKey::kOverworldEntrancePosExpanded)
            .value_or(kOverworldEntrancePosExpanded);
    ow_entrance_id_ptr =
        addresses.GetAddress(core::RomAddressKey::kOverworldEntranceIdExpanded)
            .value_or(kOverworldEntranceEntranceIdExpanded);
    num_entrances = 256;  // Expanded entrance count
  }
  // Otherwise use vanilla addresses (already set above)
 
  for (int i = 0; i < num_entrances; 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);
    bool deleted = false;
    if (map_pos == 0xFFFF) {
      deleted = true;
    }
    entrances.emplace_back(
        (x * 16) + (((map_id % 64) - (((map_id % 64) / 8) * 8)) * 512),
        (y * 16) + (((map_id % 64) / 8) * 512), entrance_id, map_id, map_pos,
        deleted);
  }
 
  return entrances;
}
 
absl::StatusOr<std::vector<OverworldEntrance>> LoadHoles(Rom* rom) {
  constexpr int kNumHoles = 0x13;
  std::vector<OverworldEntrance> holes;
  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);
    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);
  }
  return holes;
}
 
absl::Status SaveEntrances(Rom* rom,
                           const std::vector<OverworldEntrance>& entrances,
                           bool expanded_entrances) {
  auto write_entrance = [&](int index, uint32_t map_addr, uint32_t pos_addr,
                            uint32_t id_addr) -> absl::Status {
    // Mirrors ZeldaFullEditor/Save.cs::SaveOWEntrances (see lines ~1081-1085)
    // where MapID and MapPos are written as 16-bit words and EntranceID as a
    // byte.
    RETURN_IF_ERROR(rom->WriteShort(map_addr, entrances[index].map_id_));
    RETURN_IF_ERROR(rom->WriteShort(pos_addr, entrances[index].map_pos_));
    RETURN_IF_ERROR(rom->WriteByte(id_addr, entrances[index].entrance_id_));
    return absl::OkStatus();
  };
 
  // Always keep the legacy tables in sync for pure vanilla ROMs so e.g. Hyrule
  // Magic expects them. ZScream does the same in SaveOWEntrances.
  const int legacy_count =
      std::min<int>(kNumOverworldEntrances, entrances.size());
  for (int i = 0; i < legacy_count; ++i) {
    RETURN_IF_ERROR(write_entrance(i, kOverworldEntranceMap + (i * 2),
                                   kOverworldEntrancePos + (i * 2),
                                   kOverworldEntranceEntranceId + i));
  }
 
  if (expanded_entrances) {
    // For ZS v3+ ROMs, mirror writes into the expanded tables the way
    // ZeldaFullEditor does when the ASM patch is active.
    constexpr int kExpandedOverworldEntrances = 256;
    const int expanded_count =
        std::min<int>(kExpandedOverworldEntrances, entrances.size());
    for (int i = 0; i < expanded_count; ++i) {
      RETURN_IF_ERROR(
          write_entrance(i, GetOverworldEntranceMapExpanded() + (i * 2),
                         GetOverworldEntrancePosExpanded() + (i * 2),
                         GetOverworldEntranceIdExpanded() + i));
    }
  }
 
  return absl::OkStatus();
}
 
absl::Status SaveHoles(Rom* rom, const std::vector<OverworldEntrance>& holes) {
  for (int i = 0; i < kNumOverworldHoles; ++i) {
    RETURN_IF_ERROR(
        rom->WriteShort(kOverworldHoleArea + (i * 2), holes[i].map_id_));
 
    // ZeldaFullEditor/Data/Overworld.cs::LoadHoles() adds 0x400 when loading
    // (see lines ~1006-1014). SaveOWEntrances subtracts it before writing
    // (Save.cs lines ~1088-1092). We replicate that here so vanilla ROMs
    // receive the expected values.
    uint16_t rom_map_pos = static_cast<uint16_t>(holes[i].map_pos_ >= 0x400
                                                     ? holes[i].map_pos_ - 0x400
                                                     : holes[i].map_pos_);
    RETURN_IF_ERROR(rom->WriteShort(kOverworldHolePos + (i * 2), rom_map_pos));
    RETURN_IF_ERROR(
        rom->WriteByte(kOverworldHoleEntrance + i, holes[i].entrance_id_));
  }
 
  return absl::OkStatus();
}
 
}  // namespace yaze::zelda3