item_interaction_handler.cc

Go to the documentation of this file.

// Related header
#include "item_interaction_handler.h"
 
// C++ standard library
#include <algorithm>
 
// Third-party library headers
#include "absl/strings/str_format.h"
#include "imgui/imgui.h"
 
// Project headers
#include "app/editor/agent/agent_ui_theme.h"
#include "app/editor/dungeon/dungeon_coordinates.h"
 
namespace yaze::editor {
 
void ItemInteractionHandler::BeginPlacement() {
  mutation_status_ = absl::OkStatus();
  item_placement_mode_ = true;
  ClearSelection();
}
 
bool ItemInteractionHandler::HandleClick(int canvas_x, int canvas_y) {
  if (!HasValidContext())
    return false;
 
  if (item_placement_mode_) {
    if (IsWithinBounds(canvas_x, canvas_y)) {
      PlaceItemAtPosition(canvas_x, canvas_y);
    }
    return true;
  }
 
  // Try to select item at position
  auto item_index = GetEntityAtPosition(canvas_x, canvas_y);
  if (item_index.has_value()) {
    SelectItem(*item_index);
    is_dragging_ = true;
    drag_start_pos_ =
        ImVec2(static_cast<float>(canvas_x), static_cast<float>(canvas_y));
    drag_current_pos_ = drag_start_pos_;
    return true;
  }
 
  ClearSelection();
  return false;
}
 
void ItemInteractionHandler::HandleDrag(ImVec2 current_pos, ImVec2 delta) {
  if (!is_dragging_ || !selected_item_index_.has_value())
    return;
  drag_current_pos_ = current_pos;
}
 
void ItemInteractionHandler::HandleRelease() {
  if (!is_dragging_ || !selected_item_index_.has_value()) {
    is_dragging_ = false;
    return;
  }
 
  auto* room = GetCurrentRoom();
  if (!room) {
    is_dragging_ = false;
    return;
  }
 
  const int pixel_x = std::clamp(static_cast<int>(drag_current_pos_.x), 0,
                                 dungeon_coords::kRoomPixelWidth - 1);
  const int pixel_y = std::clamp(static_cast<int>(drag_current_pos_.y), 0,
                                 dungeon_coords::kRoomPixelHeight - 1);
 
  auto& pot_items = room->GetPotItems();
  if (*selected_item_index_ < pot_items.size()) {
    const auto encoded = zelda3::EncodePotItemPosition(
        pixel_x / 8 * 8, pixel_y / 8 * 8,
        pot_items[*selected_item_index_].position);
    if (!encoded) {
      is_dragging_ = false;
      return;
    }
    const uint16_t next_position = *encoded;
    if (pot_items[*selected_item_index_].position == next_position) {
      is_dragging_ = false;
      return;
    }
 
    ctx_->NotifyMutation(MutationDomain::kItems);
    pot_items[*selected_item_index_].position = next_position;
    room->MarkPotItemsDirty();
    ctx_->NotifyInvalidateCache(MutationDomain::kItems);
    ctx_->NotifyEntityChanged();
  }
 
  is_dragging_ = false;
}
 
void ItemInteractionHandler::DrawGhostPreview() {
  if (!item_placement_mode_ || !HasValidContext())
    return;
 
  auto* canvas = ctx_->canvas;
  const auto pointer_screen_pos = GetPointerScreenPosition();
  if (!pointer_screen_pos.has_value())
    return;
 
  const DungeonCanvasTransform transform = GetCanvasTransform();
  const auto [canvas_x, canvas_y] =
      transform.ScreenToRoomPixelCoordinates(*pointer_screen_pos);
 
  // Snap to 8-pixel grid
  int snapped_x =
      (canvas_x / dungeon_coords::kTileSize) * dungeon_coords::kTileSize;
  int snapped_y =
      (canvas_y / dungeon_coords::kTileSize) * dungeon_coords::kTileSize;
 
  // Draw ghost rectangle for item preview
  const ImVec2 rect_min = transform.RoomPixelsToScreen(
      ImVec2(static_cast<float>(snapped_x), static_cast<float>(snapped_y)));
  const ImVec2 rect_size = transform.RoomSizeToScreen(ImVec2(16, 16));
  const ImVec2 rect_max(rect_min.x + rect_size.x, rect_min.y + rect_size.y);
 
  const auto& theme = AgentUI::GetTheme();
  ImVec4 fill_color = theme.dungeon_selection_primary;
  fill_color.w = 0.35f;
  ImVec4 outline_color = theme.dungeon_selection_primary;
  outline_color.w = 0.85f;
 
  canvas->draw_list()->AddRectFilled(rect_min, rect_max,
                                     ImGui::GetColorU32(fill_color));
  canvas->draw_list()->AddRect(
      rect_min, rect_max, ImGui::GetColorU32(outline_color), 0.0f, 0, 2.0f);
 
  // Draw item ID label
  std::string label = absl::StrFormat("%02X", preview_item_id_);
  canvas->draw_list()->AddText(rect_min, ImGui::GetColorU32(theme.text_primary),
                               label.c_str());
}
 
void ItemInteractionHandler::DrawSelectionHighlight() {
  if (!selected_item_index_.has_value() || !HasValidContext())
    return;
 
  auto* room = GetCurrentRoom();
  if (!room)
    return;
 
  const auto& pot_items = room->GetPotItems();
  if (*selected_item_index_ >= pot_items.size())
    return;
 
  const auto& pot_item = pot_items[*selected_item_index_];
  int pixel_x = pot_item.GetPixelX();
  int pixel_y = pot_item.GetPixelY();
 
  // If dragging, use current drag position
  if (is_dragging_) {
    pixel_x = static_cast<int>(drag_current_pos_.x);
    pixel_y = static_cast<int>(drag_current_pos_.y);
    // Snap to 8-pixel grid
    pixel_x = (pixel_x / dungeon_coords::kTileSize) * dungeon_coords::kTileSize;
    pixel_y = (pixel_y / dungeon_coords::kTileSize) * dungeon_coords::kTileSize;
  }
 
  ImDrawList* draw_list = ImGui::GetWindowDrawList();
  const DungeonCanvasTransform transform = GetCanvasTransform();
  const float scale = transform.scale();
  const ImVec2 pos = transform.RoomPixelsToScreen(
      ImVec2(static_cast<float>(pixel_x), static_cast<float>(pixel_y)));
  const ImVec2 size = transform.RoomSizeToScreen(ImVec2(16, 16));
 
  // Animated selection
  static float pulse = 0.0f;
  pulse += ImGui::GetIO().DeltaTime * 3.0f;
  float alpha = 0.5f + 0.3f * sinf(pulse);
 
  ImU32 color = IM_COL32(255, 255, 0, 180);  // Yellow
  ImU32 fill_color =
      (color & 0x00FFFFFF) | (static_cast<ImU32>(alpha * 100) << 24);
 
  draw_list->AddRectFilled(pos, ImVec2(pos.x + size.x, pos.y + size.y),
                           fill_color);
  draw_list->AddRect(pos, ImVec2(pos.x + size.x, pos.y + size.y), color, 0.0f,
                     0, 2.0f);
 
  // Draw label
  ImVec2 text_pos(pos.x, pos.y - 14 * scale);
  draw_list->AddText(text_pos, IM_COL32(255, 255, 255, 220), "Item");
}
 
std::optional<size_t> ItemInteractionHandler::GetEntityAtPosition(
    int canvas_x, int canvas_y) const {
  if (!HasValidContext() || !IsWithinBounds(canvas_x, canvas_y))
    return std::nullopt;
 
  auto* room = ctx_->GetCurrentRoomConst();
  if (!room)
    return std::nullopt;
 
  // Check pot items
  const auto& pot_items = room->GetPotItems();
  for (size_t i = 0; i < pot_items.size(); ++i) {
    const auto& pot_item = pot_items[i];
 
    int item_x = pot_item.GetPixelX();
    int item_y = pot_item.GetPixelY();
 
    // 16x16 hitbox
    if (canvas_x >= item_x && canvas_x < item_x + 16 && canvas_y >= item_y &&
        canvas_y < item_y + 16) {
      return i;
    }
  }
 
  return std::nullopt;
}
 
void ItemInteractionHandler::SelectItem(size_t index) {
  selected_item_index_ = index;
  ctx_->NotifyEntityChanged();
}
 
void ItemInteractionHandler::ClearSelection() {
  selected_item_index_ = std::nullopt;
  is_dragging_ = false;
}
 
void ItemInteractionHandler::DeleteSelected() {
  if (!selected_item_index_.has_value() || !HasValidContext())
    return;
 
  auto* room = GetCurrentRoom();
  if (!room)
    return;
 
  auto& pot_items = room->GetPotItems();
  if (*selected_item_index_ >= pot_items.size())
    return;
 
  ctx_->NotifyMutation(MutationDomain::kItems);
  pot_items.erase(pot_items.begin() +
                  static_cast<ptrdiff_t>(*selected_item_index_));
  room->MarkPotItemsDirty();
  ClearSelection();
  ctx_->NotifyInvalidateCache(MutationDomain::kItems);
  ctx_->NotifyEntityChanged();
}
 
void ItemInteractionHandler::DeleteAll() {
  if (!HasValidContext()) {
    return;
  }
 
  auto* room = GetCurrentRoom();
  if (!room || room->GetPotItems().empty()) {
    return;
  }
 
  ctx_->NotifyMutation(MutationDomain::kItems);
  room->GetPotItems().clear();
  room->MarkPotItemsDirty();
  ClearSelection();
  ctx_->NotifyInvalidateCache(MutationDomain::kItems);
  ctx_->NotifyEntityChanged();
}
 
bool ItemInteractionHandler::NudgeSelected(int delta_pixel_x,
                                           int delta_pixel_y) {
  if (!selected_item_index_.has_value() || !HasValidContext()) {
    return false;
  }
 
  auto* room = GetCurrentRoom();
  if (!room) {
    return false;
  }
 
  auto& pot_items = room->GetPotItems();
  if (*selected_item_index_ >= pot_items.size()) {
    return false;
  }
 
  auto& pot_item = pot_items[*selected_item_index_];
  constexpr int kRoomPixelMax = 511;
  const int next_pixel_x =
      std::clamp(pot_item.GetPixelX() + delta_pixel_x, 0, kRoomPixelMax);
  const int next_pixel_y =
      std::clamp(pot_item.GetPixelY() + delta_pixel_y, 0, kRoomPixelMax);
  const auto encoded = zelda3::EncodePotItemPosition(
      next_pixel_x / 8 * 8, next_pixel_y / 8 * 8, pot_item.position);
  if (!encoded)
    return false;
  const uint16_t next_position = *encoded;
  if (next_position == pot_item.position) {
    return false;
  }
 
  ctx_->NotifyMutation(MutationDomain::kItems);
  pot_item.position = next_position;
  room->MarkPotItemsDirty();
  ctx_->NotifyInvalidateCache(MutationDomain::kItems);
  ctx_->NotifyEntityChanged();
  return true;
}
 
bool ItemInteractionHandler::MutateItemType(size_t index, uint8_t new_type) {
  if (!HasValidContext()) {
    return false;
  }
  auto* room = GetCurrentRoom();
  if (!room || index >= room->GetPotItems().size()) {
    return false;
  }
  auto& item = room->GetPotItems()[index];
  if (item.item == new_type || item.position == 0xFFFF) {
    return false;
  }
  // The ROM position is a tilemap byte offset with layer/control bits, not
  // two independent pixel-coordinate bytes. A type-only edit must preserve it
  // exactly, including fields outside the current position editor's subset.
  ctx_->NotifyMutation(MutationDomain::kItems);
  item.item = new_type;
  room->MarkPotItemsDirty();
  ctx_->NotifyInvalidateCache(MutationDomain::kItems);
  ctx_->NotifyEntityChanged();
  return true;
}
 
bool ItemInteractionHandler::UpdateItem(size_t index, uint8_t type, int pixel_x,
                                        int pixel_y) {
  if (!HasValidContext()) {
    return false;
  }
  auto* room = GetCurrentRoom();
  if (!room || index >= room->GetPotItems().size()) {
    return false;
  }
  auto& item = room->GetPotItems()[index];
  if (pixel_x == item.GetPixelX() && pixel_y == item.GetPixelY()) {
    return MutateItemType(index, type);
  }
  const auto encoded =
      zelda3::EncodePotItemPosition(pixel_x, pixel_y, item.position);
  if (!encoded)
    return false;
  const uint16_t position = *encoded;
  if (item.item == type && item.position == position) {
    return false;
  }
  ctx_->NotifyMutation(MutationDomain::kItems);
  item.item = type;
  item.position = position;
  room->MarkPotItemsDirty();
  ctx_->NotifyInvalidateCache(MutationDomain::kItems);
  ctx_->NotifyEntityChanged();
  return true;
}
 
bool ItemInteractionHandler::PreflightPlacement(
    const std::vector<zelda3::PotItem>& candidate) {
  if (!item_placement_preflight_) {
    return true;
  }
  const auto* source_context = ctx_;
  const int room_id = ctx_->current_room_id;
  const auto* source_room = GetCurrentRoom();
  mutation_status_ = item_placement_preflight_(room_id, candidate);
  if (mutation_status_.ok() &&
      (ctx_ != source_context || !HasValidContext() ||
       ctx_->current_room_id != room_id || GetCurrentRoom() != source_room)) {
    mutation_status_ = absl::FailedPreconditionError(
        "Pot-item room changed during placement preflight; repeat the "
        "placement");
  }
  if (!mutation_status_.ok() && mutation_error_callback_) {
    mutation_error_callback_(mutation_status_);
  }
  return mutation_status_.ok();
}
 
void ItemInteractionHandler::PlaceItemAtPosition(int canvas_x, int canvas_y) {
  mutation_status_ = absl::OkStatus();
  if (!HasValidContext())
    return;
 
  auto* room = GetCurrentRoom();
  if (!room)
    return;
 
  const auto encoded =
      zelda3::EncodePotItemPosition(std::clamp(canvas_x, 0, 511) / 8 * 8,
                                    std::clamp(canvas_y, 0, 511) / 8 * 8);
  if (!encoded)
    return;
  zelda3::PotItem new_item;
  new_item.position = *encoded;
  new_item.item = preview_item_id_;
 
  auto candidate = room->GetPotItems();
  candidate.push_back(new_item);
  if (!PreflightPlacement(candidate)) {
    return;
  }
  room = GetCurrentRoom();
  ctx_->NotifyMutation(MutationDomain::kItems);
  room->GetPotItems() = std::move(candidate);
  room->MarkPotItemsDirty();
 
  ctx_->NotifyInvalidateCache(MutationDomain::kItems);
}
 
}  // namespace yaze::editor