dungeon_object_interaction.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_DUNGEON_DUNGEON_OBJECT_INTERACTION_H
#define YAZE_APP_EDITOR_DUNGEON_DUNGEON_OBJECT_INTERACTION_H
 
#include <functional>
#include <memory>
#include <optional>
#include <utility>
#include <vector>
 
#include "app/editor/dungeon/dungeon_canvas_transform.h"
#include "app/editor/dungeon/dungeon_coordinates.h"
#include "app/editor/dungeon/dungeon_room_store.h"
#include "app/editor/dungeon/dungeon_selection_edit.h"
#include "app/editor/dungeon/dungeon_snapping.h"
#include "app/editor/dungeon/interaction/interaction_context.h"
#include "app/editor/dungeon/interaction/interaction_coordinator.h"
#include "app/editor/dungeon/interaction/interaction_mode.h"
#include "app/editor/dungeon/object_selection.h"
#include "app/gfx/render/background_buffer.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gui/canvas/canvas.h"
#include "imgui/imgui.h"
#include "zelda3/dungeon/door_position.h"
#include "zelda3/dungeon/door_types.h"
#include "zelda3/dungeon/dungeon_editor_system.h"
#include "zelda3/dungeon/object_drawer.h"
#include "zelda3/dungeon/room.h"
#include "zelda3/dungeon/room_object.h"
#include "zelda3/sprite/sprite.h"
 
#include "rom/rom.h"
 
namespace yaze {
namespace editor {
 
class DungeonObjectInteraction {
 public:
  explicit DungeonObjectInteraction(gui::Canvas* canvas) : canvas_(canvas) {
    // Set up initial context
    interaction_context_.canvas = canvas;
    interaction_context_.selection = &selection_;
    entity_coordinator_.SetContext(&interaction_context_);
    entity_coordinator_.tile_handler().SetPlacementCallback(
        [this](const zelda3::RoomObject& object) {
          CompleteObjectPlacement(object);
        });
  }
 
  // ========================================================================
  // Context and Configuration
  // ========================================================================
 
  void SetContext(const InteractionContext& ctx) {
    interaction_context_ = ctx;
    interaction_context_.canvas = canvas_;  // Always use our canvas
    interaction_context_.selection = &selection_;
    entity_coordinator_.SetContext(&interaction_context_);
  }
 
  InteractionCoordinator& entity_coordinator() { return entity_coordinator_; }
  const InteractionCoordinator& entity_coordinator() const {
    return entity_coordinator_;
  }
 
  // Last mutation/invalidation domain (best-effort). Used by editors to route
  // undo capture and avoid expensive rerenders for overlay-only edits.
  MutationDomain last_mutation_domain() const {
    return interaction_context_.last_mutation_domain;
  }
  MutationDomain last_invalidation_domain() const {
    return interaction_context_.last_invalidation_domain;
  }
  void BeginCustomCollisionMutation() {
    FinishPaintStroke();
    interaction_context_.NotifyMutation(MutationDomain::kCustomCollision);
  }
  void EndCustomCollisionMutation() {
    interaction_context_.NotifyInvalidateCache(
        MutationDomain::kCustomCollision);
  }
  absl::Status ApplyCustomCollisionImportBatch(
      const std::vector<zelda3::CustomCollisionRoomEntry>& entries) {
    FinishPaintStroke();
    if (interaction_context_.on_collision_batch_import) {
      return interaction_context_.on_collision_batch_import(entries);
    }
    return absl::UnimplementedError("No collision batch import callback");
  }
  bool HasCollisionBatchImportCallback() const {
    return static_cast<bool>(interaction_context_.on_collision_batch_import);
  }
  void SetCollisionBatchImportCallback(
      std::function<
          absl::Status(const std::vector<zelda3::CustomCollisionRoomEntry>&)>
          callback) {
    interaction_context_.on_collision_batch_import = std::move(callback);
    entity_coordinator_.SetContext(&interaction_context_);
  }
 
  // Legacy setter - kept for backwards compatibility
  void SetRom(Rom* rom) {
    interaction_context_.rom = rom;
    entity_coordinator_.SetContext(&interaction_context_);
  }
 
  // Main interaction handling
  void HandleCanvasMouseInput();
  void CheckForObjectSelection();
  void PlaceObjectAtPosition(int room_x, int room_y);
 
  void DrawSelectionHighlights();  // Draw highlights for selected objects
  void DrawHoverHighlight(
      const std::vector<zelda3::RoomObject>& objects);  // Draw hover indicator
 
  // Drag and select box functionality
  void DrawGhostPreview();  // Draw ghost preview for object placement
 
