overworld_commands.cc

Go to the documentation of this file.

#include "cli/handlers/game/overworld_commands.h"
 
#include "absl/strings/str_format.h"
#include "cli/handlers/game/overworld_inspect.h"
#include "cli/util/hex_util.h"
#include "util/macro.h"
#include "zelda3/overworld/overworld.h"
#include "zelda3/overworld/overworld_item.h"
#include "zelda3/zelda3_labels.h"
 
namespace yaze {
namespace cli {
namespace handlers {
 
using util::ParseHexString;
 
namespace {
 
absl::Status ValidateMapId(int map_id) {
  if (map_id < 0 || map_id >= zelda3::kNumOverworldMaps) {
    return absl::InvalidArgumentError(
        absl::StrFormat("Map ID out of range: 0x%02X", map_id));
  }
  return absl::OkStatus();
}
 
absl::Status SetOverworldContextForMap(int map_id,
                                       zelda3::Overworld* overworld) {
  RETURN_IF_ERROR(ValidateMapId(map_id));
  int world = 0;
  if (map_id < 0x40) {
    world = 0;
  } else if (map_id < 0x80) {
    world = 1;
  } else {
    world = 2;
  }
  overworld->set_current_world(world);
  overworld->set_current_map(map_id);
  return absl::OkStatus();
}
 
absl::Status ValidateTileCoordinates(int x, int y) {
  if (x < 0 || x >= 64 || y < 0 || y >= 64) {
    return absl::InvalidArgumentError(
        absl::StrFormat("Tile coordinates out of range: (%d,%d)", x, y));
  }
  return absl::OkStatus();
}
 
}  // namespace
 
absl::Status OverworldGetTileCommandHandler::Execute(
    Rom* rom, const resources::ArgumentParser& parser,
    resources::OutputFormatter& formatter) {
  int map_id = 0;
  int x = 0;
  int y = 0;
  if (!ParseHexString(parser.GetString("map").value(), &map_id) ||
      !ParseHexString(parser.GetString("x").value(), &x) ||
      !ParseHexString(parser.GetString("y").value(), &y)) {
    return absl::InvalidArgumentError("Invalid numeric argument for map/x/y.");
  }
  RETURN_IF_ERROR(ValidateMapId(map_id));
  RETURN_IF_ERROR(ValidateTileCoordinates(x, y));
 
  zelda3::Overworld overworld(rom);
  RETURN_IF_ERROR(overworld.Load(rom));
  RETURN_IF_ERROR(SetOverworldContextForMap(map_id, &overworld));
 
  const uint16_t tile = overworld.GetTile(x, y);
  formatter.BeginObject("Overworld Tile");
  formatter.AddHexField("map_id", map_id, 2);
  formatter.AddField("x", x);
  formatter.AddField("y", y);
  formatter.AddHexField("tile_id", tile, 4);
  formatter.EndObject();
  return absl::OkStatus();
}
 
absl::Status OverworldSetTileCommandHandler::Execute(
    Rom* rom, const resources::ArgumentParser& parser,
    resources::OutputFormatter& formatter) {
  int map_id = 0;
  int x = 0;
  int y = 0;
  int tile_value = 0;
  if (!ParseHexString(parser.GetString("map").value(), &map_id) ||
      !ParseHexString(parser.GetString("x").value(), &x) ||
      !ParseHexString(parser.GetString("y").value(), &y) ||
      !ParseHexString(parser.GetString("tile").value(), &tile_value)) {
    return absl::InvalidArgumentError(
        "Invalid numeric argument for map/x/y/tile.");
  }
  RETURN_IF_ERROR(ValidateMapId(map_id));
  RETURN_IF_ERROR(ValidateTileCoordinates(x, y));
  if (tile_value < 0 || tile_value > 0xFFFF) {
    return absl::InvalidArgumentError(
        absl::StrFormat("Tile ID out of range: 0x%X", tile_value));
  }
 
  zelda3::Overworld overworld(rom);
  RETURN_IF_ERROR(overworld.Load(rom));
  RETURN_IF_ERROR(SetOverworldContextForMap(map_id, &overworld));
 
  const uint16_t before = overworld.GetTile(x, y);
  overworld.SetTile(x, y, static_cast<uint16_t>(tile_value));
  const uint16_t after = overworld.GetTile(x, y);
 
  RETURN_IF_ERROR(overworld.SaveMap16Tiles());
  RETURN_IF_ERROR(overworld.SaveMap32Tiles());
  RETURN_IF_ERROR(overworld.SaveOverworldMaps());
 
  formatter.BeginObject("Overworld Tile Write");
  formatter.AddHexField("map_id", map_id, 2);
  formatter.AddField("x", x);
  formatter.AddField("y", y);
  formatter.AddHexField("tile_before", before, 4);
  formatter.AddHexField("tile_after", after, 4);
  if (parser.HasFlag("mock-rom")) {
    formatter.AddField("save_status", "mock-rom-skipped");
  } else {
    Rom::SaveSettings save_settings;
    save_settings.backup = true;
    RETURN_IF_ERROR(rom->SaveToFile(save_settings));
    formatter.AddField("save_status", "saved");
  }
  formatter.EndObject();
  return absl::OkStatus();
}
 
absl::Status OverworldFindTileCommandHandler::Execute(
    Rom* rom, const resources::ArgumentParser& parser,
    resources::OutputFormatter& formatter) {
  auto tile_id_str = parser.GetString("tile").value();
 
  int tile_id;
  if (!ParseHexString(tile_id_str, &tile_id)) {
    return absl::InvalidArgumentError("Invalid tile ID format. Must be hex.");
  }
 
  // Load the Overworld from ROM
  zelda3::Overworld overworld(rom);
  auto ow_status = overworld.Load(rom);
  if (!ow_status.ok()) {
    return ow_status;
  }
 
  // Call the helper function to find tile matches
  auto matches_or = overworld::FindTileMatches(overworld, tile_id);
  if (!matches_or.ok()) {
    return matches_or.status();
  }
  const auto& matches = matches_or.value();
 
  // Format the output
  formatter.BeginObject("Overworld Tile Search");
  formatter.AddField("tile_id", absl::StrFormat("0x%03X", tile_id));
  formatter.AddField("matches_found", static_cast<int>(matches.size()));
 
  formatter.BeginArray("matches");
  for (const auto& match : matches) {
    formatter.BeginObject();
    formatter.AddField("map_id", absl::StrFormat("0x%02X", match.map_id));
    formatter.AddField("world", overworld::WorldName(match.world));
    formatter.AddField("local_x", match.local_x);
    formatter.AddField("local_y", match.local_y);
    formatter.AddField("global_x", match.global_x);
    formatter.AddField("global_y", match.global_y);
    formatter.EndObject();
  }
  formatter.EndArray();
  formatter.EndObject();
 
  return absl::OkStatus();
}
 
absl::Status OverworldDescribeMapCommandHandler::Execute(
    Rom* rom, const resources::ArgumentParser& parser,
    resources::OutputFormatter& formatter) {
  auto screen_id_str = parser.GetString("screen").value();
 
  int screen_id;
  if (!ParseHexString(screen_id_str, &screen_id)) {
    return absl::InvalidArgumentError("Invalid screen ID format. Must be hex.");
  }
 
  // Load the Overworld from ROM
  zelda3::Overworld overworld(rom);
  auto ow_status = overworld.Load(rom);
  if (!ow_status.ok()) {
    return ow_status;
  }
 
  // Call the helper function to build the map summary
  auto summary_or = overworld::BuildMapSummary(overworld, screen_id);
  if (!summary_or.ok()) {
    return summary_or.status();
  }
  const auto& summary = summary_or.value();
 
  // Format the output using OutputFormatter
  formatter.AddField("screen_id", absl::StrFormat("0x%02X", summary.map_id));
  formatter.AddField("world", overworld::WorldName(summary.world));
 
  formatter.BeginObject("grid");
  formatter.AddField("x", summary.map_x);
  formatter.AddField("y", summary.map_y);
  formatter.AddField("local_index", summary.local_index);
  formatter.EndObject();
 
  formatter.BeginObject("size");
  formatter.AddField("label", summary.area_size);
  formatter.AddField("is_large", summary.is_large_map);
  formatter.AddField("parent", absl::StrFormat("0x%02X", summary.parent_map));
  formatter.AddField("quadrant", summary.large_quadrant);
  formatter.EndObject();
 
  formatter.AddField("message_id",
                     absl::StrFormat("0x%04X", summary.message_id));
  formatter.AddField("area_graphics",
                     absl::StrFormat("0x%02X", summary.area_graphics));
  formatter.AddField("area_palette",
                     absl::StrFormat("0x%02X", summary.area_palette));
  formatter.AddField("main_palette",
                     absl::StrFormat("0x%02X", summary.main_palette));
  formatter.AddField("animated_gfx",
                     absl::StrFormat("0x%02X", summary.animated_gfx));
  formatter.AddField("subscreen_overlay",
                     absl::StrFormat("0x%04X", summary.subscreen_overlay));
  formatter.AddField("area_specific_bg_color",
                     absl::StrFormat("0x%04X", summary.area_specific_bg_color));
 
  // Entrances
  formatter.BeginArray("entrances");
  auto entrances_or = zelda3::LoadEntrances(rom);
  if (entrances_or.ok()) {
    for (const auto& entrance : entrances_or.value()) {
      if (entrance.map_id_ == screen_id) {
        formatter.BeginObject();
        formatter.AddField("entrance_id", entrance.entrance_id_);
        formatter.AddField("x", entrance.x_);
        formatter.AddField("y", entrance.y_);
        formatter.AddField("is_hole", false);
        formatter.EndObject();
      }
    }
  }
  // Holes (as entrances)
  auto holes_or = zelda3::LoadHoles(rom);
  if (holes_or.ok()) {
    for (const auto& hole : holes_or.value()) {
      if (hole.map_id_ == screen_id) {
        formatter.BeginObject();
        formatter.AddField("entrance_id", hole.entrance_id_);
        formatter.AddField("x", hole.x_);
        formatter.AddField("y", hole.y_);
        formatter.AddField("is_hole", true);
        formatter.EndObject();
      }
    }
  }
  formatter.EndArray();
 
  // Exits
  formatter.BeginArray("exits");
  auto exits_or = zelda3::LoadExits(rom);
  if (exits_or.ok()) {
    for (const auto& exit : exits_or.value()) {
      if (exit.map_id_ == screen_id) {
        formatter.BeginObject();
        formatter.AddField("room_id", exit.room_id_);
        formatter.AddField("x", exit.x_);
        formatter.AddField("y", exit.y_);
        formatter.EndObject();
      }
    }
  }
  formatter.EndArray();
 
  formatter.BeginArray("sprite_graphics");
  for (uint8_t gfx : summary.sprite_graphics) {
    formatter.AddArrayItem(absl::StrFormat("0x%02X", gfx));
  }
  formatter.EndArray();
 
  formatter.BeginArray("sprite_palettes");
  for (uint8_t pal : summary.sprite_palettes) {
    formatter.AddArrayItem(absl::StrFormat("0x%02X", pal));
  }
  formatter.EndArray();
 
  formatter.BeginArray("area_music");
  for (uint8_t music : summary.area_music) {
    formatter.AddArrayItem(absl::StrFormat("0x%02X", music));
  }
  formatter.EndArray();
 
  formatter.BeginArray("static_graphics");
  for (uint8_t sgfx : summary.static_graphics) {
    formatter.AddArrayItem(absl::StrFormat("0x%02X", sgfx));
  }
  formatter.EndArray();
 
  formatter.BeginObject("overlay");
  formatter.AddField("enabled", summary.has_overlay);
  formatter.AddField("id", absl::StrFormat("0x%04X", summary.overlay_id));
  formatter.EndObject();
 
  formatter.EndObject();
 
  return absl::OkStatus();
}
 
absl::Status OverworldListWarpsCommandHandler::Execute(
    Rom* rom, const resources::ArgumentParser& parser,
    resources::OutputFormatter& formatter) {
  auto screen_id_str = parser.GetString("screen").value_or("all");
 
  // Load the Overworld from ROM
  zelda3::Overworld overworld(rom);
  auto ow_status = overworld.Load(rom);
  if (!ow_status.ok()) {
    return ow_status;
  }
 
  // Build the query
  overworld::WarpQuery query;
  if (screen_id_str != "all") {
    int map_id;
    if (!ParseHexString(screen_id_str, &map_id)) {
      return absl::InvalidArgumentError(
          "Invalid screen ID format. Must be hex.");
    }
    query.map_id = map_id;
  }
 
  // Call the helper function to collect warp entries
  auto warps_or = overworld::CollectWarpEntries(overworld, query);
  if (!warps_or.ok()) {
    return warps_or.status();
  }
  const auto& warps = warps_or.value();
 
  // Format the output
  formatter.BeginObject("Overworld Warps");
  formatter.AddField("screen_filter", screen_id_str);
  formatter.AddField("total_warps", static_cast<int>(warps.size()));
 
  formatter.BeginArray("warps");
  for (const auto& warp : warps) {
    formatter.BeginObject();
    formatter.AddField("type", overworld::WarpTypeName(warp.type));
    formatter.AddField("map_id", absl::StrFormat("0x%02X", warp.map_id));
    formatter.AddField("world", overworld::WorldName(warp.world));
    formatter.AddField("position",
                       absl::StrFormat("(%d,%d)", warp.pixel_x, warp.pixel_y));
    formatter.AddField("map_pos", absl::StrFormat("0x%04X", warp.map_pos));
 
    if (warp.entrance_id.has_value()) {
      formatter.AddField("entrance_id",
                         absl::StrFormat("0x%02X", warp.entrance_id.value()));
    }
    if (warp.entrance_name.has_value()) {
      formatter.AddField("entrance_name", warp.entrance_name.value());
    }
    if (warp.room_id.has_value()) {
      formatter.AddField("room_id",
                         absl::StrFormat("0x%04X", warp.room_id.value()));
    }
 
    formatter.AddField("deleted", warp.deleted);
    formatter.AddField("is_hole", warp.is_hole);
    formatter.EndObject();
  }
  formatter.EndArray();
  formatter.EndObject();
 
  return absl::OkStatus();
}
 
absl::Status OverworldListSpritesCommandHandler::Execute(
    Rom* rom, const resources::ArgumentParser& parser,
    resources::OutputFormatter& formatter) {
  auto screen_id_str = parser.GetString("screen").value_or("all");
 
  // Load the Overworld from ROM
  zelda3::Overworld overworld(rom);
  auto ow_status = overworld.Load(rom);
  if (!ow_status.ok()) {
    return ow_status;
  }
 
  // Build the query
  overworld::SpriteQuery query;
  if (screen_id_str != "all") {
    int map_id;
    if (!ParseHexString(screen_id_str, &map_id)) {
      return absl::InvalidArgumentError(
          "Invalid screen ID format. Must be hex.");
    }
    query.map_id = map_id;
  }
 
  // Call the helper function to collect sprites
  auto sprites_or = overworld::CollectOverworldSprites(overworld, query);
  if (!sprites_or.ok()) {
    return sprites_or.status();
  }
  const auto& sprites = sprites_or.value();
 
  // Format the output
  formatter.BeginObject("Overworld Sprites");
  formatter.AddField("screen_filter", screen_id_str);
  formatter.AddField("total_sprites", static_cast<int>(sprites.size()));
 
  formatter.BeginArray("sprites");
  for (const auto& sprite : sprites) {
    formatter.BeginObject();
    formatter.AddField("sprite_id",
                       absl::StrFormat("0x%02X", sprite.sprite_id));
    formatter.AddField("map_id", absl::StrFormat("0x%02X", sprite.map_id));
    formatter.AddField("world", overworld::WorldName(sprite.world));
    formatter.AddField("position",
                       absl::StrFormat("(%d,%d)", sprite.x, sprite.y));
 
    if (sprite.sprite_name.has_value()) {
      formatter.AddField("name", sprite.sprite_name.value());
    }
 
    formatter.EndObject();
  }
  formatter.EndArray();
  formatter.EndObject();
 
  return absl::OkStatus();
}
 
absl::Status OverworldListItemsCommandHandler::Execute(
    Rom* rom, const resources::ArgumentParser& parser,
    resources::OutputFormatter& formatter) {
  auto screen_id_str = parser.GetString("screen").value_or("all");
 
  // Load the Overworld from ROM
  zelda3::Overworld overworld(rom);
  auto ow_status = overworld.Load(rom);
  if (!ow_status.ok()) {
    return ow_status;
  }
 
  // Optional screen filter
  std::optional<int> map_filter;
  if (screen_id_str != "all") {
    int map_id;
    if (!ParseHexString(screen_id_str, &map_id)) {
      return absl::InvalidArgumentError(
          "Invalid screen ID format. Must be hex.");
    }
    map_filter = map_id;
  }
 
  auto maps = overworld.overworld_maps();
  ASSIGN_OR_RETURN(auto items, zelda3::LoadItems(rom, maps));
 
  const auto& item_names = zelda3::Zelda3Labels::GetItemNames();
 
  formatter.BeginObject("Overworld Items");
  formatter.AddField("screen_filter", screen_id_str);
 
  formatter.BeginArray("items");
  int total_items = 0;
  for (const auto& item : items) {
    if (map_filter.has_value() &&
        static_cast<int>(item.room_map_id_) != map_filter.value()) {
      continue;
    }
 
    std::string world_name = "Unknown";
    auto world_or = overworld::InferWorldFromMapId(item.room_map_id_);
    if (world_or.ok()) {
      world_name = overworld::WorldName(world_or.value());
    }
 
    formatter.BeginObject();
    formatter.AddField("item_id", absl::StrFormat("0x%02X", item.id_));
 
    if (item.id_ < item_names.size()) {
      formatter.AddField("item_name", item_names[item.id_]);
    }
 
    formatter.AddField("map_id", absl::StrFormat("0x%02X", item.room_map_id_));
    formatter.AddField("world", world_name);
    formatter.AddField("tile_pos",
                       absl::StrFormat("(%d,%d)", item.game_x_, item.game_y_));
    formatter.AddField("pixel_pos",
                       absl::StrFormat("(%d,%d)", item.x_, item.y_));
    formatter.EndObject();
 
    total_items++;
  }
  formatter.EndArray();
  formatter.AddField("total_items", total_items);
  formatter.EndObject();
 
  return absl::OkStatus();
}
 
absl::Status OverworldGetEntranceCommandHandler::Execute(
    Rom* rom, const resources::ArgumentParser& parser,
    resources::OutputFormatter& formatter) {
  auto entrance_id_str = parser.GetString("entrance").value();
 
  int entrance_id;
  if (!ParseHexString(entrance_id_str, &entrance_id)) {
    return absl::InvalidArgumentError(
        "Invalid entrance ID format. Must be hex.");
  }
 
  // Load the Overworld from ROM
  zelda3::Overworld overworld(rom);
  auto ow_status = overworld.Load(rom);
  if (!ow_status.ok()) {
    return ow_status;
  }
 
  // Call the helper function to get entrance details
  auto details_or = overworld::GetEntranceDetails(overworld, entrance_id);
  if (!details_or.ok()) {
    return details_or.status();
  }
  const auto& details = details_or.value();
 
  // Format the output
  formatter.BeginObject("Overworld Entrance");
  formatter.AddField("entrance_id",
                     absl::StrFormat("0x%02X", details.entrance_id));
  formatter.AddField("map_id", absl::StrFormat("0x%02X", details.map_id));
  formatter.AddField("world", overworld::WorldName(details.world));
  formatter.AddField("position",
                     absl::StrFormat("(%d,%d)", details.x, details.y));
  formatter.AddField("area_position", absl::StrFormat("(%d,%d)", details.area_x,
                                                      details.area_y));
  formatter.AddField("map_pos", absl::StrFormat("0x%04X", details.map_pos));
  formatter.AddField("is_hole", details.is_hole);
 
  if (details.entrance_name.has_value()) {
    formatter.AddField("name", details.entrance_name.value());
  }
 
  formatter.EndObject();
 
  return absl::OkStatus();
}
 
absl::Status OverworldTileStatsCommandHandler::Execute(
    Rom* rom, const resources::ArgumentParser& parser,
    resources::OutputFormatter& formatter) {
  auto screen_id_str = parser.GetString("screen").value_or("all");
 
  // Load the Overworld from ROM
  zelda3::Overworld overworld(rom);
  auto ow_status = overworld.Load(rom);
  if (!ow_status.ok()) {
    return ow_status;
  }
 
  // TODO: Implement comprehensive tile statistics
  // The AnalyzeTileUsage helper requires a specific tile_id,
  // so we need a different approach to gather overall tile statistics.
  // This could involve:
  // 1. Iterating through all tiles in the overworld maps
  // 2. Building a frequency map of tile usage
  // 3. Computing statistics like unique tiles, most common tiles, etc.
 
  formatter.BeginObject("Overworld Tile Statistics");
  formatter.AddField("screen_filter", screen_id_str);
  formatter.AddField("status", "partial_implementation");
  formatter.AddField("message",
                     "Comprehensive tile statistics not yet implemented. "
                     "Use overworld-find-tile for specific tile analysis.");
  formatter.AddField("total_tiles", 0);
  formatter.AddField("unique_tiles", 0);
 
  formatter.BeginArray("tile_counts");
  formatter.EndArray();
  formatter.EndObject();
 
  return absl::OkStatus();
}
 
}  // namespace handlers
}  // namespace cli
}  // namespace yaze