object_parser.h

Go to the documentation of this file.

#ifndef YAZE_APP_ZELDA3_DUNGEON_OBJECT_PARSER_H
#define YAZE_APP_ZELDA3_DUNGEON_OBJECT_PARSER_H
 
#include <cstdint>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "app/gfx/types/snes_tile.h"
#include "rom/rom.h"
 
namespace yaze {
namespace zelda3 {
 
struct ObjectRoutineInfo {
  uint32_t routine_ptr;
  uint32_t tile_ptr;
  int tile_count;
  bool is_repeatable;
  bool is_orientation_dependent;
 
  ObjectRoutineInfo()
      : routine_ptr(0),
        tile_ptr(0),
        tile_count(0),
        is_repeatable(false),
        is_orientation_dependent(false) {}
};
 
struct ObjectSubtypeInfo {
  int subtype;
  uint32_t subtype_ptr;
  uint32_t routine_ptr;
  int max_tile_count;
 
  ObjectSubtypeInfo()
      : subtype(0), subtype_ptr(0), routine_ptr(0), max_tile_count(0) {}
};
 
struct ObjectSizeInfo {
  int width_tiles;
  int height_tiles;
  bool is_horizontal;
  bool is_repeatable;
  int repeat_count;
 
  ObjectSizeInfo()
      : width_tiles(0),
        height_tiles(0),
        is_horizontal(true),
        is_repeatable(false),
        repeat_count(1) {}
};
 
struct ObjectDrawInfo {
  int draw_routine_id;  // Which drawing pattern to use (0-24)
  int tile_count;       // How many tiles this object has
  bool is_horizontal;   // Orientation
  bool is_vertical;
  bool both_layers;          // Draw to both BG1 and BG2
  std::string routine_name;  // Human-readable routine name
 
  ObjectDrawInfo()
      : draw_routine_id(0),
        tile_count(1),
        is_horizontal(true),
        is_vertical(false),
        both_layers(false),
        routine_name("Unknown") {}
};
 
struct ObjectTileReadRange {
  uint32_t begin = 0;
  uint32_t end = 0;
 
  bool operator==(const ObjectTileReadRange&) const = default;
};
 
class ObjectParser {
 public:
  explicit ObjectParser(Rom* rom) : rom_(rom) {}
 
  absl::StatusOr<std::vector<gfx::TileInfo>> ParseObject(int16_t object_id);
 
  absl::StatusOr<std::vector<ObjectTileReadRange>> ResolveTileReadRanges(
      int16_t object_id);
 
  absl::StatusOr<ObjectRoutineInfo> ParseObjectRoutine(int16_t object_id);
 
  absl::StatusOr<ObjectSubtypeInfo> GetObjectSubtype(int16_t object_id);
 
  absl::StatusOr<ObjectSizeInfo> ParseObjectSize(int16_t object_id,
                                                 uint8_t size_byte);
 
  int DetermineSubtype(int16_t object_id) const;
 
  ObjectDrawInfo GetObjectDrawInfo(int16_t object_id) const;
 
 private:
  absl::StatusOr<std::vector<gfx::TileInfo>> ParseSubtype1(int16_t object_id);
 
  absl::StatusOr<std::vector<gfx::TileInfo>> ParseSubtype2(int16_t object_id);
 
  absl::StatusOr<std::vector<gfx::TileInfo>> ParseSubtype3(int16_t object_id);
 
  absl::StatusOr<std::vector<gfx::TileInfo>> ReadTileData(int address,
                                                          int tile_count);
 
  int GetSubtype2TileCount(int16_t object_id) const;
 
  int GetSubtype3TileCount(int16_t object_id) const;
 
  // Resolve tile count for any object ID using subtype-specific tables.
  int ResolveTileCountForObject(int16_t object_id) const;
 
  Rom* rom_;
  std::vector<ObjectTileReadRange>* tile_read_range_collector_ = nullptr;
};
 
}  // namespace zelda3
}  // namespace yaze
 
#endif  // YAZE_APP_ZELDA3_DUNGEON_OBJECT_PARSER_H