room_object.h

Go to the documentation of this file.

#ifndef YAZE_APP_ZELDA3_DUNGEON_ROOM_OBJECT_H
#define YAZE_APP_ZELDA3_DUNGEON_ROOM_OBJECT_H
 
#include <cstdint>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/strings/str_format.h"
#include "app/gfx/types/snes_tile.h"
#include "rom/rom.h"
#include "zelda3/dungeon/object_parser.h"
 
namespace yaze {
namespace zelda3 {
 
enum class SpecialObjectType { Chest, BigChest, InterroomStairs };
 
enum Sorting {
  All = 0,
  Wall = 1,
  Horizontal = 2,
  Vertical = 4,
  NonScalable = 8,
  Dungeons = 16,
  Floors = 32,
  SortStairs = 64
};
 
enum class ObjectOption {
  Nothing = 0,
  Door = 1,
  Chest = 2,
  Block = 4,
  Torch = 8,
  Bgr = 16,
  Stairs = 32
};
 
ObjectOption operator|(ObjectOption lhs, ObjectOption rhs);
ObjectOption operator&(ObjectOption lhs, ObjectOption rhs);
ObjectOption operator^(ObjectOption lhs, ObjectOption rhs);
ObjectOption operator~(ObjectOption option);
 
constexpr int kRoomObjectSubtype1 = 0x8000;          // JP = Same
constexpr int kRoomObjectSubtype2 = 0x83F0;          // JP = Same
constexpr int kRoomObjectSubtype3 = 0x84F0;          // JP = Same
constexpr int kRoomObjectTileAddress = 0x1B52;       // JP = Same
constexpr int kRoomObjectTileAddressFloor = 0x1B5A;  // JP = Same
 
class RoomObject {
 public:
  enum LayerType { BG1 = 0, BG2 = 1, BG3 = 2 };
 
  // ROM room object stream index (0=primary, 1=BG2 overlay, 2=BG1 overlay).
  // Same numeric values as LayerType for encode buckets; use only when the
  // object came from the room object stream (see `layer_` comment below).
  enum ListIndex : uint8_t {
    kListPrimary = 0,
    kListBg2Overlay = 1,
    kListBg1Overlay = 2
  };
 
  RoomObject(int16_t id, uint8_t x, uint8_t y, uint8_t size, uint8_t layer = 0)
      : id_(id),
        x_(x),
        y_(y),
        size_(size),
        layer_(static_cast<LayerType>(layer)),
        nx_(x),
        ny_(y),
        ox_(x),
        oy_(y),
        width_(16),
        height_(16),
        rom_(nullptr) {}
 
  void SetRom(Rom* rom) { rom_ = rom; }
  Rom* rom() const { return rom_; }
  auto mutable_rom() { return rom_; }
 
  // Position setters and getters
  void set_id(int16_t id);
  void set_x(uint8_t x) { x_ = x; }
  void set_y(uint8_t y) { y_ = y; }
  void set_size(uint8_t size) { size_ = size; }
  uint8_t x() const { return x_; }
  uint8_t y() const { return y_; }
  uint8_t size() const { return size_; }
 
  // Ensures tiles_ is populated with a basic set based on ROM tables so we can
  // preview/draw objects without needing full emulator execution.
  void EnsureTilesLoaded();
 
  // Load tiles using the new ObjectParser
  absl::Status LoadTilesWithParser();
 
  // Getter for tiles
  const std::vector<gfx::TileInfo>& tiles() const {
    const_cast<RoomObject*>(this)->EnsureTilesLoaded();
    return tiles_;
  }
  std::vector<gfx::TileInfo>& mutable_tiles() {
    MarkTileCacheUntracked();
    return tiles_;
  }
 
  // Get tile data through Arena system - returns references, not copies
  absl::StatusOr<std::span<const gfx::TileInfo>> GetTiles() const;
 
