interaction_coordinator.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_DUNGEON_INTERACTION_INTERACTION_COORDINATOR_H_
#define YAZE_APP_EDITOR_DUNGEON_INTERACTION_INTERACTION_COORDINATOR_H_
 
#include <string>
#include <tuple>
#include <vector>
 
#include "app/editor/dungeon/interaction/door_interaction_handler.h"
#include "app/editor/dungeon/interaction/interaction_context.h"
#include "app/editor/dungeon/interaction/item_interaction_handler.h"
#include "app/editor/dungeon/interaction/sprite_interaction_handler.h"
#include "app/editor/dungeon/interaction/tile_object_handler.h"
 
namespace yaze {
namespace editor {
 
class InteractionCoordinator {
 public:
  enum class Mode {
    Select,       // Normal selection mode (no placement)
    PlaceDoor,    // Door placement mode
    PlaceSprite,  // Sprite placement mode
    PlaceItem     // Item placement mode
  };
 
  InteractionCoordinator() : current_mode_(Mode::Select), ctx_(nullptr) {}
 
  void SetContext(InteractionContext* ctx);
 
  Mode GetCurrentMode() const { return current_mode_; }
 
  void SetMode(Mode mode);
 
  void CancelCurrentMode();
 
  bool IsPlacementActive() const;
 
  // ========================================================================
  // Handler Access
  // ========================================================================
 
  DoorInteractionHandler& door_handler() { return door_handler_; }
  const DoorInteractionHandler& door_handler() const { return door_handler_; }
 
  SpriteInteractionHandler& sprite_handler() { return sprite_handler_; }
  const SpriteInteractionHandler& sprite_handler() const {
    return sprite_handler_;
  }
 
  ItemInteractionHandler& item_handler() { return item_handler_; }
  const ItemInteractionHandler& item_handler() const { return item_handler_; }
 
  TileObjectHandler& tile_handler() { return tile_handler_; }
  const TileObjectHandler& tile_handler() const { return tile_handler_; }
 
  // ========================================================================
  // Unified Interaction Methods
  // ========================================================================
 
  bool HandleClick(int canvas_x, int canvas_y);
  bool HandleMouseWheel(float delta);
 
  void SelectEntity(EntityType type, size_t index);
  void SetSelectedEntities(std::vector<SelectedEntity> entities);
  void ClearEntitySelection();
  bool HasEntitySelection() const;
  bool NudgeSelected(int delta_x, int delta_y);
  void CancelPlacement();
  const std::vector<SelectedEntity>& GetSelectedEntities() const {
    return selected_entities_;
  }
  void SelectEntitiesInRect(const std::tuple<int, int, int, int>& bounds,
                            bool additive, bool toggle);
  void BeginSelectionDrag(ImVec2 start_pos);
 
  // Doors/sprites/items only (tile objects are handled by ObjectSelection).
  std::optional<SelectedEntity> GetEntityAtPosition(int canvas_x,
                                                    int canvas_y) const;
  std::vector<SelectedEntity> GetEntitiesAtPosition(int canvas_x,
                                                    int canvas_y) const;
 
  // Current selection (doors/sprites/items only). Returns {None,0} if none.
  SelectedEntity GetSelectedEntity() const;
 
  void HandleDrag(ImVec2 current_pos, ImVec2 delta);
 
  void HandleRelease();
 
  void DrawGhostPreviews();
 
  void DrawSelectionHighlights();
 
  void DrawPostPlacementOverlays();
 
  // ========================================================================
  // Entity Selection
  // ========================================================================
 
  bool TrySelectEntityAtCursor(int canvas_x, int canvas_y);
 
  void ClearAllEntitySelections();
 
  void DeleteSelectedEntity();
 
  Mode GetSelectedEntityType() const;
 
 private:
  Mode current_mode_ = Mode::Select;
  InteractionContext* ctx_ = nullptr;
 
  DoorInteractionHandler door_handler_;
  SpriteInteractionHandler sprite_handler_;
  ItemInteractionHandler item_handler_;
  TileObjectHandler tile_handler_;
  std::vector<SelectedEntity> selected_entities_;
  int cycle_last_x_ = -1;
  int cycle_last_y_ = -1;
  size_t cycle_next_index_ = 0;
  size_t cycle_active_index_ = 0;
  ImVec2 cycle_hud_screen_pos_{0.0f, 0.0f};
  double cycle_hud_start_time_ = -1.0;
  std::vector<SelectedEntity> cycle_last_hits_;
  bool entity_group_drag_active_ = false;
  ImVec2 entity_group_drag_start_{0.0f, 0.0f};
  ImVec2 entity_group_drag_current_{0.0f, 0.0f};
  int entity_group_drag_last_dx_ = 0;
  int entity_group_drag_last_dy_ = 0;
  bool entity_group_drag_doors_mutation_started_ = false;
  bool entity_group_drag_sprites_mutation_started_ = false;
  bool entity_group_drag_items_mutation_started_ = false;
  bool entity_group_drag_doors_changed_ = false;
  bool entity_group_drag_sprites_changed_ = false;
  bool entity_group_drag_items_changed_ = false;
 
  BaseEntityHandler* GetActiveHandler();
  bool ApplySelection(SelectedEntity entity);
  bool UpdateEntitySelection(SelectedEntity entity, bool additive, bool toggle);
  bool IsSelectionHitSelected(SelectedEntity entity) const;
  bool HasGroupDragSelection() const;
  bool NudgeSelectedEntities(int delta_x, int delta_y,
                             bool defer_drag_notifications);
  void ResetEntityGroupDragState();
  void FinishEntityGroupDrag();
  void HandleEntityGroupDrag(ImVec2 current_pos);
  bool SameCycleTarget(int canvas_x, int canvas_y,
                       const std::vector<SelectedEntity>& hits) const;
  void UpdateSelectionCycleHudPreview();
  std::optional<size_t> FindSelectedCycleIndex(
      const std::vector<SelectedEntity>& hits) const;
  void DrawSelectionCycleHud();
  void DrawMultiEntitySelectionHighlights();
  std::string DescribeEntity(SelectedEntity entity) const;
  std::string DescribeCycleHudEntity(SelectedEntity entity) const;
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_DUNGEON_INTERACTION_INTERACTION_COORDINATOR_H_