room_layout.cc

Go to the documentation of this file.

#include "room_layout.h"
 
#include <algorithm>
#include <utility>
 
#include "absl/strings/str_format.h"
#include "rom/snes.h"
#include "util/log.h"
#include "zelda3/dungeon/dungeon_rom_addresses.h"
#include "zelda3/dungeon/object_drawer.h"
 
namespace yaze::zelda3 {
 
absl::StatusOr<int> RoomLayout::GetLayoutAddress(int layout_id) const {
  if (!rom_ || !rom_->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
 
  if (layout_id < 0 ||
      layout_id >= static_cast<int>(kRoomLayoutPointers.size())) {
    return absl::InvalidArgumentError(
        absl::StrFormat("Invalid layout id %d", layout_id));
  }
 
  uint32_t snes_addr = kRoomLayoutPointers[layout_id];
  int pc_addr = SnesToPc(static_cast<int>(snes_addr));
  if (pc_addr < 0 || pc_addr >= static_cast<int>(rom_->vector().size())) {
    return absl::OutOfRangeError(
        absl::StrFormat("Layout pointer %d out of range", layout_id));
  }
  return pc_addr;
}
 
absl::Status RoomLayout::LoadLayout(int layout_id, util::StopToken stop_token) {
  objects_.clear();
  if (stop_token.stop_requested()) {
    return absl::CancelledError("Room layout load cancelled");
  }
 
  auto addr_result = GetLayoutAddress(layout_id);
  if (!addr_result.ok()) {
    return addr_result.status();
  }
 
  int pos = addr_result.value();
  const int next = layout_id + 1 < static_cast<int>(kRoomLayoutPointers.size())
                       ? kRoomLayoutPointers[layout_id + 1]
                       : kRoomLayoutDataEnd;
  const int end = std::min(static_cast<int>(SnesToPc(next)),
                           static_cast<int>(rom_->vector().size()));
  const auto& rom_data = rom_->data();
  int layer = 0;
  std::vector<RoomObject> decoded;
 
  LOG_DEBUG("RoomLayout", "Loading layout %d from PC address 0x%05X", layout_id,
            pos);
 
  int obj_index = 0;
  while (pos < end) {
    if (stop_token.stop_requested()) {
      return absl::CancelledError("Room layout load cancelled");
    }
    if (end - pos < 2) {
      return absl::DataLossError(absl::StrFormat(
          "Layout %d has a truncated terminator at PC 0x%05X", layout_id, pos));
    }
    uint8_t b1 = rom_data[pos];
    uint8_t b2 = rom_data[pos + 1];
 
    if (b1 == 0xFF && b2 == 0xFF) {
      // $FF $FF is the END terminator for this layout
      LOG_DEBUG("RoomLayout",
                "Layout %d terminated at pos=0x%05X after %d objects",
                layout_id, pos, obj_index);
      objects_ = std::move(decoded);
      return absl::OkStatus();
    }
 
    if (end - pos < 3) {
      return absl::DataLossError(absl::StrFormat(
          "Layout %d has a truncated object at PC 0x%05X", layout_id, pos));
    }
 
    uint8_t b3 = rom_data[pos + 2];
    pos += 3;
 
    RoomObject obj = RoomObject::DecodeObjectFromBytes(
        b1, b2, b3, static_cast<uint8_t>(layer));
 
    obj.SetRom(rom_);
    obj.EnsureTilesLoaded();
    if (stop_token.stop_requested()) {
      return absl::CancelledError("Room layout load cancelled");
    }
    decoded.push_back(obj);
 
    LOG_DEBUG("RoomLayout",
              "Layout %d obj[%d]: bytes=[%02X,%02X,%02X] -> id=0x%03X x=%d "
              "y=%d size=%d tiles=%zu",
              layout_id, obj_index, b1, b2, b3, obj.id_, obj.x_, obj.y_,
              obj.size_, obj.tiles().size());
    obj_index++;
  }
 
  return absl::DataLossError(absl::StrFormat(
      "Layout %d has no FF FF terminator within its fixed stream", layout_id));
}
 
absl::Status RoomLayout::Draw(int room_id, const uint8_t* gfx_data,
                              gfx::BackgroundBuffer& bg1,
                              gfx::BackgroundBuffer& bg2,
                              const gfx::PaletteGroup& palette_group,
                              DungeonState* state, uint8_t floor1_graphics,
                              uint8_t floor2_graphics) const {
  if (!rom_ || !rom_->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
 
  if (objects_.empty()) {
    return absl::OkStatus();
  }
 
  ObjectDrawer drawer(rom_, room_id, gfx_data);
  drawer.SetBG1RevealMaskSource(gfx::BG1RevealMaskSource::kBG2Layout);
  drawer.SetRoomFloorGraphics(floor1_graphics, floor2_graphics);
 
  std::vector<RoomObject> render_objects = objects_;
  for (auto& obj : render_objects) {
    obj.layer_ = RoomObject::LayerType::BG1;
  }
 
  // ALTTP enters the room-layout stream with the upper tilemap pointer active.
  // Object IDs do not reroute the destination tilemap; their draw routines use
  // the current stream pointer.
  return drawer.DrawObjectList(render_objects, bg1, bg2, palette_group, state);
}
 
}  // namespace yaze::zelda3