  // Get individual tile by index - uses Arena lookup
  absl::StatusOr<const gfx::TileInfo*> GetTile(int index) const;
 
  // Get tile count without loading all tiles
  int GetTileCount() const;
 
  // ============================================================================
  // Object Encoding/Decoding (Phase 1, Task 1.1)
  // ============================================================================
 
  // 3-byte object encoding structure
  struct ObjectBytes {
    uint8_t b1;
    uint8_t b2;
    uint8_t b3;
  };
 
  // Decode object from 3-byte ROM format
  // Type1: xxxxxxss yyyyyyss iiiiiiii (ID 0x000-0x0F7)
  // Type2: 111111xx xxxxyyyy yyiiiiii (ID 0x100-0x13F)
  // Type3: xxxxxxii yyyyyyii 11111iii (ID 0xF80-0xFFF)
  static RoomObject DecodeObjectFromBytes(uint8_t b1, uint8_t b2, uint8_t b3,
                                          uint8_t layer);
 
  // Encode object to 3-byte ROM format
  ObjectBytes EncodeObjectToBytes() const;
 
  // Determine object type from bytes (1, 2, or 3)
  static int DetermineObjectType(uint8_t b1, uint8_t b3);
 
  // Get layer from LayerType enum
  uint8_t GetLayerValue() const { return static_cast<uint8_t>(layer_); }
 
  // ============================================================================
 
  // NOTE: Legacy ZScream methods removed. Modern rendering uses:
  // - ObjectParser for loading tiles from ROM
  // - ObjectDrawer for rendering tiles to BackgroundBuffer
 
  auto options() const { return options_; }
  void set_options(ObjectOption options) { options_ = options; }
 
  // For `ObjectOption::Block` objects only. Holds the current committed
  // 0-based index of the corresponding 4-byte global pushable-block entry.
  // LoadBlocks initializes it from ROM; a successful structural save rebases
  // it after deleted entries are compacted. This preserves vanilla's
  // interleaved authoring order on later no-op saves. User-added blocks use
  // kBlockLoadOrderNew until their first successful save assigns a committed
  // tail slot. Ignored for non-block objects.
  int block_load_order() const { return block_load_order_; }
  void set_block_load_order(int order) { block_load_order_ = order; }
 
  // Pushable-block bit 14 is independent of `layer_`: `layer_` stores the
  // bit-13 draw target, while this selector is retained for runtime pit and
  // collision behavior. It is preserved by edits and copies unless changed
  // explicitly by a future dedicated behavior control.
  uint8_t block_behavior_layer() const { return block_behavior_layer_; }
  void set_block_behavior_layer(uint8_t layer) {
    block_behavior_layer_ = layer & 0x01;
  }
 
  // Lightable-torch bit 14 is reserved by the runtime table. Keep it separate
  // from `layer_`, which stores the bit-13 BG1/BG2 draw target, so ordinary
  // edits and copies do not discard authoring data that yaze does not expose.
  uint8_t torch_reserved_bit() const { return torch_reserved_bit_; }
  void set_torch_reserved_bit(uint8_t reserved) {
    torch_reserved_bit_ = reserved & 0x01;
  }
 
  // Copying an editor entity must not claim the source block's ROM table slot.
  // Ordinary C++ copies intentionally preserve load order for move validation,
  // undo snapshots, and rendering; creation paths call this method explicitly.
  RoomObject CopyForNewPlacement() const {
    RoomObject copy = *this;
    copy.block_load_order_ = kBlockLoadOrderNew;
    return copy;
  }
 
  // Explicit editor/custom-object override. Built-in objects derive their
  // layer routing from DrawRoutineRegistry instead of duplicating ID lists.
  bool all_bgs_ = false;
  bool lit_ = false;
 
