door_interaction_handler.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_DUNGEON_INTERACTION_DOOR_INTERACTION_HANDLER_H_
#define YAZE_APP_EDITOR_DUNGEON_INTERACTION_DOOR_INTERACTION_HANDLER_H_
 
#include <functional>
#include <string>
#include <utility>
#include <vector>
 
#include "absl/status/status.h"
#include "app/editor/dungeon/interaction/base_entity_handler.h"
#include "zelda3/dungeon/door_position.h"
#include "zelda3/dungeon/door_types.h"
#include "zelda3/dungeon/room.h"
 
namespace yaze {
namespace editor {
 
class DoorInteractionHandler : public BaseEntityHandler {
 public:
  enum class PlacementBlockReason {
    kNone = 0,
    kInvalidRoom,
    kDoorLimit,
    kInvalidPosition,
    kStorageValidation,
  };
  enum class GhostCapacityState {
    kNormal = 0,
    kNearLimit,
    kAtLimit,
  };
 
  // ========================================================================
  // BaseEntityHandler interface
  // ========================================================================
 
  void BeginPlacement() override;
  void CancelPlacement() override;
  bool IsPlacementActive() const override { return door_placement_mode_; }
 
  bool HandleClick(int canvas_x, int canvas_y) override;
  void HandleDrag(ImVec2 current_pos, ImVec2 delta) override;
  void HandleRelease() override;
  bool HandleOverlayClick(int canvas_x, int canvas_y);
 
  void DrawGhostPreview() override;
  void DrawSelectionHighlight() override;
 
  std::optional<size_t> GetEntityAtPosition(int canvas_x,
                                            int canvas_y) const override;
 
  // ========================================================================
  // Door-specific methods
  // ========================================================================
 
  void SetDoorType(zelda3::DoorType type) { preview_door_type_ = type; }
 
  zelda3::DoorType GetDoorType() const { return preview_door_type_; }
 
  void DrawSnapIndicators();
 
  void SelectDoor(size_t index);
 
  void ClearSelection();
 
  bool HasSelection() const { return selected_door_index_.has_value(); }
 
  std::optional<size_t> GetSelectedIndex() const {
    return selected_door_index_;
  }
 
  void DeleteSelected();
  void DeleteAll();
  bool NudgeSelected(int delta_x, int delta_y);
 
  bool MutateDoorType(size_t index, zelda3::DoorType new_type);
  // Applies an encodable door edit atomically; invalid and unchanged values
  // leave both the room and undo history untouched.
  bool UpdateDoor(size_t index, zelda3::DoorType type,
                  zelda3::DoorDirection direction, uint8_t position);
 
  // Preflight is read-only and runs before history or room data changes.
  using DoorMutationPreflight =
      std::function<absl::Status(int, const std::vector<zelda3::Room::Door>&)>;
  void SetDoorMutationPreflight(DoorMutationPreflight callback) {
    door_mutation_preflight_ = std::move(callback);
  }
  const absl::Status& mutation_status() const { return mutation_status_; }
  void SetMutationErrorCallback(
      std::function<void(const absl::Status&)> callback) {
    mutation_error_callback_ = std::move(callback);
  }
 
  bool was_placement_blocked() const {
    return placement_block_reason_ != PlacementBlockReason::kNone;
  }
  PlacementBlockReason placement_block_reason() const {
    return placement_block_reason_;
  }
  void clear_placement_blocked() {
    placement_block_reason_ = PlacementBlockReason::kNone;
  }
  GhostCapacityState GetPlacementGhostCapacityState() const;
 
 private:
  struct PairBadgeOverlay {
    std::string label;
    ImVec2 screen_pos;
    ImVec2 screen_size;
    ImU32 color = 0;
    int target_room_id = -1;
    std::optional<size_t> target_door_index;
    int target_tile_x = -1;
    int target_tile_y = -1;
  };
 
  // Placement state
  bool door_placement_mode_ = false;
  PlacementBlockReason placement_block_reason_ = PlacementBlockReason::kNone;
  zelda3::DoorType preview_door_type_ = zelda3::DoorType::NormalDoor;
  zelda3::DoorDirection detected_door_direction_ = zelda3::DoorDirection::North;
  uint8_t snapped_door_position_ = 0;
 
  // Selection state
  std::optional<size_t> selected_door_index_;
  bool is_dragging_ = false;
  ImVec2 drag_start_pos_;
  ImVec2 drag_current_pos_;
  // Pointer position relative to the selected door's raw ROM anchor. Special
  // doors can extend several tiles above/left of that anchor, so preserving
  // this offset keeps the encoded position stable regardless of grab point.
  ImVec2 drag_grab_offset_from_anchor_ = ImVec2(0.0f, 0.0f);
 
  DoorMutationPreflight door_mutation_preflight_;
  std::function<void(const absl::Status&)> mutation_error_callback_;
  absl::Status mutation_status_ = absl::OkStatus();
 
  bool PreflightDoors(const std::vector<zelda3::Room::Door>& candidate);
 
  void PlaceDoorAtSnappedPosition(int canvas_x, int canvas_y);
 
  bool UpdateSnappedPosition(int canvas_x, int canvas_y);
 
  std::pair<int, int> GetCurrentDragAnchorPosition() const;
 
  std::optional<PairBadgeOverlay> BuildPairBadgeOverlay(
      const zelda3::Room::Door& door, ImVec2 door_pos, ImVec2 door_size,
      float scale) const;
  void NavigateToPairBadge(const PairBadgeOverlay& badge) const;
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_DUNGEON_INTERACTION_DOOR_INTERACTION_HANDLER_H_