tile_object_handler.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_DUNGEON_INTERACTION_TILE_OBJECT_HANDLER_H
#define YAZE_APP_EDITOR_DUNGEON_INTERACTION_TILE_OBJECT_HANDLER_H
 
#include <functional>
#include <optional>
 
#include <utility>
#include <vector>
#include "absl/status/status.h"
#include "app/editor/dungeon/interaction/base_entity_handler.h"
#include "app/editor/dungeon/interaction/ghost_preview_feedback.h"
#include "app/editor/dungeon/interaction/interaction_context.h"
#include "app/gfx/render/background_buffer.h"
#include "zelda3/dungeon/room.h"
#include "zelda3/dungeon/room_object.h"
 
namespace yaze::editor {
 
class TileObjectHandler : public BaseEntityHandler {
 public:
  using GhostCapacityState = PlacementCapacityState;
  struct GhostPreviewGeometry {
    int render_anchor_x_tiles = 0;
    int render_anchor_y_tiles = 0;
    int offset_x_tiles = 0;
    int offset_y_tiles = 0;
    int width_pixels = 8;
    int height_pixels = 8;
    int buffer_width_pixels = 8;
    int buffer_height_pixels = 8;
  };
 
  enum class PlacementBlockReason {
    kNone = 0,
    kInvalidRoom,
    kObjectLimit,
    kChestValidation,
  };
 
  enum class PlacementPolicy { kRepeat, kOnce };
 
  TileObjectHandler() : ghost_preview_buffer_(nullptr) {}
  explicit TileObjectHandler(InteractionContext* ctx) { SetContext(ctx); }
 
  // ========================================================================
  // BaseEntityHandler interface
  // ========================================================================
 
  void BeginPlacement() override;
  void CancelPlacement() override;
  bool IsPlacementActive() const override { return object_placement_mode_; }
 
  bool HandleClick(int canvas_x, int canvas_y) override;
  void HandleDrag(ImVec2 current_pos, ImVec2 delta) override;
  void HandleRelease() override;
  bool HandleMouseWheel(float delta) override;
 
  void DrawGhostPreview() override;
  void DrawSelectionHighlight() override;
 
  void InitDrag(const ImVec2& start_pos);
 
  // ========================================================================
  // Marquee (Rectangle) Selection
  // ========================================================================
 
  // Begin a rectangle selection drag on empty space (canvas-local coords).
  void BeginMarqueeSelection(const ImVec2& start_pos);
 
  // Update/draw active marquee selection and finalize on mouse release.
  void HandleMarqueeSelection(const ImVec2& mouse_pos, bool mouse_left_down,
                              bool mouse_left_released, bool shift_down,
                              bool toggle_down, bool alt_down,
                              bool draw_box = true);
 
  std::optional<size_t> GetEntityAtPosition(int canvas_x,
                                            int canvas_y) const override;
 
  bool MoveObjects(int room_id, const std::vector<size_t>& indices, int delta_x,
                   int delta_y, bool notify_mutation = true);
 
  std::vector<size_t> DuplicateObjects(int room_id,
                                       const std::vector<size_t>& indices,
                                       int delta_x, int delta_y);
 
  bool DeleteObjects(int room_id, std::vector<size_t> indices);
 
  bool DeleteAllObjects(int room_id);
 
  void SendToFront(int room_id, const std::vector<size_t>& indices);
  void SendToBack(int room_id, const std::vector<size_t>& indices);
  void MoveForward(int room_id, const std::vector<size_t>& indices);
  void MoveBackward(int room_id, const std::vector<size_t>& indices);
 
  bool ResizeObjects(int room_id, const std::vector<size_t>& indices, int delta,
                     bool horizontal = false, bool uniform = false);
 
  bool PlaceObjectAt(int room_id, const zelda3::RoomObject& object, int x,
                     int y);
 
  void SetPlacementPolicy(PlacementPolicy policy) {
    placement_policy_ = policy;
  }
  PlacementPolicy GetPlacementPolicy() const { return placement_policy_; }
  using ObjectMutationPreflight =
      std::function<absl::Status(int, const std::vector<zelda3::RoomObject>&,
                                 const std::vector<chest_data>&)>;
  void SetObjectMutationPreflight(ObjectMutationPreflight callback) {
    object_mutation_preflight_ = std::move(callback);
  }
  // Runs only after a discrete command passes preflight, before publishing it.
  // Continuous drag increments must not finish their own gesture.
  void SetBeforeObjectCommandCallback(std::function<void()> callback) {
    before_object_command_callback_ = 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);
  }
 