  int16_t id_;
  uint8_t x_;
  uint8_t y_;
  uint8_t size_;
  uint8_t nx_;
  uint8_t ny_;
  uint8_t ox_;
  uint8_t oy_;
  uint8_t z_ = 0;
  uint8_t previous_size_ = 0;
  // Size nibble bits captured from object encoding (0..3 each) for heuristic
  // orientation and sizing decisions.
  uint8_t size_x_bits_ = 0;
  uint8_t size_y_bits_ = 0;
 
  int width_;
  int height_;
  int offset_x_ = 0;
  int offset_y_ = 0;
 
  std::string name_;
 
  std::vector<uint8_t> preview_object_data_;
 
  // Tile data storage - using Arena system for efficient memory management
  // Instead of copying Tile16 vectors, we store references to Arena-managed
  // data
  mutable std::vector<gfx::TileInfo> tiles_;  // Individual tiles like ZScream
  mutable bool tiles_loaded_ = false;
  mutable int tile_count_ = 0;
  mutable int tile_data_ptr_ = -1;  // Pointer to tile data in ROM
 
  // For room-stream objects this is the object *list* index (0=primary, 1=BG2
  // overlay, 2=BG1 overlay), matching `Room::EncodeObjects` buckets; map it
  // through MapRoomObjectListIndexToDrawLayer() before drawing. For torches and
  // pushable blocks, values 0/1 are the special-table draw target. Pushable
  // block behavior and the torch reserved bit use independent fields.
  LayerType layer_;
  ObjectOption options_ = ObjectOption::Nothing;
 
  // Sentinel for blocks that were not loaded from ROM (user-added in the
  // editor). `SaveAllBlocks` keeps these at the tail of the encoded
  // buffer in creation order so they don't get sorted in front of the
  // vanilla entries.
  static constexpr int kBlockLoadOrderNew = -1;
  int block_load_order_ = kBlockLoadOrderNew;
  uint8_t block_behavior_layer_ = 0;
  uint8_t torch_reserved_bit_ = 0;
 
  Rom* rom_;
 
 private:
  void InvalidateTileCache();
  bool IsTrackedTileCacheCurrent() const;
  void MarkTileCacheCurrent();
  void MarkTileCacheUntracked();
 