  // Coordinate conversion
  std::pair<int, int> RoomToCanvasCoordinates(int room_x, int room_y) const;
  std::pair<int, int> CanvasToRoomCoordinates(int canvas_x, int canvas_y) const;
  bool IsWithinCanvasBounds(int canvas_x, int canvas_y, int margin = 32) const;
 
  // State management
  void SetCurrentRoom(DungeonRoomStore* rooms, int room_id);
  void SetPreviewObject(const zelda3::RoomObject& object, bool loaded);
  using PlacementPolicy = TileObjectHandler::PlacementPolicy;
  void SetPlacementPolicy(PlacementPolicy policy) {
    entity_coordinator_.tile_handler().SetPlacementPolicy(policy);
  }
  PlacementPolicy GetPlacementPolicy() const {
    return entity_coordinator_.tile_handler().GetPlacementPolicy();
  }
  const zelda3::RoomObject* GetPlacementPreview() const {
    const auto& handler = entity_coordinator_.tile_handler();
    return handler.IsPlacementActive() ? &handler.GetPreviewObject() : nullptr;
  }
  bool SetPlacementPreviewSize(uint8_t size) {
    return entity_coordinator_.tile_handler().SetPreviewSize(size);
  }
  bool SetPlacementPreviewLayer(int layer) {
    return entity_coordinator_.tile_handler().SetPreviewLayer(layer);
  }
  bool BeginPlacementFromSelection();
  void SetCurrentPaletteGroup(const gfx::PaletteGroup& group,
                              bool force_refresh = false) {
    bool palette_changed = current_palette_group_.name() != group.name() ||
                           current_palette_group_.size() != group.size();
    for (int i = 0; !palette_changed && i < static_cast<int>(group.size());
         ++i) {
      palette_changed =
          current_palette_group_.palette_ref(i) != group.palette_ref(i);
    }
    if (!palette_changed && !force_refresh) {
      return;
    }
 
    current_palette_group_ = group;
    interaction_context_.current_palette_group = group;
    entity_coordinator_.SetContext(&interaction_context_);
    entity_coordinator_.tile_handler().RefreshPreviewGraphics();
  }
 
  // Mode manager access
  InteractionModeManager& mode_manager() { return mode_manager_; }
  const InteractionModeManager& mode_manager() const { return mode_manager_; }
 
  // Mode queries - delegate to mode manager
  bool IsObjectLoaded() const {
    return mode_manager_.GetMode() == InteractionMode::PlaceObject;
  }
 
  void CancelPlacement();
  // Finish the active drag or paint stroke before a discrete editor command.
  void HandleMouseRelease();
 
  // Door placement mode
  void SetDoorPlacementMode(
      bool enabled, zelda3::DoorType type = zelda3::DoorType::NormalDoor);
  bool IsDoorPlacementActive() const {
    return mode_manager_.GetMode() == InteractionMode::PlaceDoor;
  }
  void SetPreviewDoorType(zelda3::DoorType type) {
    mode_manager_.GetModeState().preview_door_type = type;
  }
  zelda3::DoorType GetPreviewDoorType() const {
    return mode_manager_.GetModeState().preview_door_type.value_or(
        zelda3::DoorType::NormalDoor);
  }
  void CancelDoorPlacement() {
    if (mode_manager_.GetMode() == InteractionMode::PlaceDoor) {
      mode_manager_.CancelCurrentMode();
    }
  }
 
  // Sprite placement mode
  void SetSpritePlacementMode(bool enabled, uint8_t sprite_id = 0);
  bool IsSpritePlacementActive() const {
    return mode_manager_.GetMode() == InteractionMode::PlaceSprite;
  }
  void SetPreviewSpriteId(uint8_t id) {
    mode_manager_.GetModeState().preview_sprite_id = id;
  }
  uint8_t GetPreviewSpriteId() const {
    return mode_manager_.GetModeState().preview_sprite_id.value_or(0);
  }
  void CancelSpritePlacement() {
    if (mode_manager_.GetMode() == InteractionMode::PlaceSprite) {
      mode_manager_.CancelCurrentMode();
    }
  }
 
  // Item placement mode
  void SetItemPlacementMode(bool enabled, uint8_t item_id = 0);
  bool IsItemPlacementActive() const {
    return mode_manager_.GetMode() == InteractionMode::PlaceItem;
  }
  void SetPreviewItemId(uint8_t id) {
    mode_manager_.GetModeState().preview_item_id = id;
  }
  uint8_t GetPreviewItemId() const {
    return mode_manager_.GetModeState().preview_item_id.value_or(0);
  }
  void CancelItemPlacement() {
    if (mode_manager_.GetMode() == InteractionMode::PlaceItem) {
      mode_manager_.CancelCurrentMode();
    }
  }
 
