dungeon_object_interaction.cc

Go to the documentation of this file.

// Related header
#include "dungeon_object_interaction.h"
#include "absl/strings/str_format.h"
#include "app/editor/dungeon/dungeon_room_store.h"
 
// C++ standard library headers
#include <algorithm>
#include <cmath>
 
// Third-party library headers
#include "imgui/imgui.h"
 
// Project headers
#include "app/editor/dungeon/dungeon_coordinates.h"
#include "app/editor/dungeon/interaction/paint_util.h"
#include "app/gfx/resource/arena.h"
#include "app/gui/core/agent_theme.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/theme_manager.h"
#include "core/features.h"
#include "zelda3/dungeon/dimension_service.h"
#include "zelda3/dungeon/object_layer_semantics.h"
 
namespace yaze::editor {
 
namespace {
 
float ObjectResizeWheelDelta(const ImGuiIO& io) {
  // macOS converts Shift+vertical wheel into horizontal input before SDL
  // delivers it. Other platforms retain the vertical delta. Prefer that delta
  // when both axes are present so one wheel event only resizes once.
  return io.MouseWheel != 0.0f || !io.KeyShift ? io.MouseWheel : io.MouseWheelH;
}
 
}  // namespace
 
void DungeonObjectInteraction::HandleCanvasMouseInput() {
  ImGuiIO& io = ImGui::GetIO();
  const bool hovered = canvas_->IsMouseHovering();
  const bool mouse_left_down = ImGui::IsMouseDown(ImGuiMouseButton_Left);
  const bool mouse_left_released =
      ImGui::IsMouseReleased(ImGuiMouseButton_Left);
 
  // Keep processing drag/release if an interaction started on the canvas but
  // the cursor left the bounds before the mouse button was released.
  const bool has_active_marquee = selection_.IsRectangleSelectionActive();
  const bool should_process_without_hover =
      has_active_marquee ||
      mode_manager_.GetMode() == InteractionMode::DraggingObjects ||
      (entity_coordinator_.HasEntitySelection() &&
       (mouse_left_down || mouse_left_released)) ||
      mouse_left_released;
 
  if (!hovered && !should_process_without_hover) {
    return;
  }
 
  const ImVec2 canvas_mouse_pos =
      GetCanvasTransform().ScreenToRoomPixels(io.MousePos);
  const int canvas_mouse_x = static_cast<int>(std::floor(canvas_mouse_pos.x));
  const int canvas_mouse_y = static_cast<int>(std::floor(canvas_mouse_pos.y));
  const bool pointer_within_room =
      dungeon_coords::IsWithinBounds(canvas_mouse_x, canvas_mouse_y);
 
  // Handle Escape key to cancel any active placement mode
  if (ImGui::IsKeyPressed(ImGuiKey_Escape) &&
      entity_coordinator_.IsPlacementActive()) {
    CancelPlacement();
    return;
  }
 
  if (hovered) {
    HandleLayerKeyboardShortcuts();
    if (HandleKeyboardNudge()) {
      return;
    }
  }
 
  // Painting modes are exclusive; don't also select/drag/mutate entities.
  if (hovered && mouse_left_down) {
    const auto mode = mode_manager_.GetMode();
    if (mode == InteractionMode::PaintCollision) {
      if (pointer_within_room) {
        UpdateCollisionPainting(canvas_mouse_pos);
      }
      return;
    }
    if (mode == InteractionMode::PaintWaterFill) {
      if (pointer_within_room) {
        UpdateWaterFillPainting(canvas_mouse_pos);
      }
      return;
    }
  }
 
  if (hovered && ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
    HandleLeftClick(canvas_mouse_pos);
  }
 
  // Dispatch drag to coordinator (handlers gate internally via drag state).
  if (ImGui::IsMouseDragging(ImGuiMouseButton_Left)) {
    entity_coordinator_.HandleDrag(canvas_mouse_pos, io.MouseDelta);
  }
 
  // Handle mouse release - complete drag operation
  if (mouse_left_released) {
    HandleMouseRelease();
  }
}
 
void DungeonObjectInteraction::HandleLeftClick(const ImVec2& canvas_mouse_pos) {
  int canvas_x = static_cast<int>(std::floor(canvas_mouse_pos.x));
  int canvas_y = static_cast<int>(std::floor(canvas_mouse_pos.y));
 
  // Try to handle click via entity coordinator (handles placement, entity selection, and object selection)
  const bool was_placing = entity_coordinator_.IsPlacementActive();
  if (entity_coordinator_.HandleClick(canvas_x, canvas_y)) {
    // If a selected room element was clicked, prime drag state. Plain clicks on
    // selected mixed members preserve the whole selection; movement begins only
    // if the mouse actually drags.
    if (!was_placing && !entity_coordinator_.IsPlacementActive() &&
        (selection_.HasSelection() || HasEntitySelection())) {
      HandleObjectSelectionStart(canvas_mouse_pos);
    }
    return;
  }
 
  // The canvas viewport can contain blank space after panning. Overlay clicks
  // are dispatched above, but blank space outside the translated room must not
  // clear selection or start a marquee.
  if (!dungeon_coords::IsWithinBounds(canvas_x, canvas_y)) {
    return;
  }
 
  // Not an entity click or placement; handle empty space
  HandleEmptySpaceClick(canvas_mouse_pos);
}
 
void DungeonObjectInteraction::UpdateCollisionPainting(
    const ImVec2& canvas_mouse_pos) {
  auto [room_x, room_y] =
      CanvasToRoomCoordinates(static_cast<int>(canvas_mouse_pos.x),
                              static_cast<int>(canvas_mouse_pos.y));
  if (rooms_ && current_room_id_ >= 0 && current_room_id_ < 296) {
    auto& room = (*rooms_)[current_room_id_];
    auto& state = mode_manager_.GetModeState();
    const bool erase =
        state.paint_collision_erase ||
        (ImGui::GetCurrentContext() != nullptr && ImGui::GetIO().KeyAlt);
 
    // Only set for valid interior tiles (0-63)
    if (room_x >= 0 && room_x < 64 && room_y >= 0 && room_y < 64) {
      // Start a paint stroke (single undo snapshot per stroke).
      if (!state.is_painting) {
        state.is_painting = true;
        state.paint_mutation_started = false;
        state.paint_last_tile_x = room_x;
        state.paint_last_tile_y = room_y;
      }
 
      const int x0 =
          (state.paint_last_tile_x >= 0) ? state.paint_last_tile_x : room_x;
      const int y0 =
          (state.paint_last_tile_y >= 0) ? state.paint_last_tile_y : room_y;
 
      bool changed = false;
      auto ensure_mutation = [&]() {
        if (!state.paint_mutation_started) {
          interaction_context_.NotifyMutation(MutationDomain::kCustomCollision);
          state.paint_mutation_started = true;
        }
      };
 
      paint_util::ForEachPointOnLine(
          x0, y0, room_x, room_y, [&](int lx, int ly) {
            paint_util::ForEachPointInSquareBrush(
                lx, ly, state.paint_brush_radius,
                /*min_x=*/0, /*min_y=*/0, /*max_x=*/63, /*max_y=*/63,
                [&](int bx, int by) {
                  if (erase) {
                    if (!room.HasCollisionOverride(bx, by)) {
                      return;
                    }
                    ensure_mutation();
                    room.ClearCollisionTile(bx, by);
                    changed = true;
                    return;
                  }
                  if (room.HasCollisionOverride(bx, by) &&
                      room.GetCollisionTile(bx, by) ==
                          state.paint_collision_value) {
                    return;
                  }
                  ensure_mutation();
                  room.SetCollisionTile(bx, by, state.paint_collision_value);
                  changed = true;
                });
          });
 
      if (changed) {
        interaction_context_.NotifyInvalidateCache(
            MutationDomain::kCustomCollision);
      }
 
      state.paint_last_tile_x = room_x;
      state.paint_last_tile_y = room_y;
    }
  }
}
 
void DungeonObjectInteraction::UpdateWaterFillPainting(
    const ImVec2& canvas_mouse_pos) {
  if (!core::FeatureFlags::get().dungeon.kSaveWaterFillZones) {
    mode_manager_.SetMode(InteractionMode::Select);
    return;
  }
 
  const ImGuiIO& io = ImGui::GetIO();
  const bool erase = io.KeyAlt;
 
  auto [room_x, room_y] =
      CanvasToRoomCoordinates(static_cast<int>(canvas_mouse_pos.x),
                              static_cast<int>(canvas_mouse_pos.y));
  if (rooms_ && current_room_id_ >= 0 && current_room_id_ < 296) {
    auto& room = (*rooms_)[current_room_id_];
    auto& state = mode_manager_.GetModeState();
 
    // Only set for valid interior tiles (0-63)
    if (room_x >= 0 && room_x < 64 && room_y >= 0 && room_y < 64) {
      const bool new_val = !erase;
      // Start a paint stroke (single undo snapshot per stroke).
      if (!state.is_painting) {
        state.is_painting = true;
        state.paint_mutation_started = false;
        state.paint_last_tile_x = room_x;
        state.paint_last_tile_y = room_y;
      }
 
      const int x0 =
          (state.paint_last_tile_x >= 0) ? state.paint_last_tile_x : room_x;
      const int y0 =
          (state.paint_last_tile_y >= 0) ? state.paint_last_tile_y : room_y;
 
      bool changed = false;
      auto ensure_mutation = [&]() {
        if (!state.paint_mutation_started) {
          interaction_context_.NotifyMutation(MutationDomain::kWaterFill);
          state.paint_mutation_started = true;
        }
      };
 
      paint_util::ForEachPointOnLine(
          x0, y0, room_x, room_y, [&](int lx, int ly) {
            paint_util::ForEachPointInSquareBrush(
                lx, ly, state.paint_brush_radius,
                /*min_x=*/0, /*min_y=*/0, /*max_x=*/63, /*max_y=*/63,
                [&](int bx, int by) {
                  if (room.GetWaterFillTile(bx, by) == new_val) {
                    return;
                  }
                  ensure_mutation();
                  room.SetWaterFillTile(bx, by, new_val);
                  changed = true;
                });
          });
 
      if (changed) {
        interaction_context_.NotifyInvalidateCache(MutationDomain::kWaterFill);
      }
 
      state.paint_last_tile_x = room_x;
      state.paint_last_tile_y = room_y;
    }
  }
}
 
void DungeonObjectInteraction::HandleObjectSelectionStart(
    const ImVec2& canvas_mouse_pos) {
  const bool has_object_selection = selection_.HasSelection();
  const bool has_entity_selection = HasEntitySelection();
  if (!has_object_selection && !has_entity_selection) {
    return;
  }
 
  mode_manager_.SetMode(InteractionMode::DraggingObjects);
  if (has_object_selection) {
    entity_coordinator_.tile_handler().InitDrag(canvas_mouse_pos);
  }
  if (has_entity_selection) {
    entity_coordinator_.BeginSelectionDrag(canvas_mouse_pos);
  }
}
 
void DungeonObjectInteraction::HandleEmptySpaceClick(
    const ImVec2& canvas_mouse_pos) {
  const ImGuiIO& io = ImGui::GetIO();
  const bool additive = io.KeyShift || io.KeyCtrl || io.KeySuper;
  const bool had_selection =
      selection_.HasSelection() || entity_coordinator_.HasEntitySelection();
 
  // ZScream treats an empty click against an existing selection as a clear
  // action. Rectangle selection starts from a clean canvas gesture.
  if (!additive) {
    ClearEntitySelection();
    selection_.ClearSelection();
  }
 
  if (!had_selection) {
    entity_coordinator_.tile_handler().BeginMarqueeSelection(canvas_mouse_pos);
  }
}
 
void DungeonObjectInteraction::FinishPaintStroke() {
  // End the stroke without deselecting its tool. This also runs before a room
  // change, while invalidation still addresses the room that was painted.
  const auto mode = mode_manager_.GetMode();
  if (mode != InteractionMode::PaintCollision &&
      mode != InteractionMode::PaintWaterFill) {
    return;
  }
  auto& state = mode_manager_.GetModeState();
  const bool had_mutation = state.paint_mutation_started;
  state.is_painting = false;
  state.paint_mutation_started = false;
  state.paint_last_tile_x = -1;
  state.paint_last_tile_y = -1;
  if (had_mutation) {
    interaction_context_.NotifyInvalidateCache(
        (mode == InteractionMode::PaintCollision)
            ? MutationDomain::kCustomCollision
            : MutationDomain::kWaterFill);
  }
}
 
void DungeonObjectInteraction::HandleMouseRelease() {
  FinishPaintStroke();
 
  if (mode_manager_.GetMode() == InteractionMode::DraggingObjects) {
    mode_manager_.SetMode(InteractionMode::Select);
  }
  entity_coordinator_.HandleRelease();
  // Marquee selection finalization is handled by TileObjectHandler via
  // CheckForObjectSelection().
}
 
bool DungeonObjectInteraction::HandleKeyboardNudge() {
  if (!rooms_ || current_room_id_ < 0 ||
      current_room_id_ >= static_cast<int>(rooms_->size())) {
    return false;
  }
 
  const ImGuiIO& io = ImGui::GetIO();
  if (ImGui::IsAnyItemActive() || io.KeyCtrl || io.KeySuper || io.KeyAlt ||
      ImGui::IsMouseDown(ImGuiMouseButton_Left) ||
      entity_coordinator_.IsPlacementActive()) {
    return false;
  }
 
  const auto mode = mode_manager_.GetMode();
  if (mode == InteractionMode::DraggingObjects ||
      mode == InteractionMode::PaintCollision ||
      mode == InteractionMode::PaintWaterFill) {
    return false;
  }
 
  int delta_x = 0;
  int delta_y = 0;
  if (ImGui::IsKeyPressed(ImGuiKey_LeftArrow, true)) {
    delta_x = -1;
  } else if (ImGui::IsKeyPressed(ImGuiKey_RightArrow, true)) {
    delta_x = 1;
  }
  if (ImGui::IsKeyPressed(ImGuiKey_UpArrow, true)) {
    delta_y = -1;
  } else if (ImGui::IsKeyPressed(ImGuiKey_DownArrow, true)) {
    delta_y = 1;
  }
 
  if (delta_x == 0 && delta_y == 0) {
    return false;
  }
 
  return NudgeSelected(delta_x, delta_y);
}
 
bool DungeonObjectInteraction::NudgeSelected(int delta_x, int delta_y) {
  return entity_coordinator_.NudgeSelected(delta_x, delta_y);
}
 
void DungeonObjectInteraction::CheckForObjectSelection() {
  // Draw/update active marquee selection for tile objects (delegated).
  const ImGuiIO& io = ImGui::GetIO();
  const ImVec2 mouse_pos = GetCanvasTransform().ScreenToRoomPixels(io.MousePos);
  const bool mouse_left_released =
      ImGui::IsMouseReleased(ImGuiMouseButton_Left);
 
  if (mouse_left_released && selection_.IsRectangleSelectionActive()) {
    selection_.UpdateRectangleSelection(static_cast<int>(mouse_pos.x),
                                        static_cast<int>(mouse_pos.y));
    constexpr int kMinRectPixels = 6;
    if (!io.KeyAlt && selection_.IsRectangleLargeEnough(kMinRectPixels)) {
      entity_coordinator_.SelectEntitiesInRect(
          selection_.GetRectangleSelectionBounds(),
          /*additive=*/false,
          /*toggle=*/false);
    }
  }
 
  entity_coordinator_.tile_handler().HandleMarqueeSelection(
      mouse_pos,
      /*mouse_left_down=*/ImGui::IsMouseDown(ImGuiMouseButton_Left),
      /*mouse_left_released=*/mouse_left_released,
      /*shift_down=*/io.KeyShift,
      /*toggle_down=*/io.KeyCtrl || io.KeySuper,
      /*alt_down=*/io.KeyAlt);
}
 
void DungeonObjectInteraction::DrawSelectionHighlights() {
  if (!rooms_ || current_room_id_ < 0 || current_room_id_ >= 296)
    return;
 
  auto& room = (*rooms_)[current_room_id_];
  const auto& objects = room.GetTileObjects();
 
  // Use ObjectSelection's rendering (handles pulsing border, corner handles)
  selection_.DrawSelectionHighlights(
      canvas_, objects, [](const zelda3::RoomObject& obj) {
        auto result = zelda3::DimensionService::Get().GetDimensions(obj);
        return std::make_tuple(result.offset_x_tiles * 8,
                               result.offset_y_tiles * 8, result.width_pixels(),
                               result.height_pixels());
      });
 
  // Enhanced hover tooltip showing object info (always visible on hover)
  // Skip completely in exclusive entity mode (door/sprite/item selected)
  if (entity_coordinator_.HasEntitySelection()) {
    return;  // Entity mode active - no object tooltips or hover
  }
 
  if (canvas_->IsMouseHovering()) {
    // Also skip tooltip if cursor is over a door/sprite/item entity (not selected yet)
    ImGuiIO& io = ImGui::GetIO();
    const auto [cursor_x, cursor_y] =
        GetCanvasTransform().ScreenToRoomPixelCoordinates(io.MousePos);
    auto entity_at_cursor =
        entity_coordinator_.GetEntityAtPosition(cursor_x, cursor_y);
    if (entity_at_cursor.has_value()) {
      // Entity has priority - skip object tooltip, DrawHoverHighlight will also skip
      DrawHoverHighlight(objects);
      return;
    }
 
    auto hovered_index = entity_coordinator_.tile_handler().GetEntityAtPosition(
        cursor_x, cursor_y);
    if (hovered_index.has_value() && *hovered_index < objects.size()) {
      const auto& object = objects[*hovered_index];
      std::string object_name = zelda3::GetObjectName(object.id_);
      int subtype = zelda3::GetObjectSubtype(object.id_);
      const int layer = object.GetLayerValue();
 
      // Get subtype name
      const char* subtype_names[] = {"Unknown", "Type 1", "Type 2", "Type 3"};
      const char* subtype_name =
          (subtype >= 0 && subtype <= 3) ? subtype_names[subtype] : "Unknown";
 
      // Build informative tooltip
      std::string tooltip;
      tooltip += object_name;
      tooltip += " (" + std::string(subtype_name) + ")";
      tooltip += "\n";
      tooltip += "ID: 0x" + absl::StrFormat("%03X", object.id_);
      if (zelda3::UsesRoomObjectStream(object)) {
        static constexpr const char* kStreamNames[] = {"Primary", "BG2 overlay",
                                                       "BG1 overlay"};
        const char* stream_name =
            (layer >= 0 && layer < 3) ? kStreamNames[layer] : "Unknown";
        tooltip += " | Object stream: " + std::string(stream_name);
      } else {
        const char* layer_name =
            layer == 0 ? "Upper layer (BG1)" : "Lower layer (BG2)";
        tooltip += " | Special layer: " + std::string(layer_name);
      }
      tooltip += " | Pos: (" + std::to_string(object.x_) + ", " +
                 std::to_string(object.y_) + ")";
      const int axis_step = zelda3::RoomObjectSizeAxisStep(object.id_);
      if (axis_step > 0) {
        tooltip += absl::StrFormat(
            "\nSize: %d x %d tiles",
            zelda3::RoomObjectSizeAxisTiles(object.id_, object.size_, true),
            zelda3::RoomObjectSizeAxisTiles(object.id_, object.size_));
      } else if (zelda3::IsRoomObjectResizable(object.id_)) {
        tooltip += absl::StrFormat("\nSize: 0x%02X", object.size_);
      }
 
      if (selection_.IsObjectSelected(*hovered_index)) {
        if (axis_step > 0) {
          tooltip +=
              "\n" ICON_MD_MOUSE " Wheel: grow/shrink | Shift+wheel: width";
        } else if (zelda3::IsRoomObjectResizable(object.id_)) {
          tooltip += "\n" ICON_MD_MOUSE " Scroll wheel to resize";
        }
        tooltip += "\n" ICON_MD_DRAG_INDICATOR " Drag to move";
      } else {
        tooltip += "\n" ICON_MD_TOUCH_APP " Click to select";
      }
 
      ImGui::SetTooltip("%s", tooltip.c_str());
    }
  }
 
  // Draw hover highlight for non-selected objects
  DrawHoverHighlight(objects);
}
 
void DungeonObjectInteraction::DrawHoverHighlight(
    const std::vector<zelda3::RoomObject>& objects) {
  if (!canvas_->IsMouseHovering())
    return;
 
  // Skip all object hover in exclusive entity mode (door/sprite/item selected)
  if (entity_coordinator_.HasEntitySelection())
    return;
 
  // Don't show object hover highlight if cursor is over a door/sprite/item entity
  // Entities take priority over objects for interaction
  ImGuiIO& io = ImGui::GetIO();
  const DungeonCanvasTransform transform = GetCanvasTransform();
  const auto [cursor_canvas_x, cursor_canvas_y] =
      transform.ScreenToRoomPixelCoordinates(io.MousePos);
  auto entity_at_cursor =
      entity_coordinator_.GetEntityAtPosition(cursor_canvas_x, cursor_canvas_y);
  if (entity_at_cursor.has_value()) {
    return;  // Entity has priority - skip object hover highlight
  }
 
  auto hovered_index = entity_coordinator_.tile_handler().GetEntityAtPosition(
      cursor_canvas_x, cursor_canvas_y);
  if (!hovered_index.has_value() || *hovered_index >= objects.size()) {
    return;
  }
  const auto& object = objects[*hovered_index];
 
  // Don't draw hover highlight if object is already selected
  if (selection_.IsObjectSelected(*hovered_index)) {
    return;
  }
 
  const auto& theme = AgentUI::GetTheme();
  ImDrawList* draw_list = ImGui::GetWindowDrawList();
  // Calculate object position and dimensions
  auto [sel_x_px, sel_y_px, pixel_width, pixel_height] =
      zelda3::DimensionService::Get().GetSelectionBoundsPixels(object);
 
  ImVec2 obj_start = transform.RoomPixelsToScreen(
      ImVec2(static_cast<float>(sel_x_px), static_cast<float>(sel_y_px)));
  const ImVec2 obj_size = transform.RoomSizeToScreen(ImVec2(
      static_cast<float>(pixel_width), static_cast<float>(pixel_height)));
  ImVec2 obj_end(obj_start.x + obj_size.x, obj_start.y + obj_size.y);
 
  // Expand slightly for visibility
  constexpr float margin = 2.0f;
  obj_start.x -= margin;
  obj_start.y -= margin;
  obj_end.x += margin;
  obj_end.y += margin;
 
  // Draw subtle hover highlight with unified theme color
  ImVec4 hover_fill = theme.selection_hover;
  hover_fill.w *= 0.5f;  // Make it more subtle for hover fill
 
  ImVec4 hover_border = theme.selection_hover;
 
  // Draw filled background for better visibility
  draw_list->AddRectFilled(obj_start, obj_end, ImGui::GetColorU32(hover_fill));
 
  // Draw dashed-style border (simulated with thinner line)
  draw_list->AddRect(obj_start, obj_end, ImGui::GetColorU32(hover_border), 0.0f,
                     1.5f);
}
 
void DungeonObjectInteraction::PlaceObjectAtPosition(int room_x, int room_y) {
  auto& tile_handler = entity_coordinator_.tile_handler();
  if (!tile_handler.IsPlacementActive()) {
    return;
  }
  auto object = tile_handler.GetPreviewObject().CopyForNewPlacement();
  object.x_ = std::clamp(room_x, 0, 63);
  object.y_ = std::clamp(room_y, 0, 63);
  if (!tile_handler.PlaceObjectAt(interaction_context_.current_room_id, object,
                                  room_x, room_y)) {
    return;
  }
  if (object_placed_callback_) {
    object_placed_callback_(object);
  }
}
 
void DungeonObjectInteraction::CompleteObjectPlacement(
    const zelda3::RoomObject& /*object*/) {
  entity_coordinator_.ClearEntitySelection();
  if (!entity_coordinator_.tile_handler().IsPlacementActive() &&
      mode_manager_.GetMode() == InteractionMode::PlaceObject) {
    mode_manager_.SetMode(InteractionMode::Select);
  }
}
 
bool DungeonObjectInteraction::BeginPlacementFromSelection() {
  const auto indices = selection_.GetSelectedIndices();
  const auto* room = interaction_context_.GetCurrentRoomConst();
  if (!room || indices.size() != 1 || HasEntitySelection() ||
      indices.front() >= room->GetTileObjects().size()) {
    return false;
  }
  const auto object =
      room->GetTileObjects()[indices.front()].CopyForNewPlacement();
  SetPreviewObject(object, true);
  return true;
}
 
std::pair<int, int> DungeonObjectInteraction::RoomToCanvasCoordinates(
    int room_x, int room_y) const {
  // Dungeon tiles are 8x8 pixels, convert room coordinates (tiles) to pixels
  return {room_x * 8, room_y * 8};
}
 
std::pair<int, int> DungeonObjectInteraction::CanvasToRoomCoordinates(
    int canvas_x, int canvas_y) const {
  // Convert canvas pixels back to room coordinates (tiles)
  return {canvas_x / 8, canvas_y / 8};
}
 
bool DungeonObjectInteraction::IsWithinCanvasBounds(int canvas_x, int canvas_y,
                                                    int margin) const {
  return dungeon_coords::IsWithinBounds(canvas_x, canvas_y, margin);
}
 
void DungeonObjectInteraction::SetCurrentRoom(DungeonRoomStore* rooms,
                                              int room_id) {
  // Selections are indices into the current room's lists. After a room change
  // they would point at unrelated objects in the new room, where Delete,
  // Duplicate and the inspector would act on them. Placement is not tied to a
  // room, so it continues.
  if (rooms != rooms_ || room_id != current_room_id_) {
    FinishPaintStroke();
    const auto mode = mode_manager_.GetMode();
    if (mode == InteractionMode::DraggingObjects ||
        mode == InteractionMode::DraggingEntity ||
        mode == InteractionMode::RectangleSelect) {
      mode_manager_.SetMode(InteractionMode::Select);
    }
    // Tile and group drags already changed the old room. Finish their undo
    // actions before rebinding; single-entity drags are previews and are
    // canceled by clearing their selections below.
    entity_coordinator_.tile_handler().HandleRelease();
    selection_.CancelRectangleSelection();
    entity_coordinator_.ClearAllEntitySelections();
    ClearSelection();
  }
  rooms_ = rooms;
  current_room_id_ = room_id;
  interaction_context_.rooms = rooms;
  interaction_context_.current_room_id = room_id;
  interaction_context_.selection = &selection_;
  entity_coordinator_.SetContext(&interaction_context_);
}
 
void DungeonObjectInteraction::SetPreviewObject(
    const zelda3::RoomObject& object, bool loaded) {
  if (loaded && object.id_ >= 0) {
    // Cancel other placement modes (doors/sprites/items) before entering object
    // placement. We re-enable tile placement below.
    entity_coordinator_.CancelCurrentMode();
 
    // Enter object placement mode
    mode_manager_.SetMode(InteractionMode::PlaceObject);
 
    // Ensure tile placement mode is active so ghost preview can render and
    // clicks place the object.
    auto& tile_handler = entity_coordinator_.tile_handler();
    tile_handler.SetPreviewObject(object);
    if (!tile_handler.IsPlacementActive()) {
      tile_handler.BeginPlacement();
    }
  } else {
    // Exit placement mode if not loaded
    if (mode_manager_.GetMode() == InteractionMode::PlaceObject) {
      CancelPlacement();
    }
  }
}
 
void DungeonObjectInteraction::ClearSelection() {
  selection_.ClearSelection();
  if (mode_manager_.GetMode() == InteractionMode::DraggingObjects) {
    mode_manager_.SetMode(InteractionMode::Select);
  }
}
 
absl::Status DungeonObjectInteraction::HandleDeleteSelected() {
  DungeonSelectionEditRequest request;
  request.kind = DungeonSelectionEditKind::kDelete;
  request.objects = selection_.GetSelectedIndices();
  request.entities = entity_coordinator_.SelectedEntitiesForEdit();
  return entity_coordinator_.CommitSelectionEdit(request);
}
 
void DungeonObjectInteraction::HandleDeleteAllObjects() {
  if (entity_coordinator_.tile_handler().DeleteAllObjects(current_room_id_)) {
    selection_.ClearSelection();
  }
}
 
absl::Status DungeonObjectInteraction::HandleCopySelected() {
  const auto* room = interaction_context_.GetCurrentRoomConst();
  if (!room) {
    return entity_coordinator_.ReportSelectionEditStatus(
        absl::FailedPreconditionError("No room is available to copy"));
  }
  const auto objects = selection_.GetSelectedIndices();
  const auto entities = entity_coordinator_.SelectedEntitiesForEdit();
  if (objects.empty() && entities.empty())
    return absl::OkStatus();
  auto copied = CopyDungeonSelection(*room, objects, entities);
  if (!copied.ok()) {
    return entity_coordinator_.ReportSelectionEditStatus(copied.status());
  }
  // Only replace the clipboard after the complete selection is copyable.
  clipboard() = std::move(*copied);
  return entity_coordinator_.ReportSelectionEditStatus(absl::OkStatus());
}
 
absl::Status DungeonObjectInteraction::HandleDuplicateSelected() {
  DungeonSelectionEditRequest request;
  request.kind = DungeonSelectionEditKind::kDuplicate;
  request.objects = selection_.GetSelectedIndices();
  request.entities = entity_coordinator_.SelectedEntitiesForEdit();
  const bool includes_door = std::any_of(
      request.entities.begin(), request.entities.end(),
      [](const auto entity) { return entity.type == EntityType::Door; });
  // Doors occupy fixed wall slots: keep that group in place, then let the
  // author choose a valid shared destination explicitly.
  request.delta_x_pixels =
      includes_door ? 0 : entity_coordinator_.SelectionMoveStepPixels();
  request.delta_y_pixels = request.delta_x_pixels;
  // Duplicate does not disturb the user's clipboard.
  return entity_coordinator_.CommitSelectionEdit(request);
}
 
absl::Status DungeonObjectInteraction::HandlePasteAt(int pixel_x, int pixel_y) {
  if (!HasClipboardData())
    return absl::OkStatus();
  if (!dungeon_coords::IsWithinBounds(pixel_x, pixel_y)) {
    return entity_coordinator_.ReportSelectionEditStatus(
        absl::OutOfRangeError("Paste anchor is outside the room"));
  }
  DungeonSelectionEditRequest request;
  request.kind = DungeonSelectionEditKind::kPaste;
  request.objects = selection_.GetSelectedIndices();
  request.entities = entity_coordinator_.SelectedEntitiesForEdit();
  auto& copied = clipboard();
  request.clipboard = &copied;
  request.delta_x_pixels = pixel_x - copied.origin_pixel_x;
  request.delta_y_pixels = pixel_y - copied.origin_pixel_y;
  return entity_coordinator_.CommitSelectionEdit(request);
}
 
absl::Status DungeonObjectInteraction::HandlePasteObjectsAt(int pixel_x,
                                                            int pixel_y) {
  if (!HasClipboardData())
    return absl::OkStatus();
  if (!dungeon_coords::IsWithinBounds(pixel_x, pixel_y)) {
    return HandlePasteAt(pixel_x, pixel_y);
  }
  const auto& copied = clipboard();
  const int step = !copied.sprites.empty() || !copied.items.empty()
                       ? dungeon_coords::kSpriteTileSize
                       : dungeon_coords::kTileSize;
  // Snap the translation, rather than the target, so a copied group keeps
  // each member's relative position on its original encoding grid.
  return HandlePasteAt(
      copied.origin_pixel_x + (pixel_x - copied.origin_pixel_x) / step * step,
      copied.origin_pixel_y + (pixel_y - copied.origin_pixel_y) / step * step);
}
 
absl::Status DungeonObjectInteraction::HandlePasteObjects() {
  if (!HasClipboardData())
    return absl::OkStatus();
  if (canvas_ && ImGui::GetCurrentContext()) {
    const auto [mouse_x, mouse_y] =
        GetCanvasTransform().ScreenToRoomPixelCoordinates(
            ImGui::GetIO().MousePos);
    if (dungeon_coords::IsWithinBounds(mouse_x, mouse_y)) {
      return HandlePasteObjectsAt(mouse_x, mouse_y);
    }
  }
  // With no canvas target, doors retain their exact source wall slots.
  // An automatic diagonal offset cannot represent a valid wall destination.
  const auto& copied = clipboard();
  const int step = !copied.sprites.empty() || !copied.items.empty()
                       ? dungeon_coords::kSpriteTileSize
                       : dungeon_coords::kTileSize;
  const int fallback_offset = copied.doors.empty() ? step : 0;
  return HandlePasteAt(copied.origin_pixel_x + fallback_offset,
                       copied.origin_pixel_y + fallback_offset);
}
 
void DungeonObjectInteraction::DrawGhostPreview() {
  entity_coordinator_.DrawGhostPreviews();
}
 
void DungeonObjectInteraction::HandleScrollWheelResize() {
  const ImGuiIO& io = ImGui::GetIO();
  entity_coordinator_.HandleMouseWheel(ObjectResizeWheelDelta(io));
}
 
bool DungeonObjectInteraction::SetObjectId(size_t index, int16_t id) {
  entity_coordinator_.tile_handler().UpdateObjectsId(current_room_id_, {index},
                                                     id);
  return true;
}
 
bool DungeonObjectInteraction::SetObjectSize(size_t index, uint8_t size) {
  entity_coordinator_.tile_handler().UpdateObjectsSize(current_room_id_,
                                                       {index}, size);
  return true;
}
 
bool DungeonObjectInteraction::SetObjectLayer(
    size_t index, zelda3::RoomObject::LayerType layer) {
  return entity_coordinator_.tile_handler().UpdateObjectsLayer(
      current_room_id_, {index}, static_cast<int>(layer));
}
 
std::pair<int, int> DungeonObjectInteraction::CalculateObjectBounds(
    const zelda3::RoomObject& object) {
  return zelda3::DimensionService::Get().GetPixelDimensions(object);
}
 
bool DungeonObjectInteraction::CanAssignSelectedObjectsToLayer(
    int target_layer) const {
  if (!rooms_ || current_room_id_ < 0 ||
      current_room_id_ >= static_cast<int>(rooms_->size()) ||
      target_layer < 0 || target_layer > 2) {
    return false;
  }
 
  const auto selected = selection_.GetSelectedIndices();
  if (selected.empty()) {
    return false;
  }
 
  const auto& objects = (*rooms_)[current_room_id_].GetTileObjects();
  for (const size_t index : selected) {
    if (index >= objects.size() ||
        (target_layer == 2 && !zelda3::UsesRoomObjectStream(objects[index]))) {
      return false;
    }
  }
  return true;
}
 
bool DungeonObjectInteraction::SendSelectedToLayer(int target_layer) {
  if (!CanAssignSelectedObjectsToLayer(target_layer)) {
    return false;
  }
  return entity_coordinator_.tile_handler().UpdateObjectsLayer(
      current_room_id_, selection_.GetSelectedIndices(), target_layer);
}
 
void DungeonObjectInteraction::SendSelectedToFront() {
  entity_coordinator_.tile_handler().SendToFront(
      current_room_id_, selection_.GetSelectedIndices());
}
 
void DungeonObjectInteraction::SendSelectedToBack() {
  entity_coordinator_.tile_handler().SendToBack(
      current_room_id_, selection_.GetSelectedIndices());
}
 
void DungeonObjectInteraction::BringSelectedForward() {
  entity_coordinator_.tile_handler().MoveForward(
      current_room_id_, selection_.GetSelectedIndices());
}
 
void DungeonObjectInteraction::SendSelectedBackward() {
  entity_coordinator_.tile_handler().MoveBackward(
      current_room_id_, selection_.GetSelectedIndices());
}
 
void DungeonObjectInteraction::HandleLayerKeyboardShortcuts() {
  // Only process if we have selected objects
  if (!selection_.HasSelection())
    return;
 
  // Only when not typing in a text field
  if (ImGui::IsAnyItemActive())
    return;
 
  // Modified digits belong to editor/window shortcuts, not object placement.
  // The third room stream is unavailable to torches/pushable blocks.
  const auto& io = ImGui::GetIO();
  if (io.KeyMods == ImGuiMod_None) {
    if (ImGui::IsKeyPressed(ImGuiKey_1)) {
      SendSelectedToLayer(0);  // Primary stream / upper layer (BG1)
    } else if (ImGui::IsKeyPressed(ImGuiKey_2)) {
      SendSelectedToLayer(1);  // BG2 overlay / lower layer (BG2)
    } else if (ImGui::IsKeyPressed(ImGuiKey_3)) {
      SendSelectedToLayer(2);  // BG1 overlay stream
    }
  }
 
  // Object ordering shortcuts
  // Ctrl+Shift+] = Bring to Front, Ctrl+Shift+[ = Send to Back
  // Ctrl+] = Bring Forward, Ctrl+[ = Send Backward
  if (io.KeyCtrl && io.KeyShift) {
    if (ImGui::IsKeyPressed(ImGuiKey_RightBracket)) {
      SendSelectedToFront();
    } else if (ImGui::IsKeyPressed(ImGuiKey_LeftBracket)) {
      SendSelectedToBack();
    }
  } else if (io.KeyCtrl) {
    if (ImGui::IsKeyPressed(ImGuiKey_RightBracket)) {
      BringSelectedForward();
    } else if (ImGui::IsKeyPressed(ImGuiKey_LeftBracket)) {
      SendSelectedBackward();
    }
  }
}
 
// ============================================================================
// Door Placement Methods
// ============================================================================
 
void DungeonObjectInteraction::SetDoorPlacementMode(bool enabled,
                                                    zelda3::DoorType type) {
  if (enabled) {
    // Dispatch follows handler state; the previous placement must end too.
    CancelPlacement();
    mode_manager_.SetMode(InteractionMode::PlaceDoor);
    entity_coordinator_.door_handler().SetDoorType(type);
    entity_coordinator_.door_handler().BeginPlacement();
  } else {
    entity_coordinator_.door_handler().CancelPlacement();
    if (mode_manager_.GetMode() == InteractionMode::PlaceDoor)
      mode_manager_.SetMode(InteractionMode::Select);
  }
}
 
// ============================================================================
// Sprite Placement Methods
// ============================================================================
 
void DungeonObjectInteraction::SetSpritePlacementMode(bool enabled,
                                                      uint8_t sprite_id) {
  if (enabled) {
    // Dispatch follows handler state; the previous placement must end too.
    CancelPlacement();
    mode_manager_.SetMode(InteractionMode::PlaceSprite);
    entity_coordinator_.sprite_handler().SetSpriteId(sprite_id);
    entity_coordinator_.sprite_handler().BeginPlacement();
  } else {
    entity_coordinator_.sprite_handler().CancelPlacement();
    if (mode_manager_.GetMode() == InteractionMode::PlaceSprite)
      mode_manager_.SetMode(InteractionMode::Select);
  }
}
 
// ============================================================================
// Item Placement Methods
// ============================================================================
 
void DungeonObjectInteraction::SetItemPlacementMode(bool enabled,
                                                    uint8_t item_id) {
  if (enabled) {
    // Dispatch follows handler state; the previous placement must end too.
    CancelPlacement();
    mode_manager_.SetMode(InteractionMode::PlaceItem);
    entity_coordinator_.item_handler().SetItemId(item_id);
    entity_coordinator_.item_handler().BeginPlacement();
  } else {
    entity_coordinator_.item_handler().CancelPlacement();
    if (mode_manager_.GetMode() == InteractionMode::PlaceItem)
      mode_manager_.SetMode(InteractionMode::Select);
  }
}
 
// ============================================================================
// Entity Selection Methods (Doors, Sprites, Items)
// ============================================================================
 
void DungeonObjectInteraction::SelectEntity(EntityType type, size_t index) {
  selection_.ClearSelection();
  entity_coordinator_.SelectEntity(type, index);
}
 
void DungeonObjectInteraction::ClearEntitySelection() {
  entity_coordinator_.ClearEntitySelection();
}
 
void DungeonObjectInteraction::CancelPlacement() {
  entity_coordinator_.CancelPlacement();
  if (mode_manager_.IsPlacementActive()) {
    mode_manager_.SetMode(InteractionMode::Select);
  }
}
 
void DungeonObjectInteraction::DrawEntitySelectionHighlights() {
  entity_coordinator_.DrawSelectionHighlights();
  entity_coordinator_.DrawPostPlacementOverlays();
}
 
void DungeonObjectInteraction::DrawDoorSnapIndicators() {
  // Door snap indicators are now managed by DoorInteractionHandler
  // through the entity coordinator. No-op here for backward compatibility.
}
 
}  // namespace yaze::editor