base_entity_handler.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_DUNGEON_INTERACTION_BASE_ENTITY_HANDLER_H_
#define YAZE_APP_EDITOR_DUNGEON_INTERACTION_BASE_ENTITY_HANDLER_H_
 
#include <algorithm>
#include <optional>
#include <utility>
 
#include "app/editor/agent/agent_ui_theme.h"
#include "app/editor/dungeon/dungeon_canvas_transform.h"
#include "app/editor/dungeon/dungeon_coordinates.h"
#include "app/editor/dungeon/interaction/interaction_context.h"
#include "app/gui/core/touch_input.h"
#include "imgui/imgui.h"
 
namespace yaze {
namespace editor {
 
class BaseEntityHandler {
 public:
  virtual ~BaseEntityHandler() = default;
 
  void SetContext(InteractionContext* ctx) { ctx_ = ctx; }
 
  InteractionContext* context() const { return ctx_; }
 
  // ========================================================================
  // Placement Lifecycle
  // ========================================================================
 
  virtual void BeginPlacement() = 0;
 
  virtual void CancelPlacement() = 0;
 
  virtual bool IsPlacementActive() const = 0;
 
  // ========================================================================
  // Mouse Interaction
  // ========================================================================
 
  virtual bool HandleClick(int canvas_x, int canvas_y) = 0;
 
  virtual void HandleDrag(ImVec2 current_pos, ImVec2 delta) = 0;
 
  virtual void HandleRelease() = 0;
  virtual bool HandleMouseWheel(float delta) { return false; }
 
  // ========================================================================
  // Rendering
  // ========================================================================
 
  virtual void DrawGhostPreview() = 0;
 
  virtual void DrawSelectionHighlight() = 0;
 
  // ========================================================================
  // Hit Testing
  // ========================================================================
 
  virtual std::optional<size_t> GetEntityAtPosition(int canvas_x,
                                                    int canvas_y) const = 0;
 
  // Per-frame toast render called unconditionally by InteractionCoordinator so
  // the "Placed" message remains visible even after the user exits placement
  // mode immediately after a successful click.
  void DrawPostPlacementToast() {
    if (ImGui::GetCurrentContext() == nullptr)
      return;
    DrawSuccessToastOverlay(
        "Placed", ImGui::GetColorU32(AgentUI::GetTheme().status_success));
  }
 
 protected:
  InteractionContext* ctx_ = nullptr;
 
  // ========================================================================
  // Placement Success Toast (shared by all derived handlers)
  // ========================================================================
 
  // Call after a successful entity placement.  Extends the toast display by
  // kToastDuration seconds; rapid placements simply prolong the same toast.
  void TriggerSuccessToast() {
    if (ImGui::GetCurrentContext() == nullptr)
      return;
    toast_expire_time_ = static_cast<float>(ImGui::GetTime()) + kToastDuration;
  }
 
  // Draw a fading "OK" toast near the canvas origin.
  // @param msg  Short message to display (e.g. "Placed").
  // @param color Opaque RGBA colour for the text (alpha will be modulated).
  void DrawSuccessToastOverlay(const char* msg, ImU32 color) const {
    if (ImGui::GetCurrentContext() == nullptr)
      return;
    if (toast_expire_time_ <= 0.0f || ImGui::GetTime() >= toast_expire_time_) {
      return;
    }
    float remaining = toast_expire_time_ - static_cast<float>(ImGui::GetTime());
    // Fade out during the last 0.4 s; keep full opacity the rest of the time.
    float alpha = std::min(1.0f, remaining / 0.4f);
    // Blend alpha into supplied colour.
    ImU32 base_rgb = color & 0x00FFFFFFu;
    ImU32 alpha_ch = static_cast<ImU32>(alpha * 255.0f) << 24;
    ImU32 toast_color = base_rgb | alpha_ch;
 
    ImVec2 canvas_pos = GetCanvasZeroPoint();
    ImDrawList* draw_list = ImGui::GetWindowDrawList();
    // Render near the top-left canvas corner so it never overlaps tiles.
    draw_list->AddText(ImVec2(canvas_pos.x + 8.0f, canvas_pos.y + 6.0f),
                       toast_color, msg);
  }
 
  // Shared toast expiry timestamp (seconds, from ImGui::GetTime()).
  float toast_expire_time_ = 0.0f;
 
  static constexpr float kToastDuration = 1.5f;
 
  // ========================================================================
  // Helper Methods (available to all derived handlers)
  // ========================================================================
 
  std::pair<int, int> RoomToCanvas(int room_x, int room_y) const {
    return dungeon_coords::RoomToCanvas(room_x, room_y);
  }
 
  std::pair<int, int> CanvasToRoom(int canvas_x, int canvas_y) const {
    return dungeon_coords::CanvasToRoom(canvas_x, canvas_y);
  }
 
  bool IsWithinBounds(int canvas_x, int canvas_y) const {
    return dungeon_coords::IsWithinBounds(canvas_x, canvas_y);
  }
 
  ImVec2 GetCanvasZeroPoint() const {
    if (!ctx_ || !ctx_->canvas)
      return ImVec2(0, 0);
    return ctx_->canvas->zero_point();
  }
 
  DungeonCanvasTransform GetCanvasTransform() const {
    if (!ctx_ || !ctx_->canvas) {
      return DungeonCanvasTransform(ImVec2(0, 0), ImVec2(0, 0), 1.0f);
    }
    return DungeonCanvasTransform(ctx_->canvas->zero_point(),
                                  ctx_->canvas->scrolling(),
                                  ctx_->canvas->global_scale());
  }
 
  std::optional<ImVec2> GetPointerScreenPosition() const {
    if (ImGui::GetCurrentContext() == nullptr || !ctx_ || !ctx_->canvas) {
      return std::nullopt;
    }
 
    const DungeonCanvasTransform transform = GetCanvasTransform();
    const auto is_within_room = [&transform](ImVec2 screen_pos) {
      const auto [room_x, room_y] =
          transform.ScreenToRoomPixelCoordinates(screen_pos);
      return dungeon_coords::IsWithinBounds(room_x, room_y);
    };
 
    if (ctx_->canvas->IsMouseHovering()) {
      const ImVec2 mouse_pos = ImGui::GetIO().MousePos;
      if (is_within_room(mouse_pos)) {
        return mouse_pos;
      }
    }
 
    if (!gui::TouchInput::IsTouchActive()) {
      return std::nullopt;
    }
 
    for (int i = 0; i < gui::TouchInput::kMaxTouchPoints; ++i) {
      const auto touch = gui::TouchInput::GetTouchPoint(i);
      if (!touch.active) {
        continue;
      }
      if (is_within_room(touch.position)) {
        return touch.position;
      }
    }
 
    return std::nullopt;
  }
 
  bool HasValidContext() const { return ctx_ && ctx_->IsValid(); }
 
  zelda3::Room* GetCurrentRoom() const {
    return ctx_ ? ctx_->GetCurrentRoom() : nullptr;
  }
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_DUNGEON_INTERACTION_BASE_ENTITY_HANDLER_H_