  void SetPlacementCallback(
      std::function<void(const zelda3::RoomObject&)> callback) {
    placement_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;
 
  void UpdateObjectsId(int room_id, const std::vector<size_t>& indices,
                       int16_t new_id);
 
  void UpdateObjectsSize(int room_id, const std::vector<size_t>& indices,
                         uint8_t new_size);
 
  // Returns false when the request is rejected. Accepted no-op updates return
  // true so inspector controls can distinguish validation failures from an
  // already-selected target.
  bool UpdateObjectsLayer(int room_id, const std::vector<size_t>& indices,
                          int new_layer);
 
  void SetPreviewObject(const zelda3::RoomObject& object);
  const zelda3::RoomObject& GetPreviewObject() const { return preview_object_; }
 
  // Preview edits do not mutate the room or create undo entries. Accepted
  // no-op updates return true; unavailable sizes/layers return false.
  bool SetPreviewSize(uint8_t size);
  bool SetPreviewLayer(int layer);
 
  void RefreshPreviewGraphics();
 
  static GhostPreviewGeometry CalculateGhostPreviewGeometry(
      const zelda3::RoomObject& object);
 
  const gfx::BackgroundBuffer* ghost_preview_buffer_for_testing() const {
    return ghost_preview_buffer_.get();
  }
 
  // ========================================================================
  // Clipboard Operations
  // ========================================================================
 
  void CopyObjectsToClipboard(int room_id, const std::vector<size_t>& indices);
 
  std::vector<size_t> PasteFromClipboard(int room_id, int offset_x,
                                         int offset_y);
 
  std::vector<size_t> PasteFromClipboardAt(int room_id, int target_x,
                                           int target_y);
 
  bool HasClipboardData() const { return !clipboard_.empty(); }
 
  void ClearClipboard() {
    clipboard_.clear();
    clipboard_chests_.clear();
    clipboard_status_ = absl::OkStatus();
  }
 
 private:
  // Placement state
  bool object_placement_mode_ = false;
  PlacementPolicy placement_policy_ = PlacementPolicy::kOnce;
  std::function<void(const zelda3::RoomObject&)> placement_callback_;
  PlacementBlockReason placement_block_reason_ = PlacementBlockReason::kNone;
  zelda3::RoomObject preview_object_{-1, 0, 0, 0};
  std::unique_ptr<gfx::BackgroundBuffer> ghost_preview_buffer_;
  bool ghost_preview_bitmap_ready_ = false;
  bool ghost_preview_create_queued_ = false;
  uint64_t ghost_preview_graphics_revision_ = 0;
  int ghost_preview_room_id_ = -1;
 
  // Clipboard
  std::vector<zelda3::RoomObject> clipboard_;
  std::vector<std::optional<chest_data>> clipboard_chests_;
  absl::Status clipboard_status_;
  absl::Status mutation_status_;
  ObjectMutationPreflight object_mutation_preflight_;
  std::function<void()> before_object_command_callback_;
  std::function<void(const absl::Status&)> mutation_error_callback_;
  bool RejectMutation(absl::Status status);
 
  bool CommitCandidate(
      int room_id, std::vector<zelda3::RoomObject> candidate,
      const std::vector<std::optional<size_t>>& sources,
      const std::vector<std::optional<chest_data>>& chest_overrides = {},
      std::optional<std::vector<size_t>> selection = std::nullopt);
 
  void RenderGhostPreviewBitmap();
 
  // Drag state
  bool is_dragging_ = false;
  ImVec2 drag_start_{0, 0};
  ImVec2 drag_current_{0, 0};
  int drag_last_dx_ = 0;
  int drag_last_dy_ = 0;
  bool drag_has_duplicated_ = false;
  bool drag_mutation_started_ = false;
  std::optional<std::pair<int, int>> drag_rejected_delta_;
 
  ImVec2 ApplyDragModifiers(const ImVec2& delta) const;
  void DrawSmartGuides(const std::vector<zelda3::RoomObject>& objects) const;
 
  zelda3::Room* GetRoom(int room_id);
  void NotifyChange(zelda3::Room* room);
};
 
}  // namespace yaze::editor
 
#endif  // YAZE_APP_EDITOR_DUNGEON_INTERACTION_TILE_OBJECT_HANDLER_H