entity_operations.cc

Go to the documentation of this file.

#include "entity_operations.h"
 
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <utility>
 
#include "absl/strings/str_format.h"
#include "util/log.h"
 
namespace yaze {
namespace editor {
namespace {
 
struct EntityInsertionPosition {
  int parent_map;
  int x;
  int y;
  uint8_t game_x;
  uint8_t game_y;
};
 
absl::StatusOr<EntityInsertionPosition> ResolveEntityInsertionPosition(
    const std::vector<zelda3::OverworldMap>& maps, ImVec2 world_position,
    int current_map) {
  if (current_map < 0 || current_map >= zelda3::kExpandedMapCount ||
      current_map >= static_cast<int>(maps.size())) {
    return absl::InvalidArgumentError("Invalid entity insertion map");
  }
  if (!std::isfinite(world_position.x) || !std::isfinite(world_position.y) ||
      world_position.x < 0 || world_position.y < 0 ||
      world_position.x >= 4096 || world_position.y >= 4096) {
    return absl::InvalidArgumentError("Invalid entity insertion position");
  }
 
  const int x = static_cast<int>(world_position.x) / 16 * 16;
  const int y = static_cast<int>(world_position.y) / 16 * 16;
  const int world = current_map / 64;
  const int screen = world * 64 + x / 512 + (y / 512) * 8;
  if (screen != current_map) {
    return absl::InvalidArgumentError(
        "Entity insertion position does not belong to the selected screen");
  }
 
  const int raw_parent = maps[current_map].parent();
  const int parent = raw_parent == 0xFF ? current_map : raw_parent;
  if (parent < 0 || parent >= zelda3::kExpandedMapCount ||
      parent >= static_cast<int>(maps.size()) || parent / 64 != world) {
    return absl::InvalidArgumentError("Invalid entity insertion parent map");
  }
  const int parent_parent = maps[parent].parent();
  if (parent_parent != parent && parent_parent != 0xFF) {
    return absl::InvalidArgumentError(
        "Entity insertion parent is not a root map");
  }
 
  // Game coordinates span the entire parent area, including the other screens
  // of a large/wide/tall area. Taking world_position modulo 512 loses that
  // quadrant offset and causes items to move after save/reload.
  const int game_x = (x - (parent % 8) * 512) / 16;
  const int game_y = (y - ((parent % 64) / 8) * 512) / 16;
  if (game_x < 0 || game_x > 63 || game_y < 0 || game_y > 63) {
    return absl::InvalidArgumentError(
        "Entity insertion position is outside the parent coordinate range");
  }
  return EntityInsertionPosition{parent, x, y, static_cast<uint8_t>(game_x),
                                 static_cast<uint8_t>(game_y)};
}
 
bool MatchesItemIdentity(const zelda3::OverworldItem& lhs,
                         const zelda3::OverworldItem& rhs) {
  return lhs.id_ == rhs.id_ && lhs.room_map_id_ == rhs.room_map_id_ &&
         lhs.x_ == rhs.x_ && lhs.y_ == rhs.y_ && lhs.game_x_ == rhs.game_x_ &&
         lhs.game_y_ == rhs.game_y_ && lhs.bg2_ == rhs.bg2_;
}
 
absl::Status ValidateRecordPosition(const zelda3::Overworld& overworld,
                                    int map_id, int x, int y) {
  const auto* parent = overworld.overworld_map(map_id);
  if (map_id < 0 || map_id >= zelda3::kExpandedMapCount || !parent) {
    return absl::InvalidArgumentError("The record's map is not available");
  }
  if (parent->parent() != map_id && parent->parent() != 0xFF) {
    return absl::InvalidArgumentError("Choose the area's parent map");
  }
  if (x < 0 || y < 0 || x >= 4096 || y >= 4096) {
    return absl::InvalidArgumentError("Position must be within 0-4095 pixels");
  }
  const auto size = parent->area_size();
  const int width = (size == zelda3::AreaSizeEnum::LargeArea ||
                     size == zelda3::AreaSizeEnum::WideArea)
                        ? 1024
                        : 512;
  const int height = (size == zelda3::AreaSizeEnum::LargeArea ||
                      size == zelda3::AreaSizeEnum::TallArea)
                         ? 1024
                         : 512;
  const int local_x = x - (map_id % 8) * 512;
  const int local_y = y - ((map_id % 64) / 8) * 512;
  const int screen = (map_id / 64) * 64 + x / 512 + (y / 512) * 8;
  const auto* page = overworld.overworld_map(screen);
  const int page_parent =
      page ? (page->parent() == 0xFF ? screen : page->parent()) : -1;
  if (local_x < 0 || local_y < 0 || local_x >= width || local_y >= height ||
      screen / 64 != map_id / 64 || !page || page_parent != map_id) {
    return absl::InvalidArgumentError(
        "Position does not belong to the selected parent area");
  }
  return absl::OkStatus();
}
 
}  // namespace
 
absl::StatusOr<zelda3::OverworldEntrance> BuildOverworldEntranceEdit(
    const zelda3::Overworld& overworld,
    const std::vector<zelda3::OverworldEntrance>& records, size_t row,
    const zelda3::OverworldEntrance& draft, bool legacy_hole_table) {
  if (row >= records.size()) {
    return absl::NotFoundError("Entrance row is no longer available");
  }
  if (draft.is_hole_ != records[row].is_hole_) {
    return absl::InvalidArgumentError("An edit cannot change the record kind");
  }
  auto value = draft;
  value.entity_type_ = zelda3::GameEntity::kEntrance;
  value.entity_id_ = static_cast<int>(row);
  if (value.deleted) {
    value.map_pos_ = 0xFFFF;
    return value;
  }
  RETURN_IF_ERROR(
      ValidateRecordPosition(overworld, value.map_id_, value.x_, value.y_));
  if (value.x_ % 16 != 0 || value.y_ % 16 != 0) {
    return absl::InvalidArgumentError("Entrance position must align to a tile");
  }
  const auto& before = records[row];
  if (value.map_id_ != before.map_id_ || value.x_ != before.x_ ||
      value.y_ != before.y_) {
    value.UpdateMapProperties(value.map_id_, &overworld);
  } else {
    value.map_pos_ = before.map_pos_;
    value.game_x_ = before.game_x_;
    value.game_y_ = before.game_y_;
  }
  // The legacy hole decoder adds $400. Its existing non-wrapping codec
  // cannot round-trip positions in the first eight local tile rows.
  if (legacy_hole_table && value.map_pos_ < 0x400) {
    return absl::InvalidArgumentError(
        "Legacy hole positions must start at local tile row 8");
  }
  for (size_t i = row + 1; i < records.size(); ++i) {
    const auto& other = records[i];
    if (!other.deleted && other.map_id_ == value.map_id_ &&
        other.map_pos_ == value.map_pos_ && other.is_hole_ == value.is_hole_) {
      return absl::FailedPreconditionError(absl::StrFormat(
          "Entrance row %d is shadowed by row %d at this position", row, i));
    }
  }
  return value;
}
 
absl::StatusOr<zelda3::OverworldExit> BuildOverworldExitEdit(
    const zelda3::Overworld& overworld,
    const std::vector<zelda3::OverworldExit>& records, size_t row,
    const zelda3::OverworldExit& draft) {
  if (row >= records.size()) {
    return absl::NotFoundError("Return row is no longer available");
  }
  if (draft.is_hole_ != records[row].is_hole_) {
    return absl::InvalidArgumentError("An edit cannot change the record kind");
  }
  auto value = draft;
  value.entity_type_ = zelda3::GameEntity::kExit;
  value.entity_id_ = static_cast<int>(row);
  if (value.deleted_) {
    // The runtime scans room IDs, not the editor's deleted marker. Retire
    // this authored row's dispatch key as well as its player coordinates.
    value.room_id_ = 0xFFFF;
    value.x_player_ = value.y_player_ = 0xFFFF;
    return value;
  }
  if (value.room_id_ == 0xFFFF) {
    return absl::InvalidArgumentError("Choose a room for this return row");
  }
  RETURN_IF_ERROR(
      ValidateRecordPosition(overworld, value.map_id_, value.x_, value.y_));
  const auto& before = records[row];
  const bool geometry_changed = value.map_id_ != before.map_id_ ||
                                value.x_ != before.x_ || value.y_ != before.y_;
  const bool scroll_changed = value.x_scroll_ != before.x_scroll_ ||
                              value.y_scroll_ != before.y_scroll_;
  const bool camera_changed = value.x_camera_ != before.x_camera_ ||
                              value.y_camera_ != before.y_camera_;
  // Automatic is an editor preference, not a persisted ROM bit. An untouched
  // loaded row must retain its authored camera/VRAM rather than normalize it.
  if (geometry_changed || value.is_automatic_ != before.is_automatic_ ||
      scroll_changed || (value.is_automatic_ && camera_changed)) {
    value.UpdateMapProperties(value.map_id_, &overworld);
  } else {
    value.x_player_ = before.x_player_;
    value.y_player_ = before.y_player_;
    value.map_pos_ = before.map_pos_;
    value.game_x_ = before.game_x_;
    value.game_y_ = before.game_y_;
  }
  for (size_t i = row + 1; i < records.size(); ++i) {
    // The native scan compares room IDs, including rows whose player
    // coordinates contain the unused sentinel.
    if (records[i].room_id_ == value.room_id_) {
      return absl::FailedPreconditionError(absl::StrFormat(
          "Return row %d is shadowed by row %d for this room", row, i));
    }
  }
  return value;
}
 
absl::StatusOr<zelda3::OverworldItem> BuildOverworldItemForInsertion(
    const std::vector<zelda3::OverworldMap>& maps, ImVec2 world_position,
    int current_map, uint8_t item_id) {
  auto position =
      ResolveEntityInsertionPosition(maps, world_position, current_map);
  if (!position.ok()) {
    return position.status();
  }
  // This constructor already derives game coordinates from the parent origin.
  return zelda3::OverworldItem(item_id,
                               static_cast<uint16_t>(position->parent_map),
                               position->x, position->y, false);
}
 
absl::StatusOr<zelda3::Sprite> BuildOverworldSpriteForInsertion(
    const std::vector<zelda3::OverworldMap>& maps, ImVec2 world_position,
    int current_map, uint8_t sprite_id) {
  auto position =
      ResolveEntityInsertionPosition(maps, world_position, current_map);
  if (!position.ok()) {
    return position.status();
  }
  static const std::vector<uint8_t> empty_gfx;
  const auto& gfx = current_map < static_cast<int>(maps.size())
                        ? maps[current_map].current_graphics()
                        : empty_gfx;
  return zelda3::Sprite(gfx, static_cast<uint8_t>(position->parent_map),
                        sprite_id, position->game_x, position->game_y,
                        position->x, position->y);
}
 
absl::StatusOr<zelda3::OverworldEntrance*> InsertEntrance(
    zelda3::Overworld* overworld, ImVec2 mouse_pos, int current_map,
    bool is_hole) {
  if (!overworld || !overworld->is_loaded()) {
    return absl::FailedPreconditionError("Overworld not loaded");
  }
 
  if (is_hole && overworld->expanded_entrances()) {
    return absl::FailedPreconditionError(
        "Expanded holes use existing combined entrance table rows");
  }
 
  // Snap to 16x16 grid and clamp to bounds (ZScream: EntranceMode.cs:86-87)
  ImVec2 snapped_pos = ClampToOverworldBounds(SnapToEntityGrid(mouse_pos));
 
  // Get parent map ID (ZScream: EntranceMode.cs:78-82)
  auto* current_ow_map = overworld->overworld_map(current_map);
  uint8_t map_id = GetParentMapId(current_ow_map, current_map);
 
  if (is_hole) {
    // Search for first deleted hole slot (ZScream: EntranceMode.cs:74-100)
    auto& holes = overworld->holes();
    for (size_t i = 0; i < holes.size(); ++i) {
      if (holes[i].deleted) {
        // Reuse deleted slot
        holes[i].deleted = false;
        holes[i].map_id_ = map_id;
        holes[i].x_ = static_cast<int>(snapped_pos.x);
        holes[i].y_ = static_cast<int>(snapped_pos.y);
        holes[i].entrance_id_ = 0;  // Default, user configures in popup
        holes[i].is_hole_ = true;
 
        // Update map properties (ZScream: EntranceMode.cs:90)
        holes[i].UpdateMapProperties(map_id, overworld);
 
        LOG_DEBUG("EntityOps",
                  "Inserted hole at slot %zu: pos=(%d,%d) map=0x%02X", i,
                  holes[i].x_, holes[i].y_, map_id);
 
        return &holes[i];
      }
    }
    return absl::ResourceExhaustedError(
        "No space available for new hole. Delete one first.");
 
  } else {
    // Search for first deleted entrance slot (ZScream: EntranceMode.cs:104-130)
    auto* entrances = overworld->mutable_entrances();
    for (size_t i = 0; i < entrances->size(); ++i) {
      if (entrances->at(i).deleted) {
        // Reuse deleted slot
        entrances->at(i).deleted = false;
        entrances->at(i).map_id_ = map_id;
        entrances->at(i).x_ = static_cast<int>(snapped_pos.x);
        entrances->at(i).y_ = static_cast<int>(snapped_pos.y);
        entrances->at(i).entrance_id_ = 0;  // Default, user configures in popup
        entrances->at(i).is_hole_ = false;
 
        // Update map properties (ZScream: EntranceMode.cs:120)
        entrances->at(i).UpdateMapProperties(map_id, overworld);
 
        LOG_DEBUG("EntityOps",
                  "Inserted entrance at slot %zu: pos=(%d,%d) map=0x%02X", i,
                  entrances->at(i).x_, entrances->at(i).y_, map_id);
 
        return &entrances->at(i);
      }
    }
    return absl::ResourceExhaustedError(
        "No space available for new entrance. Delete one first.");
  }
}
 
absl::StatusOr<zelda3::OverworldExit*> InsertExit(zelda3::Overworld* overworld,
                                                  ImVec2 mouse_pos,
                                                  int current_map) {
  if (!overworld || !overworld->is_loaded()) {
    return absl::FailedPreconditionError("Overworld not loaded");
  }
 
  // Snap to 16x16 grid and clamp to bounds (ZScream: ExitMode.cs:71-72)
  ImVec2 snapped_pos = ClampToOverworldBounds(SnapToEntityGrid(mouse_pos));
 
  // Get parent map ID (ZScream: ExitMode.cs:63-67)
  auto* current_ow_map = overworld->overworld_map(current_map);
  uint8_t map_id = GetParentMapId(current_ow_map, current_map);
 
  // Search for first deleted exit slot (ZScream: ExitMode.cs:59-124)
  auto& exits = *overworld->mutable_exits();
  for (size_t i = 0; i < exits.size(); ++i) {
    if (exits[i].deleted_) {
      // Reuse deleted slot
      exits[i].deleted_ = false;
      exits[i].map_id_ = map_id;
      exits[i].x_ = static_cast<int>(snapped_pos.x);
      exits[i].y_ = static_cast<int>(snapped_pos.y);
 
      // Initialize with default values (ZScream: ExitMode.cs:95-112)
      // User will configure room_id, scroll, camera in popup
      exits[i].room_id_ = 0;
      exits[i].x_scroll_ = 0;
      exits[i].y_scroll_ = 0;
      exits[i].x_camera_ = 0;
      exits[i].y_camera_ = 0;
      exits[i].x_player_ = static_cast<uint16_t>(snapped_pos.x);
      exits[i].y_player_ = static_cast<uint16_t>(snapped_pos.y);
      exits[i].scroll_mod_x_ = 0;
      exits[i].scroll_mod_y_ = 0;
      exits[i].door_type_1_ = 0;
      exits[i].door_type_2_ = 0;
 
      // Update map properties with overworld context for area size detection
      exits[i].UpdateMapProperties(map_id, overworld);
 
      LOG_DEBUG("EntityOps",
                "Inserted exit at slot %zu: pos=(%d,%d) map=0x%02X", i,
                exits[i].x_, exits[i].y_, map_id);
 
      return &exits[i];
    }
  }
 
  return absl::ResourceExhaustedError(
      "No space available for new exit. Delete one first.");
}
 
absl::StatusOr<zelda3::Sprite*> InsertSprite(zelda3::Overworld* overworld,
                                             ImVec2 mouse_pos, int current_map,
                                             int game_state,
                                             uint8_t sprite_id) {
  if (!overworld || !overworld->is_loaded()) {
    return absl::FailedPreconditionError("Overworld not loaded");
  }
 
  if (game_state < 0 || game_state > 2) {
    return absl::InvalidArgumentError("Invalid game state (must be 0-2)");
  }
 
  auto sprite = BuildOverworldSpriteForInsertion(
      overworld->overworld_maps(), mouse_pos, current_map, sprite_id);
  if (!sprite.ok()) {
    return sprite.status();
  }
 
  // Add new sprite to the game state array (ZScream: SpriteMode.cs:34-35)
  auto& sprites = *overworld->mutable_sprites(game_state);
 
  sprites.push_back(std::move(*sprite));
 
  // Return pointer to the newly added sprite
  zelda3::Sprite* inserted_sprite = &sprites.back();
 
  LOG_DEBUG(
      "EntityOps",
      "Inserted sprite at game_state=%d: pos=(%d,%d) map=0x%02X id=0x%02X",
      game_state, inserted_sprite->x_, inserted_sprite->y_,
      inserted_sprite->map_id(), sprite_id);
 
  return inserted_sprite;
}
 
absl::StatusOr<zelda3::OverworldItem*> InsertItem(zelda3::Overworld* overworld,
                                                  ImVec2 mouse_pos,
                                                  int current_map,
                                                  uint8_t item_id) {
  if (!overworld || !overworld->is_loaded()) {
    return absl::FailedPreconditionError("Overworld not loaded");
  }
 
  auto item = BuildOverworldItemForInsertion(overworld->overworld_maps(),
                                             mouse_pos, current_map, item_id);
  if (!item.ok()) {
    return item.status();
  }
 
  // Add new item to the all_items array (ZScream: ItemMode.cs:92-108)
  auto& items = *overworld->mutable_all_items();
 
  items.push_back(std::move(*item));
 
  zelda3::OverworldItem* inserted_item = &items.back();
 
  LOG_DEBUG("EntityOps",
            "Inserted item: pos=(%d,%d) game=(%d,%d) map=0x%02X id=0x%02X",
            inserted_item->x_, inserted_item->y_, inserted_item->game_x_,
            inserted_item->game_y_, inserted_item->room_map_id_, item_id);
 
  return inserted_item;
}
 
absl::Status RemoveItem(zelda3::Overworld* overworld,
                        const zelda3::OverworldItem* item_ptr) {
  if (!overworld) {
    return absl::InvalidArgumentError("Overworld is null");
  }
  if (!item_ptr) {
    return absl::InvalidArgumentError("Item pointer is null");
  }
 
  auto* items = overworld->mutable_all_items();
  auto it = std::find_if(items->begin(), items->end(),
                         [item_ptr](const zelda3::OverworldItem& item) {
                           return &item == item_ptr;
                         });
  if (it == items->end()) {
    return absl::NotFoundError("Item pointer not found in overworld item list");
  }
 
  items->erase(it);
  return absl::OkStatus();
}
 
absl::Status RemoveItemByIdentity(zelda3::Overworld* overworld,
                                  const zelda3::OverworldItem& item_identity) {
  if (!overworld) {
    return absl::InvalidArgumentError("Overworld is null");
  }
 
  auto* items = overworld->mutable_all_items();
  auto it = std::find_if(items->begin(), items->end(),
                         [&item_identity](const zelda3::OverworldItem& item) {
                           return MatchesItemIdentity(item, item_identity);
                         });
  if (it == items->end()) {
    return absl::NotFoundError("No matching item identity in overworld list");
  }
 
  items->erase(it);
  return absl::OkStatus();
}
 
zelda3::OverworldItem* FindItemByIdentity(
    zelda3::Overworld* overworld, const zelda3::OverworldItem& item_identity) {
  if (!overworld) {
    return nullptr;
  }
 
  auto* items = overworld->mutable_all_items();
  auto it = std::find_if(items->begin(), items->end(),
                         [&item_identity](const zelda3::OverworldItem& item) {
                           return !item.deleted &&
                                  MatchesItemIdentity(item, item_identity);
                         });
  if (it == items->end()) {
    return nullptr;
  }
  return &(*it);
}
 
absl::StatusOr<zelda3::OverworldItem*> DuplicateItemByIdentity(
    zelda3::Overworld* overworld, const zelda3::OverworldItem& item_identity,
    int offset_x, int offset_y) {
  if (!overworld) {
    return absl::InvalidArgumentError("Overworld is null");
  }
 
  auto* source_item = FindItemByIdentity(overworld, item_identity);
  if (!source_item) {
    return absl::NotFoundError("No matching item identity in overworld list");
  }
 
  zelda3::OverworldItem duplicate = *source_item;
  const ImVec2 clamped_pos = ClampToOverworldBounds(
      ImVec2(static_cast<float>(source_item->x_ + offset_x),
             static_cast<float>(source_item->y_ + offset_y)));
  duplicate.x_ = static_cast<int>(clamped_pos.x);
  duplicate.y_ = static_cast<int>(clamped_pos.y);
  duplicate.deleted = false;
  duplicate.UpdateMapProperties(duplicate.room_map_id_);
 
  auto* items = overworld->mutable_all_items();
  items->push_back(duplicate);
  return &items->back();
}
 
absl::Status NudgeItem(zelda3::OverworldItem* item, int delta_x, int delta_y) {
  if (!item) {
    return absl::InvalidArgumentError("Item pointer is null");
  }
  const ImVec2 clamped_pos =
      ClampToOverworldBounds(ImVec2(static_cast<float>(item->x_ + delta_x),
                                    static_cast<float>(item->y_ + delta_y)));
  item->x_ = static_cast<int>(clamped_pos.x);
  item->y_ = static_cast<int>(clamped_pos.y);
  item->UpdateMapProperties(item->room_map_id_);
  return absl::OkStatus();
}
 
zelda3::OverworldItem* FindNearestItemForSelection(
    zelda3::Overworld* overworld,
    const zelda3::OverworldItem& anchor_identity) {
  if (!overworld) {
    return nullptr;
  }
 
  auto* items = overworld->mutable_all_items();
  if (!items || items->empty()) {
    return nullptr;
  }
 
  const int anchor_x = anchor_identity.x_;
  const int anchor_y = anchor_identity.y_;
  const uint16_t anchor_map = anchor_identity.room_map_id_;
 
  auto rank = [&](const zelda3::OverworldItem& item) {
    const int same_map_rank = (item.room_map_id_ == anchor_map) ? 0 : 1;
    const std::int64_t dx = static_cast<std::int64_t>(item.x_) - anchor_x;
    const std::int64_t dy = static_cast<std::int64_t>(item.y_) - anchor_y;
    const std::int64_t dist2 = (dx * dx) + (dy * dy);
    return std::pair<int, std::int64_t>(same_map_rank, dist2);
  };
 
  auto best_it = items->end();
  std::pair<int, std::int64_t> best_rank = {2, 0};
  for (auto it = items->begin(); it != items->end(); ++it) {
    if (it->deleted) {
      continue;
    }
    const auto current_rank = rank(*it);
    if (best_it == items->end() || current_rank < best_rank) {
      best_it = it;
      best_rank = current_rank;
    }
  }
 
  if (best_it == items->end()) {
    return nullptr;
  }
  return &(*best_it);
}
 
}  // namespace editor
}  // namespace yaze