  // Only parser-populated caches are tracked. Tests, custom previews, and
  // other callers that inject tiles directly retain their cache across ROM
  // revisions because no ROM provenance was claimed for those tiles.
  mutable const Rom* tile_cache_rom_identity_ = nullptr;
  mutable uint64_t tile_cache_revision_ = 0;
  mutable bool tile_cache_tracked_ = false;
};
 
// Room-object size is persisted only for Type 1 objects. Type 2 has no size
// field, while Type 3 reuses those bits as part of the object ID; its canonical
// value mirrors DecodeObjectFromBytes rather than the ID's raw low nibble.
bool IsRoomObjectSizeEditable(int object_id);
uint8_t CanonicalRoomObjectSize(int object_id, uint8_t requested_size);
uint8_t DefaultRoomObjectSizeForPlacement(int object_id);
 
// Geometric resizing is distinct from the persisted size field: active custom
// objects use that field as a variant selector, not as width/height.
bool IsRoomObjectResizable(int object_id);
// Tile stride for each packed two-bit axis, or zero for scalar/fixed objects.
int RoomObjectSizeAxisStep(int object_id);
// Physical tile extent for a packed axis, including fixed borders. Returns zero
// for scalar/fixed objects and active custom variants.
int RoomObjectSizeAxisTiles(int object_id, uint8_t size,
                            bool horizontal = false);
// Packed objects resize height by default, width when horizontal is true.
uint8_t ResizeRoomObjectByDelta(int object_id, uint8_t size, int delta,
                                bool horizontal = false);
 
// Stateful small and big chests advance the engine's per-room chest-event
// index. Fixed-open chest graphics (F9A/FB2) and the FF5 minigame chest do not.
inline constexpr bool IsStatefulChestObjectId(int object_id) {
  return object_id == 0xF99 || object_id == 0xFB1;
}
 
// Validates that an ordinary room-object stream entry can be encoded without
// changing its identity or colliding with the stream's list/door markers.
// Torches and pushable blocks use separate tables; callers must exclude them
// with UsesRoomObjectStream().
absl::Status ValidateRoomObjectStreamEntryForSave(const RoomObject& object);
 
// USDASM (LoadAndBuildRoom): three room-object lists separated by $FFFF after the
// floor/layout header. `RoomObject::layer_` stores that list index (0, 1, 2) for
// encode round-trip — not the same as “which SNES buffer”. After
// `RoomDraw_DrawFloors`, the layout pass and the primary room-object list both
// still target the upper/BG1 tilemap pointers; only the post-$FFFF overlay pass
// explicitly swaps to lower/BG2, and the final pass swaps back to upper/BG1.
// Use this when building draw lists.
inline RoomObject::LayerType MapRoomObjectListIndexToDrawLayer(
    uint8_t list_index) {
  if (list_index > 2) {
    list_index = 2;
  }
  if (list_index == 1) {
    return RoomObject::LayerType::BG2;
  }
  return list_index == 0 ? RoomObject::LayerType::BG1
                         : RoomObject::LayerType::BG3;
}
 
// NOTE: Legacy Subtype1, Subtype2, Subtype3 classes removed.
// These were ported from ZScream but are no longer used.
// Modern code uses: ObjectParser + ObjectDrawer + ObjectRenderer
 
constexpr static inline const char* Type1RoomObjectNames[] = {
    "Ceiling ↔",
    "Wall (top, north) ↔",
    "Wall (top, south) ↔",
    "Wall (bottom, north) ↔",
    "Wall (bottom, south) ↔",
    "Wall columns (north) ↔",
    "Wall columns (south) ↔",
    "Deep wall (north) ↔",
    "Deep wall (south) ↔",
    "Diagonal wall A ◤ (top) ↔",
    "Diagonal wall A ◣ (top) ↔",
    "Diagonal wall A ◥ (top) ↔",
    "Diagonal wall A ◢ (top) ↔",
    "Diagonal wall B ◤ (top) ↔",
    "Diagonal wall B ◣ (top) ↔",
    "Diagonal wall B ◥ (top) ↔",
    "Diagonal wall B ◢ (top) ↔",
    "Diagonal wall C ◤ (top) ↔",
    "Diagonal wall C ◣ (top) ↔",
    "Diagonal wall C ◥ (top) ↔",
    "Diagonal wall C ◢ (top) ↔",
    "Diagonal wall A ◤ (bottom) ↔",
    "Diagonal wall A ◣ (bottom) ↔",
    "Diagonal wall A ◥ (bottom) ↔",
    "Diagonal wall A ◢ (bottom) ↔",
    "Diagonal wall B ◤ (bottom) ↔",
    "Diagonal wall B ◣ (bottom) ↔",
    "Diagonal wall B ◥ (bottom) ↔",
    "Diagonal wall B ◢ (bottom) ↔",
    "Diagonal wall C ◤ (bottom) ↔",
    "Diagonal wall C ◣ (bottom) ↔",
    "Diagonal wall C ◥ (bottom) ↔",
    "Diagonal wall C ◢ (bottom) ↔",
    "Platform stairs ↔",
    "Rail ↔",
    "Pit edge ┏━┓ A (north) ↔",
    "Pit edge ┏━┓ B (north) ↔",
    "Pit edge ┏━┓ C (north) ↔",
    "Pit edge ┏━┓ D (north) ↔",
    "Pit edge ┏━┓ E (north) ↔",
    "Pit edge ┗━┛ (south) ↔",
    "Pit edge ━━━ (south) ↔",
    "Pit edge ━━━ (north) ↔",
    "Pit edge ━━┛ (south) ↔",
    "Pit edge ┗━━ (south) ↔",
    "Pit edge ━━┓ (north) ↔",
    "Pit edge ┏━━ (north) ↔",
    "Rail wall (north) ↔",
    "Rail wall (south) ↔",
    "Nothing",
    "Nothing",
    "Carpet ↔",
    "Carpet trim ↔",
    "Hole in wall",  // Generic opening or doorway
    "Drapes (north) ↔",
    "Drapes (west, odd) ↔",
    "Statues ↔",
    "Columns ↔",
    "Wall decors (north) ↔",
    "Wall decors (south) ↔",
    "Chairs in pairs ↔",
    "Tall torches ↔",
    "Supports (north) ↔",
    "Water edge ┏━┓ (concave) ↔",
    "Water edge ┗━┛ (concave) ↔",
    "Water edge ┏━┓ (convex) ↔",
    "Water edge ┗━┛ (convex) ↔",
    "Water edge ┏━┛ (concave) ↔",
    "Water edge ┗━┓ (concave) ↔",
    "Water edge ┗━┓ (convex) ↔",
    "Water edge ┏━┛ (convex) ↔",
    "Waterfall A ↔",
    "Waterfall B ↔",
    "Floor tiles 4x2 A ↔",
    "Floor tiles 4x2 B ↔",
    "Supports (south) ↔",
    "Bar ↔",
    "Shelf A ↔",
    "Shelf B ↔",
    "Shelf C ↔",
    "Somaria path ↔",
    "Cannon hole A (north) ↔",
    "Cannon hole A (south) ↔",
    "Pipe path ↔",
    "Nothing",
    "Wall torches (north) ↔",
    "Wall torches (south) ↔",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
    "Cannon hole B (north) ↔",
    "Cannon hole B (south) ↔",
    "Thick rail ↔",
    "Blocks ↔",
    "Long rail ↔",
    "Ceiling ↕",
    "Wall (top, west) ↕",
    "Wall (top, east) ↕",
    "Wall (bottom, west) ↕",
    "Wall (bottom, east) ↕",
    "Wall columns (west) ↕",
    "Wall columns (east) ↕",
    "Deep wall (west) ↕",
    "Deep wall (east) ↕",
    "Rail ↕",
    "Pit edge (west) ↕",
    "Pit edge (east) ↕",
    "Rail wall (west) ↕",
    "Rail wall (east) ↕",
    "Nothing",
    "Nothing",
    "Carpet ↕",
    "Carpet trim ↕",
    "Nothing",
    "Drapes (west) ↕",
    "Drapes (east) ↕",
    "Columns ↕",
    "Wall decors (west) ↕",
    "Wall decors (east) ↕",
    "Supports (west) ↕",
    "Water edge (west) ↕",
    "Water edge (east) ↕",
    "Supports (east) ↕",
    "Somaria path ↕",
    "Pipe path ↕",
    "Nothing",
    "Wall torches (west) ↕",
    "Wall torches (east) ↕",
    "Wall decors tight A (west) ↕",
    "Wall decors tight A (east) ↕",
    "Wall decors tight B (west) ↕",
    "Wall decors tight B (east) ↕",
    "Cannon hole (west) ↕",
    "Cannon hole (east) ↕",
    "Tall torches ↕",
    "Thick rail ↕",
    "Blocks ↕",
    "Long rail ↕",
    "Jump ledge (west) ↕",
    "Jump ledge (east) ↕",
    "Rug trim (west) ↕",
    "Rug trim (east) ↕",
    "Bar ↕",
    "Wall flair (west) ↕",
    "Wall flair (east) ↕",
    "Blue pegs ↕",
    "Orange pegs ↕",
    "Invisible floor ↕",
    "Fake pots ↕",
    "Hammer pegs ↕",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
    "Diagonal ceiling A ◤",
    "Diagonal ceiling A ◣",
    "Diagonal ceiling A ◥",
    "Diagonal ceiling A ◢",
    "Pit ⇲",
    "Diagonal layer 2 mask A ◤",
    "Diagonal layer 2 mask A ◣",
    "Diagonal layer 2 mask A ◥",
    "Diagonal layer 2 mask A ◢",
    "Diagonal layer 2 mask B ◤",  // TODO: VERIFY
    "Diagonal layer 2 mask B ◣",  // TODO: VERIFY
    "Diagonal layer 2 mask B ◥",  // TODO: VERIFY
    "Diagonal layer 2 mask B ◢",  // TODO: VERIFY
    "Nothing",
    "Nothing",
    "Nothing",
    "Jump ledge (north) ↔",
    "Jump ledge (south) ↔",
    "Rug ↔",
    "Rug trim (north) ↔",
    "Rug trim (south) ↔",
    "Archery game curtains ↔",
    "Wall flair (north) ↔",
    "Wall flair (south) ↔",
    "Blue pegs ↔",
    "Orange pegs ↔",
    "Invisible floor ↔",
    "Fake pressure plates ↔",
    "Fake pots ↔",
    "Hammer pegs ↔",
    "Nothing",
    "Nothing",
    "Ceiling (large) ⇲",
    "Chest platform (tall) ⇲",
    "Layer 2 pit mask (large) ⇲",
    "Layer 2 pit mask (medium) ⇲",
    "Floor 1 ⇲",
    "Floor 3 ⇲",
    "Layer 2 mask (large) ⇲",
    "Floor 4 ⇲",
    "Water floor ⇲ ",
    "Flood water (medium) ⇲ ",
    "Conveyor floor ⇲ ",
    "Nothing",
    "Nothing",
    "Moving wall (west) ⇲",
    "Moving wall (east) ⇲",
    "Nothing",
    "Nothing",
    "Icy floor A ⇲",
    "Icy floor B ⇲",
    "Wall moved check A (logic)",
    "Wall moved check B (logic)",
    "Wall moved check C (logic)",
    "Wall moved check D (logic)",
    "Layer 2 mask (medium) ⇲",
    "Flood water (large) ⇲",
    "Layer 2 swim mask ⇲",
    "Flood water B (large) ⇲",
    "Floor 2 ⇲",
    "Chest platform (short) ⇲",
    "Table / rock ⇲",
    "Spike blocks ⇲",
    "Spiked floor ⇲",
    "Floor 7 ⇲",
    "Tiled floor ⇲",
    "Rupee floor ⇲",
    "Conveyor upwards ⇲",
    "Conveyor downwards ⇲",
    "Conveyor leftwards ⇲",
    "Conveyor rightwards ⇲",
    "Heavy current water ⇲",
    "Floor 10 ⇲",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
    "Nothing",
};
 
constexpr static inline const char* Type2RoomObjectNames[] = {
    "Corner (top, concave) ▛",
    "Corner (top, concave) ▙",
    "Corner (top, concave) ▜",
    "Corner (top, concave) ▟",
    "Corner (top, convex) ▟",
    "Corner (top, convex) ▜",
    "Corner (top, convex) ▙",
    "Corner (top, convex) ▛",
    "Corner (bottom, concave) ▛",
    "Corner (bottom, concave) ▙",
    "Corner (bottom, concave) ▜",
    "Corner (bottom, concave) ▟",
    "Corner (bottom, convex) ▟",
    "Corner (bottom, convex) ▜",
    "Corner (bottom, convex) ▙",
    "Corner (bottom, convex) ▛",
    "Kinked corner north (bottom) ▜",
    "Kinked corner south (bottom) ▟",
    "Kinked corner north (bottom) ▛",
    "Kinked corner south (bottom) ▙",
    "Kinked corner west (bottom) ▙",
    "Kinked corner west (bottom) ▛",
    "Kinked corner east (bottom) ▟",
    "Kinked corner east (bottom) ▜",
    "Deep corner (concave) ▛",
    "Deep corner (concave) ▙",
    "Deep corner (concave) ▜",
    "Deep corner (concave) ▟",
    "Large brazier",
    "Statue",
    "Star tile (disabled)",
    "Star tile (enabled)",
    "Small torch (lit)",
    "Barrel",
    "Statue (back)",
    "Table",
    "Fairy statue",
    "Potted plant",
    "Stool",
    "Chair",
    "Bed",
    "Fireplace",
    "Mario portrait",
    "Rightwards 2x2 decor",
    "Rightwards 6x3 decor",
    "Interroom stairs (up)",
    "Interroom stairs (down)",
    "Interroom stairs B (down)",
    "Intraroom stairs north B",  // TODO: VERIFY LAYER HANDLING
    "Intraroom stairs north (separate layers)",
    "Intraroom stairs north (merged layers)",
    "Intraroom stairs north (swim layer)",
    "Block",
    "Water-hop stairs A",
    "Water-hop stairs B",
    "Dam floodgate",
    "Interroom spiral stairs up (top)",
    "Interroom spiral stairs down (top)",
    "Interroom spiral stairs up (bottom)",
    "Interroom spiral stairs down (bottom)",
    "Sanctuary wall (north)",
    "Sanctuary pew (right end)",
    "Pew",
    "Magic bat altar",
};
 
constexpr static inline const char* Type3RoomObjectNames[] = {
    "Waterfall face (empty)",
    "Waterfall face (short)",
    "Waterfall face (long)",
    "Somaria path endpoint",
    "Somaria path intersection ╋",
    "Somaria path corner ┏",
    "Somaria path corner ┗",
    "Somaria path corner ┓",
    "Somaria path corner ┛",
    "Somaria path intersection ┳",
    "Somaria path intersection ┻",
    "Somaria path intersection ┣",
    "Somaria path intersection ┫",
    "Prison cell bars (alt)",
    "Somaria path 2-way endpoint",
    "Somaria path crossover",
    "Babasu hole (north)",
    "Babasu hole (south)",
    "9 blue rupees",
    "Telepathy tile",
    "Unused / Warp door",
    "Kholdstare's shell",
    "Hammer peg",
    "Prison cell",
    "Big key lock",
    "Chest",
    "Chest (open)",
    "Intraroom stairs south",  // TODO: VERIFY LAYER HANDLING
    "Intraroom stairs south (separate layers)",
    "Intraroom stairs south (merged layers)",
    "Interroom straight stairs up (north, top)",
    "Interroom straight stairs down (north, top)",
    "Interroom straight stairs up (south, top)",
    "Interroom straight stairs down (south, top)",
    "Deep corner (convex) ▟",
    "Deep corner (convex) ▜",
    "Deep corner (convex) ▙",
    "Deep corner (convex) ▛",
    "Interroom straight stairs up (north, bottom)",
    "Interroom straight stairs down (north, bottom)",
    "Interroom straight stairs up (south, bottom)",
    "Interroom straight stairs down (south, bottom)",
    "Lamp cones",
    "Single 2x2 decor A",
    "Liftable large block",
    "Agahnim's altar",
    "Agahnim's boss room",
    "Pot",
    "Single 2x2 decor B",
    "Big chest",
    "Big chest (open)",
    "Intraroom stairs south (swim layer)",
    "Intraroom stairs south (long)",
    "Ladder (north)",
    "Ladder (south)",
    "4x4 decor A ↔",
    "4x4 decor B ↔",
    "4x4 decor C ↔",
    "Pipe end (south)",
    "Pipe end (north)",
    "Pipe end (east)",
    "Pipe end (west)",
    "Pipe corner ▛",
    "Pipe corner ▙",
    "Pipe corner ▜",
    "Pipe corner ▟",
    "Pipe-rock intersection ⯊",
    "Pipe-rock intersection ⯋",
    "Pipe-rock intersection ◖",
    "Pipe-rock intersection ◗",
    "Pipe crossover",
    "Bombable floor",
    "Fake bombable floor",
    "Single 2x2 decor C",
    "Warp tile",
    "Tool rack",
    "Furnace",
    "Tub (wide)",
    "Anvil",
    "Warp tile (disabled)",
    "Pressure plate",
    "Single 2x2 decor D",
    "Blue peg",
    "Orange peg",
    "Fortune teller room",
    "Utility 3x5 decor",
    "Bar corner ▛",
    "Bar corner ▙",
    "Bar corner ▜",
    "Bar corner ▟",
    "Decorative bowl",
    "Tub (tall)",
    "Bookcase",
    "Range",
    "Suitcase",
    "Bar bottles",
    "Arrow game hole (west)",
    "Arrow game hole (east)",
    "Vitreous goo gfx",
    "Fake pressure plate",
    "Medusa head",
    "4-way shooter block",
    "Pit",
    "Wall crack (north)",
    "Wall crack (south)",
    "Wall crack (west)",
    "Wall crack (east)",
    "Large decor",
    "Water grate (north)",
    "Water grate (south)",
    "Water grate (west)",
    "Water grate (east)",
    "Window sunlight",
    "Floor sunlight",
    "Trinexx's shell",
    "Layer 2 mask (full)",
    "Boss entrance",
    "Minigame chest",
    "Ganon door",
    "Triforce wall ornament",
    "Triforce floor tiles",
    "Freezor hole",
    "Pile of bones",
    "Vitreous goo damage",
    "Arrow tile ↑",
    "Arrow tile ↓",
    "Arrow tile →",
    "Nothing",
};
 
// Helper function to get object name from ID
// Works across all three object subtypes
inline std::string GetObjectName(int object_id) {
  if (object_id < 0x100) {
    // Type 1: Subtype 1 objects (0x00-0xFF)
    constexpr size_t kType1Count =
        sizeof(Type1RoomObjectNames) / sizeof(Type1RoomObjectNames[0]);
    if (object_id >= 0 && object_id < static_cast<int>(kType1Count)) {
      return Type1RoomObjectNames[object_id];
    }
    return absl::StrFormat("Unknown Type1 (0x%02X)", object_id);
  } else if (object_id >= 0x100 && object_id < 0x200) {
    // Type 2: Subtype 2 objects (0x100-0x1FF)
    int idx = object_id - 0x100;
    constexpr size_t kType2Count =
        sizeof(Type2RoomObjectNames) / sizeof(Type2RoomObjectNames[0]);
    if (idx >= 0 && idx < static_cast<int>(kType2Count)) {
      return Type2RoomObjectNames[idx];
    }
    return absl::StrFormat("Unknown Type2 (0x%03X)", object_id);
  } else if (object_id >= 0xF80) {
    // Type 3: Special objects (0xF80-0xFFF, decoded from ASM 0x200-0x27F)
    int idx = object_id - 0xF80;
    constexpr size_t kType3Count =
        sizeof(Type3RoomObjectNames) / sizeof(Type3RoomObjectNames[0]);
    if (idx >= 0 && idx < static_cast<int>(kType3Count)) {
      return Type3RoomObjectNames[idx];
    }
    return absl::StrFormat("Unknown Type3 (0x%03X)", object_id);
  }
  return absl::StrFormat("Unknown (0x%03X)", object_id);
}
 
// Helper to get object type/subtype from ID
inline int GetObjectSubtype(int object_id) {
  if (object_id < 0x100)
    return 1;
  if (object_id < 0x200)
    return 2;
  if (object_id >= 0xF80)
    return 3;
  return 0;  // Unknown
}
 
}  // namespace zelda3
}  // namespace yaze
 
#endif  // YAZE_APP_ZELDA3_DUNGEON_ROOM_OBJECT_H