dungeon_commands.h

Go to the documentation of this file.

#ifndef YAZE_SRC_CLI_HANDLERS_DUNGEON_COMMANDS_H_
#define YAZE_SRC_CLI_HANDLERS_DUNGEON_COMMANDS_H_
 
#include <string_view>
 
#include "cli/service/resources/command_handler.h"
 
namespace yaze {
namespace cli {
namespace handlers {
 
// Writes the dedicated seven-record dungeon spawn schema. If object_title is
// non-empty, the report is nested under an object with that name.
absl::Status WriteDungeonSpawnPointReport(Rom* rom, int spawn_id,
                                          resources::OutputFormatter& formatter,
                                          std::string_view object_title);
 
class DungeonListSpritesCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const { return "dungeon-list-sprites"; }
  std::string GetDescription() const {
    return "List all sprites in a dungeon room";
  }
  std::string GetUsage() const {
    return "dungeon-list-sprites --room <room_id> [--sprite-registry <path>] "
           "[--format <json|text>]";
  }
 
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override {
    return parser.RequireArgs({"room"});
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class DungeonDescribeRoomCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const { return "dungeon-describe-room"; }
  std::string GetDescription() const {
    return "Get detailed description of a dungeon room";
  }
  std::string GetUsage() const {
    return "dungeon-describe-room --room <room_id> [--sprite-registry <path>] "
           "[--include-objects] [--include-staircase-resolution] [--format "
           "<json|text>]";
  }
 
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override {
    return parser.RequireArgs({"room"});
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class DungeonListChestsCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const { return "dungeon-list-chests"; }
  std::string GetDescription() const {
    return "List chest contents for dungeon rooms";
  }
  std::string GetUsage() const {
    return "dungeon-list-chests [--room <room_id>] [--format <json|text>]";
  }
 
  absl::Status ValidateArgs(
      const resources::ArgumentParser& /*parser*/) override {
    return absl::OkStatus();
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class DungeonGetEntranceCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const { return "dungeon-get-entrance"; }
  std::string GetDescription() const {
    return "Get entrance metadata for a dungeon room";
  }
  std::string GetUsage() const {
    return "dungeon-get-entrance --entrance <entrance_id> [--spawn] "
           "[--format <json|text>]";
  }
 
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override {
    return parser.RequireArgs({"entrance"});
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class DungeonExportRoomCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const { return "dungeon-export-room"; }
  std::string GetDescription() const {
    return "Export room data to JSON format";
  }
  std::string GetUsage() const {
    return "dungeon-export-room --room <room_id> [--format <json|text>]";
  }
 
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override {
    return parser.RequireArgs({"room"});
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class DungeonListObjectsCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const { return "dungeon-list-objects"; }
  std::string GetDescription() const {
    return "List all objects in a dungeon room";
  }
  std::string GetUsage() const {
    return "dungeon-list-objects --room <room_id> [--format <json|text>]";
  }
 
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override {
    return parser.RequireArgs({"room"});
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class DungeonGetRoomTilesCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const { return "dungeon-get-room-tiles"; }
  std::string GetDescription() const {
    return "Get tile data for a dungeon room";
  }
  std::string GetUsage() const {
    return "dungeon-get-room-tiles --room <room_id> [--format <json|text>]";
  }
 
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override {
    return parser.RequireArgs({"room"});
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class DungeonSetRoomPropertyCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const { return "dungeon-set-room-property"; }
  std::string GetDescription() const {
    return "Set a property on a dungeon room";
  }
  std::string GetUsage() const {
    return "dungeon-set-room-property --room <room_id> --property <property> "
           "--value <value> [--manifest <path>] [--format <json|text>]";
  }
 
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override {
    return parser.RequireArgs({"room", "property", "value"});
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class DungeonRoomHeaderCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const { return "dungeon-room-header"; }
  std::string GetDescription() const {
    return "Read raw room header bytes for debugging ROM address issues";
  }
  std::string GetUsage() const {
    return "dungeon-room-header --room <room_id> [--format <json|text>]";
  }
 
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override {
    return parser.RequireArgs({"room"});
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class DungeonGenerateTrackCollisionCommandHandler
    : public resources::CommandHandler {
 public:
  std::string GetName() const { return "dungeon-generate-track-collision"; }
  std::string GetDescription() const {
    return "Generate collision overlay from rail objects for minecart rooms";
  }
  std::string GetUsage() const {
    return "dungeon-generate-track-collision --room <room_id> | "
           "--rooms <hex,hex,...> "
           "[--write] [--preserve-stops] [--visualize] [--promote-switch X,Y] "
           "[--project-context <path.yaze|path.yazeproj>] "
           "[--format <json|text>]";
  }
 
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override {
    // Accept either --room (single) or --rooms (batch)
    if (parser.GetString("room").has_value() ||
        parser.GetString("rooms").has_value()) {
      return absl::OkStatus();
    }
    return absl::InvalidArgumentError("Either --room or --rooms is required");
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
}  // namespace handlers
}  // namespace cli
}  // namespace yaze
 
#endif  // YAZE_SRC_CLI_HANDLERS_DUNGEON_COMMANDS_H_