  // Selection state - delegates to ObjectSelection
  std::vector<size_t> GetSelectedObjectIndices() const {
    return selection_.GetSelectedIndices();
  }
  void SetSelectedObjects(const std::vector<size_t>& indices) {
    entity_coordinator_.ClearEntitySelection();
    selection_.ClearSelection();
    for (size_t idx : indices) {
      selection_.SelectObject(idx, ObjectSelection::SelectionMode::Add);
    }
  }
  bool IsObjectSelectActive() const {
    return selection_.HasSelection() || selection_.IsRectangleSelectionActive();
  }
  void ClearSelection();
  bool IsObjectSelected(size_t index) const {
    return selection_.IsObjectSelected(index);
  }
  size_t GetSelectionCount() const { return selection_.GetSelectionCount(); }
 
  // Selection change notification
  void SetSelectionChangeCallback(std::function<void()> callback) {
    selection_.SetSelectionChangedCallback(std::move(callback));
  }
  void SetObjectSelectionVisibilityPredicate(
      std::function<bool(int, const zelda3::RoomObject&)> predicate) {
    interaction_context_.is_object_visible_for_selection = std::move(predicate);
    entity_coordinator_.SetContext(&interaction_context_);
  }
 
  // Helper for click selection with proper mode handling
 
  // Object manipulation
  void HandleScrollWheelResize();  // Resize selected objects with scroll wheel
 
  // Move the current canvas selection by one editor nudge step. Tile objects
  // move by room-tile units; doors, sprites, and items use their native grids.
  // Mixed selections move together so keyboard nudging follows the same grammar
  // as marquee and additive selection.
  bool NudgeSelected(int delta_x, int delta_y);
  absl::Status HandleDeleteSelected();
  void HandleDeleteAllObjects();
  absl::Status HandleCopySelected();
  absl::Status HandlePasteObjects();
  // Snap a pointer anchor while preserving the copied group's encoding grids.
  absl::Status HandlePasteObjectsAt(int pixel_x, int pixel_y);
  absl::Status HandleDuplicateSelected();
  absl::Status HandlePasteAt(int pixel_x, int pixel_y);
  const absl::Status& selection_edit_status() const {
    return entity_coordinator_.selection_edit_status();
  }
  void SetSharedSelectionClipboard(DungeonSelectionClipboard* clipboard) {
    shared_selection_clipboard_ = clipboard;
  }
  bool HasClipboardData() const { return !clipboard().empty(); }
 
  // Inspector-friendly mutation helpers (with undo + rerender integration).
  // These are intended for UI panels that want to edit a single object without
  // duplicating mutation/invalidation boilerplate.
  bool SetObjectId(size_t index, int16_t id);
  bool SetObjectSize(size_t index, uint8_t size);
  bool SetObjectLayer(size_t index, zelda3::RoomObject::LayerType layer);
 
  // Stored placement assignment for selected objects. Stream 2 is available
  // only when every selected object belongs to the room object stream; torches
  // and pushable blocks use a two-value special-table draw selector instead.
  bool CanAssignSelectedObjectsToLayer(int target_layer) const;
  bool SendSelectedToLayer(int target_layer);
 
  // Object ordering (changes draw order within the layer)
  // SNES draws objects in list order - first objects appear behind, last on top
  void
  SendSelectedToFront();  // Move to end of list (drawn last, appears on top)
  void
  SendSelectedToBack();  // Move to start of list (drawn first, appears behind)
  void BringSelectedForward();  // Move up one position in list
  void SendSelectedBackward();  // Move down one position in list
 
  // Layer filter access (delegates to ObjectSelection)
  void SetLayerFilter(int layer) { selection_.SetLayerFilter(layer); }
  int GetLayerFilter() const { return selection_.GetLayerFilter(); }
  bool IsLayerFilterActive() const { return selection_.IsLayerFilterActive(); }
  bool IsMaskModeActive() const { return selection_.IsMaskModeActive(); }
  const char* GetLayerFilterName() const {
    return selection_.GetLayerFilterName();
  }
  void SetLayersMerged(bool merged) { selection_.SetLayersMerged(merged); }
  bool AreLayersMerged() const { return selection_.AreLayersMerged(); }
 
  // Check keyboard shortcuts for layer operations
  void HandleLayerKeyboardShortcuts();
 
