room_object.cc

Go to the documentation of this file.

#include "room_object.h"
 
#include <algorithm>
 
#include "absl/status/status.h"
#include "absl/strings/str_format.h"
#include "core/features.h"
#include "util/log.h"
#include "zelda3/dungeon/custom_object.h"
#include "zelda3/dungeon/draw_routines/draw_routine_registry.h"
#include "zelda3/dungeon/object_dimensions.h"
#include "zelda3/dungeon/object_parser.h"
 
namespace yaze {
namespace zelda3 {
 
namespace {
struct SubtypeTableInfo {
  int base_ptr;    // base address of subtype table in ROM (PC)
  int index_mask;  // mask to apply to object id for index
  int id_offset;   // offset to subtract from object_id before masking
 
  SubtypeTableInfo(int base, int mask, int offset = 0)
      : base_ptr(base), index_mask(mask), id_offset(offset) {}
};
 
SubtypeTableInfo GetSubtypeTable(int object_id) {
  // Heuristic: 0x00-0xFF => subtype1, 0x100-0x1FF => subtype2, >=0xF80 =>
  // subtype3.  Type 3 IDs from decoding are 0xF80-0xFFF (b3 0xF8-0xFF shifted).
  if (object_id >= 0xF80) {
    // Type 3: IDs 0xF80-0xFFF map to table indices 0-127
    // Subtract 0xF80 first, then mask with 0x7F
    return SubtypeTableInfo(kRoomObjectSubtype3, 0x7F, 0xF80);
  } else if (object_id >= 0x100) {
    // Type 2: IDs 0x100-0x1FF map to table indices 0-255
    return SubtypeTableInfo(kRoomObjectSubtype2, 0xFF, 0x100);
  } else {
    // Type 1: IDs 0x00-0xFF map directly to table indices
    return SubtypeTableInfo(kRoomObjectSubtype1, 0xFF, 0);
  }
}
 
}  // namespace
 
ObjectOption operator|(ObjectOption lhs, ObjectOption rhs) {
  return static_cast<ObjectOption>(static_cast<int>(lhs) |
                                   static_cast<int>(rhs));
}
 
ObjectOption operator&(ObjectOption lhs, ObjectOption rhs) {
  return static_cast<ObjectOption>(static_cast<int>(lhs) &
                                   static_cast<int>(rhs));
}
 
ObjectOption operator^(ObjectOption lhs, ObjectOption rhs) {
  return static_cast<ObjectOption>(static_cast<int>(lhs) ^
                                   static_cast<int>(rhs));
}
 
ObjectOption operator~(ObjectOption option) {
  return static_cast<ObjectOption>(~static_cast<int>(option));
}
 
// NOTE: DrawTile was legacy ZScream code that is no longer used.
// Modern rendering uses ObjectDrawer which draws directly to BackgroundBuffer
// bitmaps.
 
void RoomObject::EnsureTilesLoaded() {
  if (tiles_loaded_ && !IsTrackedTileCacheCurrent()) {
    InvalidateTileCache();
  }
  if (tiles_loaded_) {
    return;
  }
 
  if (rom_ == nullptr) {
    // DEBUG: Log wall/corner objects
    if (id_ == 0x001 || id_ == 0x002 || id_ == 0x061 || id_ == 0x062 ||
        (id_ >= 0x100 && id_ <= 0x103)) {
      LOG_DEBUG("RoomObject", "EnsureTilesLoaded: obj=0x%03X ROM is NULL!",
                id_);
    }
    return;
  }
 
  // Try the new parser first - this is more efficient and accurate
  auto parser_status = LoadTilesWithParser();
  if (parser_status.ok()) {
    tiles_loaded_ = true;
    MarkTileCacheCurrent();
    // DEBUG: Log wall/corner objects
    if (id_ == 0x001 || id_ == 0x002 || id_ == 0x061 || id_ == 0x062 ||
        (id_ >= 0x100 && id_ <= 0x103)) {
      LOG_DEBUG("RoomObject",
                "EnsureTilesLoaded: obj=0x%03X loaded %zu tiles via parser",
                id_, tiles_.size());
    }
    return;
  }
 
  // DEBUG: Log parser failure for wall/corner objects
  if (id_ == 0x001 || id_ == 0x002 || id_ == 0x061 || id_ == 0x062 ||
      (id_ >= 0x100 && id_ <= 0x103)) {
    LOG_DEBUG("RoomObject",
              "EnsureTilesLoaded: obj=0x%03X parser failed: %s, trying legacy",
              id_, std::string(parser_status.message()).c_str());
  }
 
  // Fallback to legacy method for compatibility with enhanced validation
  auto rom_data = rom_->data();
 
  // Determine which subtype table to use and compute the tile data offset.
  SubtypeTableInfo sti = GetSubtypeTable(id_);
  // Apply offset first (for Type 2/3 objects), then mask
  int index = ((id_ - sti.id_offset) & sti.index_mask);
  int tile_ptr = sti.base_ptr + (index * 2);
 
  // Enhanced bounds checking
  if (tile_ptr < 0 || tile_ptr + 1 >= (int)rom_->size()) {
    // Log error but don't crash
    LOG_DEBUG("RoomObject", "Tile pointer out of bounds for object %04X", id_);
    tiles_.clear();
    tiles_loaded_ = true;  // Mark as loaded (empty) to prevent retry
    MarkTileCacheCurrent();
    return;
  }
 
  int tile_rel = (int16_t)((rom_data[tile_ptr + 1] << 8) + rom_data[tile_ptr]);
  int pos = kRoomObjectTileAddress + tile_rel;
  tile_data_ptr_ = pos;
 
  // Enhanced bounds checking for tile data
  if (pos < 0 || pos + 7 >= (int)rom_->size()) {
    // Log error but don't crash
    LOG_DEBUG("RoomObject", "Tile data position out of bounds for object %04X",
              id_);
    tiles_.clear();
    tiles_loaded_ = true;  // Mark as loaded (empty) to prevent retry
    MarkTileCacheCurrent();
    return;
  }
 
  // Read tile data with validation
  uint16_t w0 = (uint16_t)(rom_data[pos] | (rom_data[pos + 1] << 8));
  uint16_t w1 = (uint16_t)(rom_data[pos + 2] | (rom_data[pos + 3] << 8));
  uint16_t w2 = (uint16_t)(rom_data[pos + 4] | (rom_data[pos + 5] << 8));
  uint16_t w3 = (uint16_t)(rom_data[pos + 6] | (rom_data[pos + 7] << 8));
 
  tiles_.clear();
  tiles_.push_back(gfx::WordToTileInfo(w0));
  tiles_.push_back(gfx::WordToTileInfo(w1));
  tiles_.push_back(gfx::WordToTileInfo(w2));
  tiles_.push_back(gfx::WordToTileInfo(w3));
  tile_count_ = 1;
  tiles_loaded_ = true;
  MarkTileCacheCurrent();
}
 
void RoomObject::InvalidateTileCache() {
  tiles_.clear();
  tiles_loaded_ = false;
  tile_count_ = 0;
  tile_data_ptr_ = -1;
  MarkTileCacheUntracked();
}
 
bool RoomObject::IsTrackedTileCacheCurrent() const {
  return !tile_cache_tracked_ ||
         (rom_ != nullptr && tile_cache_rom_identity_ == rom_ &&
          tile_cache_revision_ == rom_->object_tile_revision());
}
 
void RoomObject::MarkTileCacheCurrent() {
  tile_cache_rom_identity_ = rom_;
  tile_cache_revision_ = rom_->object_tile_revision();
  tile_cache_tracked_ = true;
}
 
void RoomObject::MarkTileCacheUntracked() {
  tile_cache_rom_identity_ = nullptr;
  tile_cache_revision_ = 0;
  tile_cache_tracked_ = false;
}
 
void RoomObject::set_id(int16_t id) {
  if (id_ == id) {
    return;
  }
  id_ = id;
  // A manual/custom routing override belongs to the old object identity.
  // Built-in routing for the new ID is resolved through DrawRoutineRegistry.
  all_bgs_ = false;
  InvalidateTileCache();
}
 
absl::Status RoomObject::LoadTilesWithParser() {
  if (rom_ == nullptr) {
    return absl::InvalidArgumentError("ROM is null");
  }
 
  ObjectParser parser(rom_);
  auto result = parser.ParseObject(id_);
  if (!result.ok()) {
    return result.status();
  }
 
  tiles_ = std::move(result.value());
  tile_count_ = tiles_.size();
  return absl::OkStatus();
}
 
absl::StatusOr<std::span<const gfx::TileInfo>> RoomObject::GetTiles() const {
  const_cast<RoomObject*>(this)->EnsureTilesLoaded();
 
  if (tiles_.empty()) {
    return absl::FailedPreconditionError("No tiles loaded for object");
  }
 
  return std::span<const gfx::TileInfo>(tiles_.data(), tiles_.size());
}
 
absl::StatusOr<const gfx::TileInfo*> RoomObject::GetTile(int index) const {
  const_cast<RoomObject*>(this)->EnsureTilesLoaded();
 
  if (index < 0 || index >= static_cast<int>(tiles_.size())) {
    return absl::OutOfRangeError(absl::StrFormat(
        "Tile index %d out of range (0-%d)", index, tiles_.size() - 1));
  }
 
  return &tiles_[index];
}
 
int RoomObject::GetTileCount() const {
  const_cast<RoomObject*>(this)->EnsureTilesLoaded();
 
  return tile_count_;
}
 
// ============================================================================
// Object Encoding/Decoding Implementation (Phase 1, Task 1.1)
// ============================================================================
 
int RoomObject::DetermineObjectType(uint8_t b1, uint8_t b3) {
  // IMPORTANT: Check Type 2 FIRST to avoid boundary collision with Type 3.
  // Type 2 objects with certain Y positions can produce b3 >= 0xF8, which
  // would incorrectly trigger Type 3 decoding if we checked b3 first.
  //
  // Type 2: 111111xx xxxxyyyy yyiiiiii
  // Discriminator: b1 >= 0xFC (top 6 bits all 1)
  if (b1 >= 0xFC) {
    return 2;
  }
 
  // Type 3: Representable object IDs 0xF80-0xFFF
  // These have b3 >= 0xF8 (top nibble is 0xF)
  if (b3 >= 0xF8) {
    return 3;
  }
 
  // Type 1: Representable object IDs 0x000-0x0F7
  return 1;
}
 
RoomObject RoomObject::DecodeObjectFromBytes(uint8_t b1, uint8_t b2, uint8_t b3,
                                             uint8_t layer) {
  uint8_t x = 0;
  uint8_t y = 0;
  uint8_t size = 0;
  uint16_t id = 0;
 
  // IMPORTANT: Check Type 2 FIRST to avoid boundary collision with Type 3.
  // Type 2 objects with certain Y positions can produce b3 >= 0xF8, which
  // would incorrectly trigger Type 3 decoding if we checked b3 first.
 
  // Type 2: 111111xx xxxxyyyy yyiiiiii
  // Discriminator: b1 >= 0xFC (top 6 bits all 1)
  if (b1 >= 0xFC) {
    id = (b3 & 0x3F) | 0x100;
    x = ((b2 & 0xF0) >> 4) | ((b1 & 0x03) << 4);
    y = ((b2 & 0x0F) << 2) | ((b3 & 0xC0) >> 6);
    size = 0;
    LOG_DEBUG("ObjectParser",
              "Type2: b1=%02X b2=%02X b3=%02X -> id=%04X x=%d y=%d size=%d", b1,
              b2, b3, id, x, y, size);
  }
  // Type 3: xxxxxxii yyyyyyii 11111iii
  // Discriminator: b3 >= 0xF8 (top 5 bits all 1)
  else if (b3 >= 0xF8) {
    id = (static_cast<uint16_t>(b3) << 4) | 0x80 |
         ((static_cast<uint16_t>(b2 & 0x03) << 2) + (b1 & 0x03));
    x = (b1 & 0xFC) >> 2;
    y = (b2 & 0xFC) >> 2;
    size = ((b1 & 0x03) << 2) | (b2 & 0x03);
    LOG_DEBUG("ObjectParser",
              "Type3: b1=%02X b2=%02X b3=%02X -> id=%04X x=%d y=%d size=%d", b1,
              b2, b3, id, x, y, size);
  }
  // Type 1: xxxxxxss yyyyyyss iiiiiiii
  else {
    id = b3;
    x = (b1 & 0xFC) >> 2;
    y = (b2 & 0xFC) >> 2;
    size = ((b1 & 0x03) << 2) | (b2 & 0x03);
    LOG_DEBUG("ObjectParser",
              "Type1: b1=%02X b2=%02X b3=%02X -> id=%04X x=%d y=%d size=%d", b1,
              b2, b3, id, x, y, size);
  }
 
  return RoomObject(static_cast<int16_t>(id), x, y, size, layer);
}
 
RoomObject::ObjectBytes RoomObject::EncodeObjectToBytes() const {
  ObjectBytes bytes;
 
  // Determine type based on object ID
  if (id_ >= 0x100 && id_ < 0x200) {
    // Type 2: 111111xx xxxxyyyy yyiiiiii (representable IDs 0x100-0x13F)
    bytes.b1 = 0xFC | ((x_ & 0x30) >> 4);
    bytes.b2 = ((x_ & 0x0F) << 4) | ((y_ & 0x3C) >> 2);
    bytes.b3 = ((y_ & 0x03) << 6) | (id_ & 0x3F);
  } else if (id_ >= 0xF00) {
    // Type 3: xxxxxxii yyyyyyii 11111iii (representable IDs 0xF80-0xFFF)
    bytes.b1 = (x_ << 2) | (id_ & 0x03);
    bytes.b2 = (y_ << 2) | ((id_ >> 2) & 0x03);
    bytes.b3 = (id_ >> 4) & 0xFF;
  } else {
    // Type 1: xxxxxxss yyyyyyss iiiiiiii (representable IDs 0x000-0x0F7)
    uint8_t clamped_size = size_ > 15 ? 15 : size_;
    bytes.b1 = (x_ << 2) | ((clamped_size >> 2) & 0x03);
    bytes.b2 = (y_ << 2) | (clamped_size & 0x03);
    bytes.b3 = static_cast<uint8_t>(id_);
  }
 
  return bytes;
}
 
bool IsRoomObjectSizeEditable(int object_id) {
  return object_id >= 0x000 && object_id <= 0x0F7;
}
 
bool IsRoomObjectResizable(int object_id) {
  return IsRoomObjectSizeEditable(object_id) &&
         !(core::FeatureFlags::get().kEnableCustomObjects &&
           CustomObjectManager::Get().GetSubtypeCount(object_id) > 0);
}
 
int RoomObjectSizeAxisStep(int object_id) {
  if (!IsRoomObjectResizable(object_id)) {
    return 0;
  }
  switch (DrawRoutineRegistry::Get().GetRoutineIdForObject(object_id)) {
    case DrawRoutineIds::k4x4BlocksIn4x4SuperSquare:
    case DrawRoutineIds::k4x4FloorIn4x4SuperSquare:
    case DrawRoutineIds::k4x4FloorOneIn4x4SuperSquare:
    case DrawRoutineIds::k4x4FloorTwoIn4x4SuperSquare:
      return 4;
    case DrawRoutineIds::k3x3FloorIn4x4SuperSquare:
      return 3;
    case DrawRoutineIds::kSpike2x2In4x4SuperSquare:
    case DrawRoutineIds::kTableRock4x4_1to16:
    case DrawRoutineIds::kClosedChestPlatform:
    case DrawRoutineIds::kOpenChestPlatform:
      return 2;
    default:
      return 0;
  }
}
 
int RoomObjectSizeAxisTiles(int object_id, uint8_t size, bool horizontal) {
  const int step = RoomObjectSizeAxisStep(object_id);
  if (step == 0) {
    return 0;
  }
  // USDASM $018CC7/$019733/$0193DC include fixed borders around their packed
  // axes. Keep those extents in the existing dimension table, not UI formulas.
  if (object_id == 0xC1 || object_id == 0xDC || object_id == 0xDD) {
    const auto [width, height] =
        ObjectDimensionTable::Get().GetDimensions(object_id, size & 0x0F);
    return horizontal ? width : height;
  }
  const int axis = (size >> (horizontal ? 2 : 0)) & 0x03;
  return (axis + 1) * step;
}
 
uint8_t ResizeRoomObjectByDelta(int object_id, uint8_t size, int delta,
                                bool horizontal) {
  if (!IsRoomObjectResizable(object_id) || delta == 0) {
    return size;
  }
  // Bound before adding so arbitrary caller deltas cannot overflow int.
  delta = std::clamp(delta, -15, 15);
  if (RoomObjectSizeAxisStep(object_id) != 0) {
    const int shift = horizontal ? 2 : 0;
    const int mask = 0x03 << shift;
    const int axis = (size >> shift) & 0x03;
    return static_cast<uint8_t>(((size & 0x0F) & ~mask) |
                                (std::clamp(axis + delta, 0, 3) << shift));
  }
  return static_cast<uint8_t>(
      std::clamp(static_cast<int>(size) + delta, 0, 15));
}
 
uint8_t CanonicalRoomObjectSize(int object_id, uint8_t requested_size) {
  if (IsRoomObjectSizeEditable(object_id)) {
    return std::min<uint8_t>(requested_size, 15);
  }
  if (object_id >= 0x100 && object_id <= 0x13F) {
    return 0;
  }
  if (object_id >= 0xF80 && object_id <= 0xFFF) {
    return static_cast<uint8_t>(((object_id & 0x03) << 2) |
                                ((object_id >> 2) & 0x03));
  }
  return requested_size;
}
 
uint8_t DefaultRoomObjectSizeForPlacement(int object_id) {
  if (IsRoomObjectSizeEditable(object_id)) {
    return 2;
  }
  return CanonicalRoomObjectSize(object_id, 0);
}
 
absl::Status ValidateRoomObjectStreamEntryForSave(const RoomObject& object) {
  const int layer = object.GetLayerValue();
  if (layer > 2) {
    return absl::InvalidArgumentError(absl::StrFormat(
        "Room object 0x%03X has invalid stream list index %d; expected 0..2",
        object.id_, layer));
  }
  if (object.x_ > 63 || object.y_ > 63) {
    return absl::InvalidArgumentError(absl::StrFormat(
        "Room object 0x%03X has out-of-range coordinates (%d, %d); "
        "expected 0..63",
        object.id_, object.x_, object.y_));
  }
 
  int expected_type = 0;
  if (object.id_ >= 0x000 && object.id_ <= 0x0F7) {
    expected_type = 1;
  } else if (object.id_ >= 0x100 && object.id_ <= 0x13F) {
    expected_type = 2;
  } else if (object.id_ >= 0xF80 && object.id_ <= 0xFFF) {
    expected_type = 3;
  } else {
    return absl::InvalidArgumentError(absl::StrFormat(
        "Room object ID 0x%03X is not representable without aliasing; "
        "expected 0x000..0x0F7, 0x100..0x13F, or 0xF80..0xFFF",
        object.id_));
  }
 
  const uint8_t canonical_size =
      CanonicalRoomObjectSize(object.id_, object.size_);
  if (object.size_ != canonical_size) {
    if (expected_type == 1) {
      return absl::InvalidArgumentError(
          absl::StrFormat("Room object 0x%03X has noncanonical size 0x%02X; "
                          "Type 1 size must be 0x00..0x0F",
                          object.id_, object.size_));
    }
    return absl::InvalidArgumentError(absl::StrFormat(
        "Room object 0x%03X has noncanonical size 0x%02X; expected 0x%02X",
        object.id_, object.size_, canonical_size));
  }
 
  // Type 1/3 encode X in the upper six bits of byte 1. X=63 therefore
  // produces the Type 2 discriminator (0xFC..0xFF) and decodes as another
  // object family.
  if (expected_type != 2 && object.x_ == 63) {
    return absl::InvalidArgumentError(absl::StrFormat(
        "Room object 0x%03X at x=63 collides with the Type 2 discriminator",
        object.id_));
  }
 
  const RoomObject::ObjectBytes encoded = object.EncodeObjectToBytes();
  if ((encoded.b1 == 0xFF && encoded.b2 == 0xFF) ||
      (encoded.b1 == 0xF0 && encoded.b2 == 0xFF)) {
    return absl::InvalidArgumentError(absl::StrFormat(
        "Room object 0x%03X encodes with reserved stream-control prefix "
        "0x%02X 0x%02X",
        object.id_, encoded.b1, encoded.b2));
  }
 
  const int encoded_type =
      RoomObject::DetermineObjectType(encoded.b1, encoded.b3);
  if (encoded_type != expected_type) {
    return absl::InvalidArgumentError(absl::StrFormat(
        "Room object 0x%03X encodes with Type %d discriminator, expected "
        "Type %d",
        object.id_, encoded_type, expected_type));
  }
 
  const RoomObject decoded = RoomObject::DecodeObjectFromBytes(
      encoded.b1, encoded.b2, encoded.b3,
      static_cast<uint8_t>(object.GetLayerValue()));
  if (decoded.id_ != object.id_ || decoded.x_ != object.x_ ||
      decoded.y_ != object.y_) {
    return absl::InvalidArgumentError(absl::StrFormat(
        "Room object 0x%03X at (%d, %d) aliases to 0x%03X at (%d, %d) "
        "after encoding",
        object.id_, object.x_, object.y_, decoded.id_, decoded.x_, decoded.y_));
  }
 
  return absl::OkStatus();
}
 
}  // namespace zelda3
}  // namespace yaze