overworld_item.cc

Go to the documentation of this file.

#include "zelda3/overworld/overworld_item.h"
 
#include <algorithm>
#include <cstdint>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "rom/rom.h"
#include "rom/snes.h"
#include "util/log.h"
#include "util/macro.h"
#include "zelda3/common.h"
#include "zelda3/overworld/overworld_map.h"
#include "zelda3/overworld/overworld_version_helper.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.
  auto version = OverworldVersionHelper::GetVersion(*rom);
 
  // 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 = OverworldVersionHelper::SupportsAreaEnum(version)
                   ? 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 auto version = OverworldVersionHelper::GetVersion(*rom);
  const int pointer_count = OverworldVersionHelper::SupportsAreaEnum(version)
                                ? zelda3::kNumOverworldMaps
                                : zelda3::kNumOverworldMapItemPointers;
 
  std::vector<std::vector<OverworldItem>> room_items(pointer_count);
 
  // Reset bomb door lookup table used by special item (0x86)
  for (int i = 0; i < pointer_count; ++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, pointer_count - 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 < pointer_count; ++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