  // Callbacks - stored in interaction_context_ (single source of truth)
  void SetObjectPlacedCallback(
      std::function<void(const zelda3::RoomObject&)> callback) {
    object_placed_callback_ = std::move(callback);
  }
  void SetCacheInvalidationCallback(std::function<void()> callback) {
    interaction_context_.on_invalidate_cache = std::move(callback);
    entity_coordinator_.SetContext(&interaction_context_);
  }
  void SetMutationCallback(std::function<void()> callback) {
    interaction_context_.on_mutation = std::move(callback);
    entity_coordinator_.SetContext(&interaction_context_);
  }
  void SetSelectionEditCallbacks(
      std::function<absl::Status(const DungeonSelectionEditPlan&, bool)> edit,
      std::function<void()> finish,
      std::function<void(const absl::Status&)> error = {}) {
    interaction_context_.on_selection_edit = std::move(edit);
    interaction_context_.on_selection_edit_finished = std::move(finish);
    interaction_context_.on_selection_edit_error = std::move(error);
  }
  void FinishSelectionGesture() {
    entity_coordinator_.FinishSelectionGesture();
  }
  void SetEditorSystem(zelda3::DungeonEditorSystem* system) {
    editor_system_ = system;
  }
 
  // Entity selection (doors, sprites, items)
  void SelectEntity(EntityType type, size_t index);
  void ClearEntitySelection();
  bool HasEntitySelection() const {
    return entity_coordinator_.HasEntitySelection();
  }
  SelectedEntity GetSelectedEntity() const {
    return entity_coordinator_.GetSelectedEntity();
  }
 
  // Draw entity selection highlights
  void DrawEntitySelectionHighlights();
  void DrawDoorSnapIndicators();  // Show valid snap positions during door drag
 
  // Callbacks for entity changes
  void SetEntityChangedCallback(std::function<void()> callback) {
    interaction_context_.on_entity_changed = std::move(callback);
    entity_coordinator_.SetContext(&interaction_context_);
  }
  void SetDoorPairNavigationCallback(
      std::function<void(int, std::optional<size_t>, int, int)> callback) {
    interaction_context_.on_door_pair_navigation = std::move(callback);
    entity_coordinator_.SetContext(&interaction_context_);
  }
 
 private:
  void CompleteObjectPlacement(const zelda3::RoomObject& object);
  DungeonCanvasTransform GetCanvasTransform() const {
    return DungeonCanvasTransform(canvas_->zero_point(), canvas_->scrolling(),
                                  canvas_->global_scale());
  }
 
  gui::Canvas* canvas_;
  zelda3::DungeonEditorSystem* editor_system_ = nullptr;
  DungeonRoomStore* rooms_ = nullptr;
  int current_room_id_ = 0;
 
  // Unified interaction context and coordinator for entity handling
  InteractionContext interaction_context_;
  InteractionCoordinator entity_coordinator_;
 
  // Unified mode state machine - replaces scattered boolean flags
  InteractionModeManager mode_manager_;
 
  // Helper to calculate object bounds
  std::pair<int, int> CalculateObjectBounds(const zelda3::RoomObject& object);
 
  // Refactored input handlers
  void HandleLeftClick(const ImVec2& canvas_mouse_pos);
  void UpdateCollisionPainting(const ImVec2& canvas_mouse_pos);
  void UpdateWaterFillPainting(const ImVec2& canvas_mouse_pos);
  void HandleObjectSelectionStart(const ImVec2& canvas_mouse_pos);
  void HandleEmptySpaceClick(const ImVec2& canvas_mouse_pos);
  void FinishPaintStroke();
  bool HandleKeyboardNudge();
 
  // Ghost preview bitmap (persists across frames for placement preview)
  gfx::PaletteGroup current_palette_group_;
  DungeonSelectionClipboard& clipboard() {
    return shared_selection_clipboard_ ? *shared_selection_clipboard_
                                       : selection_clipboard_;
  }
  const DungeonSelectionClipboard& clipboard() const {
    return shared_selection_clipboard_ ? *shared_selection_clipboard_
                                       : selection_clipboard_;
  }
  // Direct viewer use retains a local clipboard; editor-owned viewers bind the
  // session clipboard so separate room panels can reuse one selection.
  DungeonSelectionClipboard selection_clipboard_;
  DungeonSelectionClipboard* shared_selection_clipboard_ = nullptr;
 
  // Unified selection system - replaces legacy selection state
  ObjectSelection selection_;
 
  // Callbacks - stored only in interaction_context_ (no duplication)
  std::function<void(const zelda3::RoomObject&)> object_placed_callback_;
 
  // Entity selection state (doors, sprites, items)
  // Note: entity selection is owned by InteractionCoordinator/handlers.
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_DUNGEON_DUNGEON_OBJECT_INTERACTION_H