door_interaction_handler.cc

Go to the documentation of this file.

// Related header
#include "door_interaction_handler.h"
#include "util/i18n/tr.h"
 
// Third-party library headers
#include "imgui/imgui.h"
 
#include <algorithm>
#include <cmath>
#include <string>
 
// Project headers
#include "absl/strings/str_format.h"
#include "app/editor/agent/agent_ui_theme.h"
#include "app/editor/dungeon/dungeon_canvas_viewer.h"
#include "app/editor/dungeon/dungeon_connection_edit.h"
#include "app/editor/dungeon/interaction/ghost_preview_feedback.h"
#include "zelda3/dungeon/dungeon_limits.h"
 
namespace yaze::editor {
 
namespace {
 
PlacementCapacityState ToPlacementCapacityState(
    DoorInteractionHandler::GhostCapacityState state) {
  return static_cast<PlacementCapacityState>(state);
}
 
ImVec2 EstimateBadgeTextSize(const std::string& label) {
  // Overlay hit-testing can run from headless interaction tests before ImGui has
  // baked a font atlas. Keep the clickable region independent of font state.
  return ImVec2(std::max(1.0f, static_cast<float>(label.size()) * 7.0f), 14.0f);
}
 
}  // namespace
 
void DoorInteractionHandler::BeginPlacement() {
  door_placement_mode_ = true;
  ClearSelection();
}
 
void DoorInteractionHandler::CancelPlacement() {
  door_placement_mode_ = false;
  detected_door_direction_ = zelda3::DoorDirection::North;
  snapped_door_position_ = 0;
}
 
bool DoorInteractionHandler::HandleClick(int canvas_x, int canvas_y) {
  if (!HasValidContext())
    return false;
 
  if (door_placement_mode_) {
    if (IsWithinBounds(canvas_x, canvas_y)) {
      PlaceDoorAtSnappedPosition(canvas_x, canvas_y);
    }
    return true;
  }
 
  // Try to select door at position
  auto door_index = GetEntityAtPosition(canvas_x, canvas_y);
  if (door_index.has_value()) {
    const auto* room = ctx_->GetCurrentRoomConst();
    if (!room || *door_index >= room->GetDoors().size()) {
      return false;
    }
    const auto [anchor_x, anchor_y] =
        room->GetDoors()[*door_index].GetPixelCoords();
 
    SelectDoor(*door_index);
    is_dragging_ = true;
    drag_start_pos_ =
        ImVec2(static_cast<float>(canvas_x), static_cast<float>(canvas_y));
    drag_current_pos_ = drag_start_pos_;
    drag_grab_offset_from_anchor_ =
        ImVec2(static_cast<float>(canvas_x - anchor_x),
               static_cast<float>(canvas_y - anchor_y));
    return true;
  }
 
  ClearSelection();
  return false;
}
 
void DoorInteractionHandler::HandleDrag(ImVec2 current_pos, ImVec2 delta) {
  if (!is_dragging_ || !selected_door_index_.has_value())
    return;
 
  drag_current_pos_ = current_pos;
}
 
void DoorInteractionHandler::HandleRelease() {
  mutation_status_ = absl::OkStatus();
  if (!is_dragging_ || !selected_door_index_.has_value()) {
    is_dragging_ = false;
    return;
  }
 
  auto* room = GetCurrentRoom();
  if (!room) {
    is_dragging_ = false;
    return;
  }
 
  if (*selected_door_index_ >= room->GetDoors().size()) {
    is_dragging_ = false;
    return;
  }
 
  // HandleClick primes drag state so a selected door can move immediately, but
  // a plain click must not canonicalize distinct ROM positions that share the
  // same visual snap slot.
  if (drag_current_pos_.x == drag_start_pos_.x &&
      drag_current_pos_.y == drag_start_pos_.y) {
    is_dragging_ = false;
    return;
  }
 
  const auto [drag_x, drag_y] = GetCurrentDragAnchorPosition();
 
  // Detect wall from final position
  zelda3::DoorDirection direction;
  if (zelda3::DoorPositionManager::DetectWallFromPosition(drag_x, drag_y,
                                                          direction)) {
    uint8_t position = zelda3::DoorPositionManager::SnapToNearestPosition(
        drag_x, drag_y, direction);
 
    if (zelda3::DoorPositionManager::IsValidPosition(position, direction)) {
      auto candidate = room->GetDoors();
      auto& door = candidate[*selected_door_index_];
      if (door.position != position || door.direction != direction) {
        door.position = position;
        door.direction = direction;
 
        // Re-encode bytes for ROM storage
        auto [b1, b2] = door.EncodeBytes();
        door.byte1 = b1;
        door.byte2 = b2;
 
        if (!PreflightDoors(candidate)) {
          is_dragging_ = false;
          return;
        }
        room = GetCurrentRoom();
        ctx_->NotifyMutation(MutationDomain::kDoors);
        room->GetDoors() = std::move(candidate);
        room->MarkObjectStreamDirty();
        ctx_->NotifyInvalidateCache(MutationDomain::kDoors);
      }
    }
  }
 
  is_dragging_ = false;
}
 
bool DoorInteractionHandler::HandleOverlayClick(int canvas_x, int canvas_y) {
  if (!selected_door_index_.has_value() || !HasValidContext() || is_dragging_) {
    return false;
  }
 
  auto* room = GetCurrentRoom();
  if (!room) {
    return false;
  }
 
  const auto& doors = room->GetDoors();
  if (*selected_door_index_ >= doors.size()) {
    return false;
  }
 
  const auto& door = doors[*selected_door_index_];
  const auto [door_x, door_y, door_w, door_h] = door.GetEditorBounds();
  const DungeonCanvasTransform transform = GetCanvasTransform();
  const float scale = transform.scale();
  const ImVec2 door_pos = transform.RoomPixelsToScreen(
      ImVec2(static_cast<float>(door_x), static_cast<float>(door_y)));
  const ImVec2 door_size = transform.RoomSizeToScreen(
      ImVec2(static_cast<float>(door_w), static_cast<float>(door_h)));
  const auto badge = BuildPairBadgeOverlay(door, door_pos, door_size, scale);
  if (!badge.has_value() || badge->target_room_id < 0) {
    return false;
  }
 
  const ImVec2 screen_pos = transform.RoomPixelsToScreen(
      ImVec2(static_cast<float>(canvas_x), static_cast<float>(canvas_y)));
  const ImVec2 badge_max(badge->screen_pos.x + badge->screen_size.x,
                         badge->screen_pos.y + badge->screen_size.y);
  if (screen_pos.x < badge->screen_pos.x ||
      screen_pos.y < badge->screen_pos.y || screen_pos.x > badge_max.x ||
      screen_pos.y > badge_max.y) {
    return false;
  }
 
  NavigateToPairBadge(*badge);
  return true;
}
 
DoorInteractionHandler::GhostCapacityState
DoorInteractionHandler::GetPlacementGhostCapacityState() const {
  auto* room = GetCurrentRoom();
  const size_t current_door_count = room ? room->GetDoors().size() : 0;
  return static_cast<GhostCapacityState>(
      GetPlacementCapacityState(current_door_count, zelda3::kMaxDoors));
}
 
void DoorInteractionHandler::DrawGhostPreview() {
  if (!door_placement_mode_ || !HasValidContext())
    return;
 
  const auto pointer_screen_pos = GetPointerScreenPosition();
  if (!pointer_screen_pos.has_value())
    return;
 
  const DungeonCanvasTransform transform = GetCanvasTransform();
  const auto [canvas_x, canvas_y] =
      transform.ScreenToRoomPixelCoordinates(*pointer_screen_pos);
 
  // Try to update snapped position
  if (!UpdateSnappedPosition(canvas_x, canvas_y)) {
    // Placement guidance: make invalid hover state explicit instead of showing
    // no preview.
    const auto& theme = AgentUI::GetTheme();
    ImDrawList* draw_list = ImGui::GetWindowDrawList();
    ImVec2 hint_pos(pointer_screen_pos->x + 14.0f,
                    pointer_screen_pos->y + 10.0f);
    draw_list->AddText(hint_pos, ImGui::GetColorU32(theme.status_warning),
                       "Move cursor near a wall to place door");
    ImGui::SetTooltip(tr("Door placement requires a wall-adjacent position."));
    return;  // Not near a wall
  }
 
  const auto [snap_canvas_x, snap_canvas_y, door_width_px, door_height_px] =
      zelda3::DoorPositionManager::GetDoorEditorBounds(
          snapped_door_position_, detected_door_direction_, preview_door_type_);
 
  // Draw ghost preview
  ImDrawList* draw_list = ImGui::GetWindowDrawList();
  const float scale = transform.scale();
  const ImVec2 preview_start = transform.RoomPixelsToScreen(ImVec2(
      static_cast<float>(snap_canvas_x), static_cast<float>(snap_canvas_y)));
  const ImVec2 preview_size = transform.RoomSizeToScreen(ImVec2(
      static_cast<float>(door_width_px), static_cast<float>(door_height_px)));
  const ImVec2 preview_end(preview_start.x + preview_size.x,
                           preview_start.y + preview_size.y);
 
  const auto& theme = AgentUI::GetTheme();
 
  const auto capacity_state = GetPlacementGhostCapacityState();
  const auto placement_state = ToPlacementCapacityState(capacity_state);
  auto* room = GetCurrentRoom();
  const size_t current_door_count = room ? room->GetDoors().size() : 0;
 
  const ImVec4 base_color = GetPlacementAccentColor(
      theme, placement_state, theme.dungeon_selection_primary);
 
  // Draw semi-transparent filled rectangle
  ImVec4 fill_vec(base_color.x, base_color.y, base_color.z, 0.31f);
  draw_list->AddRectFilled(preview_start, preview_end,
                           ImGui::GetColorU32(fill_vec));
 
  // Draw outline
  ImVec4 outline_color(base_color.x, base_color.y, base_color.z, 0.9f);
  draw_list->AddRect(preview_start, preview_end,
                     ImGui::GetColorU32(outline_color), 0.0f, 2.0f);
 
  // Draw door type label
  std::string type_name(zelda3::GetDoorTypeName(preview_door_type_));
  std::string dir_name(zelda3::GetDoorDirectionName(detected_door_direction_));
  std::string label = type_name + " (" + dir_name + ")";
 
  ImVec2 text_pos(preview_start.x, preview_start.y - 16 * scale);
  draw_list->AddText(text_pos, IM_COL32(255, 255, 255, 200), label.c_str());
 
  const std::string badge_text =
      absl::StrFormat("Doors %zu/%zu", current_door_count, zelda3::kMaxDoors);
  ImVec2 badge_min;
  switch (detected_door_direction_) {
    case zelda3::DoorDirection::North:
      badge_min = ImVec2(preview_start.x, preview_end.y + 6.0f);
      break;
    case zelda3::DoorDirection::South: {
      const ImVec2 badge_size = ImGui::CalcTextSize(badge_text.c_str());
      const ImVec2 status_size = ImGui::CalcTextSize(
          GetPlacementCapacityStatusText(placement_state).data());
      const float badge_height = badge_size.y + status_size.y + 14.0f;
      badge_min =
          ImVec2(preview_start.x, preview_start.y - badge_height - 6.0f);
      break;
    }
    case zelda3::DoorDirection::West:
      badge_min = ImVec2(preview_end.x + 6.0f, preview_start.y);
      break;
    case zelda3::DoorDirection::East: {
      const ImVec2 badge_size = ImGui::CalcTextSize(badge_text.c_str());
      const ImVec2 status_size = ImGui::CalcTextSize(
          GetPlacementCapacityStatusText(placement_state).data());
      const float badge_width = std::max(badge_size.x, status_size.x) + 14.0f;
      badge_min = ImVec2(preview_start.x - badge_width - 6.0f, preview_start.y);
      break;
    }
  }
  DrawPlacementCapacityBadge(draw_list, badge_min, theme, placement_state,
                             badge_text);
 
  // Capacity tooltip when at/near limit
  if (capacity_state != GhostCapacityState::kNormal &&
      ImGui::IsMouseHoveringRect(preview_start, preview_end)) {
    ImGui::SetTooltip(
        tr("Doors: %zu/%zu\n%s"), current_door_count, zelda3::kMaxDoors,
        GetPlacementCapacityTooltipSuffix(placement_state).data());
  }
}
 
void DoorInteractionHandler::DrawSelectionHighlight() {
  if (!selected_door_index_.has_value() || !HasValidContext())
    return;
 
  auto* room = GetCurrentRoom();
  if (!room)
    return;
 
  const auto& doors = room->GetDoors();
  if (*selected_door_index_ >= doors.size())
    return;
 
  const auto& door = doors[*selected_door_index_];
  auto [door_x, door_y, door_w, door_h] = door.GetEditorBounds();
 
  // If dragging, use current drag position for door preview
  if (is_dragging_) {
    const auto [drag_x, drag_y] = GetCurrentDragAnchorPosition();
 
    zelda3::DoorDirection dir;
    bool is_inner = false;
    if (zelda3::DoorPositionManager::DetectWallSection(drag_x, drag_y, dir,
                                                       is_inner)) {
      uint8_t snap_pos = zelda3::DoorPositionManager::SnapToNearestPosition(
          drag_x, drag_y, dir);
      std::tie(door_x, door_y, door_w, door_h) =
          zelda3::DoorPositionManager::GetDoorEditorBounds(snap_pos, dir,
                                                           door.type);
    }
  }
 
  ImDrawList* draw_list = ImGui::GetWindowDrawList();
  const DungeonCanvasTransform transform = GetCanvasTransform();
  const float scale = transform.scale();
  const ImVec2 pos = transform.RoomPixelsToScreen(
      ImVec2(static_cast<float>(door_x), static_cast<float>(door_y)));
  const ImVec2 size = transform.RoomSizeToScreen(
      ImVec2(static_cast<float>(door_w), static_cast<float>(door_h)));
 
  // Animated selection
  static float pulse = 0.0f;
  pulse += ImGui::GetIO().DeltaTime * 3.0f;
  float alpha = 0.5f + 0.3f * sinf(pulse);
 
  ImU32 color = IM_COL32(255, 165, 0, 180);  // Orange
  ImU32 fill_color =
      (color & 0x00FFFFFF) | (static_cast<ImU32>(alpha * 100) << 24);
 
  draw_list->AddRectFilled(pos, ImVec2(pos.x + size.x, pos.y + size.y),
                           fill_color);
  draw_list->AddRect(pos, ImVec2(pos.x + size.x, pos.y + size.y), color, 0.0f,
                     2.0f);
 
  ImVec2 label_pos(pos.x, pos.y - 14 * scale);
  draw_list->AddText(label_pos, IM_COL32(255, 255, 255, 220), "Door");
 
  if (auto badge = BuildPairBadgeOverlay(door, pos, size, scale)) {
    const ImVec2 badge_max(badge->screen_pos.x + badge->screen_size.x,
                           badge->screen_pos.y + badge->screen_size.y);
    const bool interactive =
        badge->target_room_id >= 0 && ctx_ && ctx_->on_door_pair_navigation;
    const bool hovered =
        interactive && ImGui::IsMouseHoveringRect(badge->screen_pos, badge_max);
 
    draw_list->AddText(badge->screen_pos, badge->color, badge->label.c_str());
    if (hovered) {
      const auto& theme = AgentUI::GetTheme();
      const ImU32 hover_color = ImGui::GetColorU32(theme.accent_color);
      draw_list->AddLineH(badge->screen_pos.x, badge_max.x, badge_max.y + 1.0f,
                          hover_color);
      ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
      ImGui::SetTooltip(tr("Open room 0x%03X"), badge->target_room_id);
    }
  }
 
  // Draw snap indicators when dragging
  if (is_dragging_) {
    DrawSnapIndicators();
  }
}
 
std::optional<DoorInteractionHandler::PairBadgeOverlay>
DoorInteractionHandler::BuildPairBadgeOverlay(const zelda3::Room::Door& door,
                                              ImVec2 door_pos, ImVec2 door_size,
                                              float scale) const {
  if (is_dragging_ || !ctx_ || !ctx_->rooms ||
      !zelda3::IsRoomConnectionDoorType(door.type)) {
    return std::nullopt;
  }
 
  PairBadgeOverlay badge;
  const bool ordinary = door.type == zelda3::DoorType::NormalDoor ||
                        door.type == zelda3::DoorType::NormalDoorLower;
  if (ordinary) {
    const auto target =
        DungeonConnectionTargetRoom(ctx_->current_room_id, door);
    if (!target.ok()) {
      return std::nullopt;
    }
    const int neighbor = *target;
    badge.target_room_id = neighbor;
    const auto opposite = OppositeDir(door.direction);
    const uint8_t return_position =
        door.position < 6 ? door.position + 6 : door.position - 6;
    std::tie(badge.target_tile_x, badge.target_tile_y) =
        zelda3::DoorPositionManager::PositionToTileCoords(return_position,
                                                          opposite);
    // Drawing and hit-testing must not decode unopened rooms. The inspector
    // loads target data explicitly when it builds an editable preview.
    const auto* source_room = ctx_->rooms->GetIfLoaded(ctx_->current_room_id);
    const auto* target_room = ctx_->rooms->GetIfLoaded(neighbor);
    if (!source_room || !target_room || !source_room->AreObjectsLoaded() ||
        !target_room->AreObjectsLoaded() || !selected_door_index_) {
      badge.label = absl::StrFormat("inspect 0x%03X", neighbor);
      badge.color = IM_COL32(170, 170, 170, 220);
    } else {
      const auto layer = door.type == zelda3::DoorType::NormalDoorLower
                             ? DungeonConnectionLayer::kLower
                             : DungeonConnectionLayer::kUpper;
      const auto plan = PlanDungeonDoorConnection(
          *source_room, *target_room,
          {ctx_->current_room_id, *selected_door_index_, layer});
      if (!plan.ok()) {
        badge.label = absl::StrFormat("blocked 0x%03X", neighbor);
        badge.color = IM_COL32(255, 200, 90, 235);
      } else if (plan->creates_return) {
        badge.label = absl::StrFormat("no pair 0x%03X", neighbor);
        badge.color = IM_COL32(255, 130, 90, 235);
      } else {
        badge.target_door_index = plan->target_door_index;
        if (plan->changed()) {
          badge.label = absl::StrFormat("layer mismatch 0x%03X", neighbor);
          badge.color = IM_COL32(255, 200, 90, 235);
        } else {
          badge.label = absl::StrFormat("pair 0x%03X", neighbor);
          badge.color = IM_COL32(120, 220, 150, 235);
        }
      }
    }
  } else if (const int neighbor =
                 NeighborRoomId(ctx_->current_room_id, door.direction);
             neighbor < 0) {
    badge.label = "edge";
    badge.color = IM_COL32(170, 170, 170, 220);
  } else {
    badge.target_room_id = neighbor;
    const auto opposite = OppositeDir(door.direction);
    const auto& neighbor_doors = (*ctx_->rooms)[neighbor].GetDoors();
    bool any_on_opposite = false;
    for (size_t i = 0; i < neighbor_doors.size(); ++i) {
      const auto& nd = neighbor_doors[i];
      if (nd.direction != opposite ||
          !zelda3::IsRoomConnectionDoorType(nd.type)) {
        continue;
      }
 
      any_on_opposite = true;
      if (!badge.target_door_index.has_value()) {
        badge.target_door_index = i;
      }
      if (nd.position == door.position) {
        badge.target_door_index = i;
        break;
      }
    }
 
    if (badge.target_door_index.has_value()) {
      const auto& target_door = neighbor_doors[*badge.target_door_index];
      const auto [target_tile_x, target_tile_y] = target_door.GetTileCoords();
      badge.target_tile_x = target_tile_x;
      badge.target_tile_y = target_tile_y;
    } else {
      const auto [target_tile_x, target_tile_y] =
          zelda3::DoorPositionManager::PositionToTileCoords(door.position,
                                                            opposite);
      badge.target_tile_x = target_tile_x;
      badge.target_tile_y = target_tile_y;
    }
 
    if (badge.target_door_index.has_value() &&
        neighbor_doors[*badge.target_door_index].position == door.position) {
      badge.label = absl::StrFormat("nearby 0x%03X", neighbor);
      badge.color = IM_COL32(255, 200, 90, 235);  // Unverified special door
    } else if (any_on_opposite) {
      badge.label = absl::StrFormat("~0x%03X", neighbor);
      badge.color = IM_COL32(255, 200, 90, 235);  // amber
    } else {
      badge.label = absl::StrFormat("no pair 0x%03X", neighbor);
      badge.color = IM_COL32(255, 130, 90, 235);  // red-orange
    }
  }
 
  switch (door.direction) {
    case zelda3::DoorDirection::North:
      badge.screen_pos = ImVec2(door_pos.x + 40.0f, door_pos.y - 14 * scale);
      break;
    case zelda3::DoorDirection::South:
      badge.screen_pos = ImVec2(door_pos.x, door_pos.y + door_size.y + 2.0f);
      break;
    case zelda3::DoorDirection::West:
      badge.screen_pos =
          ImVec2(door_pos.x - 88.0f, door_pos.y + door_size.y * 0.5f - 7.0f);
      break;
    case zelda3::DoorDirection::East:
      badge.screen_pos = ImVec2(door_pos.x + door_size.x + 6.0f,
                                door_pos.y + door_size.y * 0.5f - 7.0f);
      break;
  }
  badge.screen_size = EstimateBadgeTextSize(badge.label);
  return badge;
}
 
void DoorInteractionHandler::NavigateToPairBadge(
    const PairBadgeOverlay& badge) const {
  if (!ctx_ || !ctx_->on_door_pair_navigation || badge.target_room_id < 0) {
    return;
  }
  ctx_->on_door_pair_navigation(badge.target_room_id, badge.target_door_index,
                                badge.target_tile_x, badge.target_tile_y);
}
 
std::optional<size_t> DoorInteractionHandler::GetEntityAtPosition(
    int canvas_x, int canvas_y) const {
  if (!HasValidContext() || !IsWithinBounds(canvas_x, canvas_y))
    return std::nullopt;
 
  auto* room = ctx_->GetCurrentRoomConst();
  if (!room)
    return std::nullopt;
 
  const auto& doors = room->GetDoors();
  for (size_t i = 0; i < doors.size(); ++i) {
    const auto& door = doors[i];
 
    auto [door_x, door_y, door_w, door_h] = door.GetEditorBounds();
 
    if (canvas_x >= door_x && canvas_x < door_x + door_w &&
        canvas_y >= door_y && canvas_y < door_y + door_h) {
      return i;
    }
  }
 
  return std::nullopt;
}
 
void DoorInteractionHandler::SelectDoor(size_t index) {
  selected_door_index_ = index;
  ctx_->NotifyEntityChanged();
}
 
void DoorInteractionHandler::ClearSelection() {
  selected_door_index_ = std::nullopt;
  is_dragging_ = false;
}
 
bool DoorInteractionHandler::PreflightDoors(
    const std::vector<zelda3::Room::Door>& candidate) {
  mutation_status_ = absl::OkStatus();
  if (!door_mutation_preflight_) {
    return true;
  }
  const auto* source_context = ctx_;
  const int room_id = ctx_->current_room_id;
  const auto* source_room = GetCurrentRoom();
  mutation_status_ = door_mutation_preflight_(room_id, candidate);
  if (mutation_status_.ok() &&
      (ctx_ != source_context || !HasValidContext() ||
       ctx_->current_room_id != room_id || GetCurrentRoom() != source_room)) {
    mutation_status_ = absl::FailedPreconditionError(
        "Door room changed during edit preflight; repeat the edit");
  }
  if (!mutation_status_.ok() && mutation_error_callback_) {
    mutation_error_callback_(mutation_status_);
  }
  return mutation_status_.ok();
}
 
void DoorInteractionHandler::DeleteSelected() {
  mutation_status_ = absl::OkStatus();
  if (!selected_door_index_.has_value() || !HasValidContext())
    return;
 
  auto* room = GetCurrentRoom();
  if (!room)
    return;
 
  auto candidate = room->GetDoors();
  if (*selected_door_index_ >= candidate.size())
    return;
 
  candidate.erase(candidate.begin() +
                  static_cast<ptrdiff_t>(*selected_door_index_));
  if (!PreflightDoors(candidate)) {
    return;
  }
  room = GetCurrentRoom();
  ctx_->NotifyMutation(MutationDomain::kDoors);
  room->GetDoors() = std::move(candidate);
  room->MarkObjectStreamDirty();
  ClearSelection();
  ctx_->NotifyInvalidateCache(MutationDomain::kDoors);
  ctx_->NotifyEntityChanged();
}
 
void DoorInteractionHandler::DeleteAll() {
  mutation_status_ = absl::OkStatus();
  if (!HasValidContext()) {
    return;
  }
 
  auto* room = GetCurrentRoom();
  if (!room || room->GetDoors().empty()) {
    return;
  }
 
  if (!PreflightDoors({})) {
    return;
  }
  room = GetCurrentRoom();
  ctx_->NotifyMutation(MutationDomain::kDoors);
  room->GetDoors().clear();
  room->MarkObjectStreamDirty();
  ClearSelection();
  ctx_->NotifyInvalidateCache(MutationDomain::kDoors);
  ctx_->NotifyEntityChanged();
}
 
bool DoorInteractionHandler::NudgeSelected(int delta_x, int delta_y) {
  mutation_status_ = absl::OkStatus();
  if (!selected_door_index_.has_value() || !HasValidContext()) {
    return false;
  }
 
  auto* room = GetCurrentRoom();
  if (!room) {
    return false;
  }
 
  auto candidate = room->GetDoors();
  if (*selected_door_index_ >= candidate.size()) {
    return false;
  }
 
  auto& door = candidate[*selected_door_index_];
  int position_delta = 0;
  switch (door.direction) {
    case zelda3::DoorDirection::North:
    case zelda3::DoorDirection::South:
      position_delta = delta_x;
      break;
    case zelda3::DoorDirection::West:
    case zelda3::DoorDirection::East:
      position_delta = delta_y;
      break;
  }
 
  if (position_delta == 0) {
    return false;
  }
 
  const int next_position =
      std::clamp(static_cast<int>(door.position) + position_delta, 0,
                 zelda3::DoorPositionManager::kMaxDoorPositions - 1);
  if (next_position == door.position ||
      !zelda3::DoorPositionManager::IsValidPosition(
          static_cast<uint8_t>(next_position), door.direction)) {
    return false;
  }
 
  door.position = static_cast<uint8_t>(next_position);
  auto [b1, b2] = door.EncodeBytes();
  door.byte1 = b1;
  door.byte2 = b2;
  if (!PreflightDoors(candidate)) {
    return false;
  }
  room = GetCurrentRoom();
  ctx_->NotifyMutation(MutationDomain::kDoors);
  room->GetDoors() = std::move(candidate);
  room->MarkObjectStreamDirty();
  ctx_->NotifyInvalidateCache(MutationDomain::kDoors);
  ctx_->NotifyEntityChanged();
  return true;
}
 
bool DoorInteractionHandler::MutateDoorType(size_t index,
                                            zelda3::DoorType new_type) {
  mutation_status_ = absl::OkStatus();
  auto* room = GetCurrentRoom();
  if (!room || index >= room->GetDoors().size()) {
    return false;
  }
  const auto& door = room->GetDoors()[index];
  return UpdateDoor(index, new_type, door.direction, door.position);
}
 
bool DoorInteractionHandler::UpdateDoor(size_t index, zelda3::DoorType type,
                                        zelda3::DoorDirection direction,
                                        uint8_t position) {
  mutation_status_ = absl::OkStatus();
  if (!HasValidContext()) {
    return false;
  }
  const auto raw_type = static_cast<uint8_t>(type);
  if ((raw_type & 1) != 0 || raw_type > 0x66 ||
      static_cast<unsigned>(direction) > 3 ||
      !zelda3::DoorPositionManager::IsValidPosition(position, direction)) {
    return false;
  }
  auto* room = GetCurrentRoom();
  if (!room || index >= room->GetDoors().size()) {
    return false;
  }
  auto candidate = room->GetDoors();
  auto& door = candidate[index];
  if (door.type == type && door.direction == direction &&
      door.position == position) {
    return false;
  }
  door.type = type;
  door.direction = direction;
  door.position = position;
  const auto [b1, b2] = door.EncodeBytes();
  door.byte1 = b1;
  door.byte2 = b2;
  if (!PreflightDoors(candidate)) {
    return false;
  }
  room = GetCurrentRoom();
  ctx_->NotifyMutation(MutationDomain::kDoors);
  room->GetDoors() = std::move(candidate);
  room->MarkObjectStreamDirty();
  ctx_->NotifyInvalidateCache(MutationDomain::kDoors);
  ctx_->NotifyEntityChanged();
  return true;
}
 
void DoorInteractionHandler::PlaceDoorAtSnappedPosition(int canvas_x,
                                                        int canvas_y) {
  mutation_status_ = absl::OkStatus();
  if (!HasValidContext()) {
    placement_block_reason_ = PlacementBlockReason::kInvalidRoom;
    return;
  }
 
  auto* room = GetCurrentRoom();
  if (!room) {
    placement_block_reason_ = PlacementBlockReason::kInvalidRoom;
    return;
  }
 
  // Enforce door limit at placement time (matches DungeonValidator::zelda3::kMaxDoors)
 
  if (room->GetDoors().size() >= zelda3::kMaxDoors) {
    placement_block_reason_ = PlacementBlockReason::kDoorLimit;
    return;
  }
 
  // Detect wall from position
  zelda3::DoorDirection direction;
  if (!zelda3::DoorPositionManager::DetectWallFromPosition(canvas_x, canvas_y,
                                                           direction)) {
    placement_block_reason_ = PlacementBlockReason::kInvalidPosition;
    return;
  }
 
  // Snap to nearest valid position
  uint8_t position = zelda3::DoorPositionManager::SnapToNearestPosition(
      canvas_x, canvas_y, direction);
 
  // Validate position
  if (!zelda3::DoorPositionManager::IsValidPosition(position, direction)) {
    placement_block_reason_ = PlacementBlockReason::kInvalidPosition;
    return;
  }
 
  placement_block_reason_ = PlacementBlockReason::kNone;
 
  // Create the door
  zelda3::Room::Door new_door;
  new_door.position = position;
  new_door.type = preview_door_type_;
  new_door.direction = direction;
 
  // Encode bytes for ROM storage
  auto [byte1, byte2] = new_door.EncodeBytes();
  new_door.byte1 = byte1;
  new_door.byte2 = byte2;
 
  auto candidate = room->GetDoors();
  candidate.push_back(new_door);
  if (!PreflightDoors(candidate)) {
    placement_block_reason_ = PlacementBlockReason::kStorageValidation;
    return;
  }
  room = GetCurrentRoom();
  ctx_->NotifyMutation(MutationDomain::kDoors);
 
  // Add door to room
  room->AddDoor(new_door);
  TriggerSuccessToast();
 
  ctx_->NotifyInvalidateCache(MutationDomain::kDoors);
}
 
bool DoorInteractionHandler::UpdateSnappedPosition(int canvas_x, int canvas_y) {
  zelda3::DoorDirection direction;
  if (!zelda3::DoorPositionManager::DetectWallFromPosition(canvas_x, canvas_y,
                                                           direction)) {
    return false;
  }
 
  detected_door_direction_ = direction;
  snapped_door_position_ = zelda3::DoorPositionManager::SnapToNearestPosition(
      canvas_x, canvas_y, direction);
  return true;
}
 
std::pair<int, int> DoorInteractionHandler::GetCurrentDragAnchorPosition()
    const {
  return {
      static_cast<int>(drag_current_pos_.x - drag_grab_offset_from_anchor_.x),
      static_cast<int>(drag_current_pos_.y - drag_grab_offset_from_anchor_.y),
  };
}
 
void DoorInteractionHandler::DrawSnapIndicators() {
  if (!is_dragging_ || !HasValidContext())
    return;
 
  const auto [drag_x, drag_y] = GetCurrentDragAnchorPosition();
 
  zelda3::DoorDirection direction;
  bool is_inner = false;
  if (!zelda3::DoorPositionManager::DetectWallSection(drag_x, drag_y, direction,
                                                      is_inner)) {
    return;
  }
 
  uint8_t start_pos =
      zelda3::DoorPositionManager::GetSectionStartPosition(direction, is_inner);
  uint8_t nearest_snap = zelda3::DoorPositionManager::SnapToNearestPosition(
      drag_x, drag_y, direction);
 
  ImDrawList* draw_list = ImGui::GetWindowDrawList();
  const DungeonCanvasTransform transform = GetCanvasTransform();
  const auto& theme = AgentUI::GetTheme();
  zelda3::DoorType indicator_type = preview_door_type_;
  auto* room = GetCurrentRoom();
  if (room && selected_door_index_.has_value() &&
      *selected_door_index_ < room->GetDoors().size()) {
    indicator_type = room->GetDoors()[*selected_door_index_].type;
  }
  // Draw indicators for 6 positions in this section
  for (uint8_t i = 0; i < 6; ++i) {
    uint8_t pos = start_pos + i;
    const auto [pixel_x, pixel_y, width, height] =
        zelda3::DoorPositionManager::GetDoorEditorBounds(pos, direction,
                                                         indicator_type);
 
    const ImVec2 snap_start = transform.RoomPixelsToScreen(
        ImVec2(static_cast<float>(pixel_x), static_cast<float>(pixel_y)));
    const ImVec2 snap_size = transform.RoomSizeToScreen(
        ImVec2(static_cast<float>(width), static_cast<float>(height)));
    const ImVec2 snap_end(snap_start.x + snap_size.x,
                          snap_start.y + snap_size.y);
 
    if (pos == nearest_snap) {
      ImVec4 highlight(theme.dungeon_selection_primary.x,
                       theme.dungeon_selection_primary.y,
                       theme.dungeon_selection_primary.z, 0.75f);
      draw_list->AddRect(snap_start, snap_end, ImGui::GetColorU32(highlight),
                         0.0f, 2.5f);
    } else {
      ImVec4 ghost(1.0f, 1.0f, 1.0f, 0.25f);
      draw_list->AddRect(snap_start, snap_end, ImGui::GetColorU32(ghost), 0.0f,
                         1.0f);
    }
  }
}
 
}  // namespace yaze::editor