sprite_interaction_handler.cc

Go to the documentation of this file.

// Related header
#include "sprite_interaction_handler.h"
#include "util/i18n/tr.h"
 
// C++ standard library
#include <algorithm>
#include <cstdint>
 
// 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"
#include "zelda3/dungeon/dungeon_limits.h"
 
namespace yaze::editor {
 
SpriteInteractionHandler::GhostCapacityState
SpriteInteractionHandler::GetPlacementGhostCapacityState() const {
  auto* room = GetCurrentRoom();
  const size_t current_sprite_count = room ? room->GetSprites().size() : 0;
  return GetPlacementCapacityState(current_sprite_count,
                                   zelda3::kMaxTotalSprites);
}
 
void SpriteInteractionHandler::BeginPlacement() {
  sprite_placement_mode_ = true;
  ClearSelection();
}
 
bool SpriteInteractionHandler::HandleClick(int canvas_x, int canvas_y) {
  if (!HasValidContext())
    return false;
 
  if (sprite_placement_mode_) {
    if (IsWithinBounds(canvas_x, canvas_y)) {
      PlaceSpriteAtPosition(canvas_x, canvas_y);
    }
    return true;
  }
 
  // Try to select sprite at position
  auto sprite_index = GetEntityAtPosition(canvas_x, canvas_y);
  if (sprite_index.has_value()) {
    SelectSprite(*sprite_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 SpriteInteractionHandler::HandleDrag(ImVec2 current_pos, ImVec2 delta) {
  if (!is_dragging_ || !selected_sprite_index_.has_value())
    return;
  drag_current_pos_ = current_pos;
}
 
void SpriteInteractionHandler::HandleRelease() {
  if (!is_dragging_ || !selected_sprite_index_.has_value()) {
    is_dragging_ = false;
    return;
  }
 
  auto* room = GetCurrentRoom();
  if (!room) {
    is_dragging_ = false;
    return;
  }
 
  // Convert to sprite coordinates (16-pixel units)
  auto [tile_x, tile_y] =
      CanvasToSpriteCoords(static_cast<int>(drag_current_pos_.x),
                           static_cast<int>(drag_current_pos_.y));
 
  // Clamp to valid range (sprites use 0-31 range)
  tile_x = std::clamp(tile_x, 0, dungeon_coords::kSpriteGridMax);
  tile_y = std::clamp(tile_y, 0, dungeon_coords::kSpriteGridMax);
 
  const auto& sprites = room->GetSprites();
  if (*selected_sprite_index_ < sprites.size()) {
    const auto& sprite = sprites[*selected_sprite_index_];
    UpdateSprite(*selected_sprite_index_, sprite.id(), tile_x, tile_y,
                 sprite.subtype(), sprite.layer(), sprite.key_drop());
  }
 
  is_dragging_ = false;
}
 
void SpriteInteractionHandler::DrawGhostPreview() {
  if (!sprite_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 16-pixel grid
  int snapped_x = (canvas_x / dungeon_coords::kSpriteTileSize) *
                  dungeon_coords::kSpriteTileSize;
  int snapped_y = (canvas_y / dungeon_coords::kSpriteTileSize) *
                  dungeon_coords::kSpriteTileSize;
 
  auto* room = GetCurrentRoom();
  const size_t current_sprite_count = room ? room->GetSprites().size() : 0;
  const auto capacity_state = GetPlacementGhostCapacityState();
 
  // Draw ghost rectangle for sprite 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(dungeon_coords::kSpriteTileSize, dungeon_coords::kSpriteTileSize));
  const ImVec2 rect_max(rect_min.x + rect_size.x, rect_min.y + rect_size.y);
 
  const auto& theme = AgentUI::GetTheme();
  const ImVec4 base_color =
      GetPlacementAccentColor(theme, capacity_state, theme.status_success);
  ImVec4 fill_color = base_color;
  fill_color.w = 0.40f;
  ImVec4 outline_color = base_color;
  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 sprite ID label
  std::string label = absl::StrFormat("%02X", preview_sprite_id_);
  canvas->draw_list()->AddText(rect_min, ImGui::GetColorU32(theme.text_primary),
                               label.c_str());
 
  // Capacity tooltip when at/near limit
  if (capacity_state != GhostCapacityState::kNormal &&
      ImGui::IsMouseHoveringRect(rect_min, rect_max)) {
    ImGui::SetTooltip(tr("Sprites: %zu/%zu\n%s"), current_sprite_count,
                      zelda3::kMaxTotalSprites,
                      GetPlacementCapacityTooltipSuffix(capacity_state).data());
  }
 
  const std::string badge_text = absl::StrFormat(
      "Sprites %zu/%zu", current_sprite_count, zelda3::kMaxTotalSprites);
  DrawPlacementCapacityBadge(canvas->draw_list(),
                             ImVec2(rect_min.x, rect_max.y + 6.0f), theme,
                             capacity_state, badge_text);
}
 
void SpriteInteractionHandler::DrawSelectionHighlight() {
  if (!selected_sprite_index_.has_value() || !HasValidContext())
    return;
 
  auto* room = GetCurrentRoom();
  if (!room)
    return;
 
  const auto& sprites = room->GetSprites();
  if (*selected_sprite_index_ >= sprites.size())
    return;
 
  const auto& sprite = sprites[*selected_sprite_index_];
 
  // Sprites use 16-pixel coordinate system
  int pixel_x = sprite.x() * dungeon_coords::kSpriteTileSize;
  int pixel_y = sprite.y() * dungeon_coords::kSpriteTileSize;
 
  // If dragging, use current drag position (snapped to 16-pixel grid)
  if (is_dragging_) {
    auto [tile_x, tile_y] =
        CanvasToSpriteCoords(static_cast<int>(drag_current_pos_.x),
                             static_cast<int>(drag_current_pos_.y));
    tile_x = std::clamp(tile_x, 0, dungeon_coords::kSpriteGridMax);
    tile_y = std::clamp(tile_y, 0, dungeon_coords::kSpriteGridMax);
    pixel_x = tile_x * dungeon_coords::kSpriteTileSize;
    pixel_y = tile_y * dungeon_coords::kSpriteTileSize;
  }
 
  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(dungeon_coords::kSpriteTileSize, dungeon_coords::kSpriteTileSize));
 
  // 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(0, 255, 0, 180);  // Green
  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), "Sprite");
}
 
std::optional<size_t> SpriteInteractionHandler::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 sprites (16x16 hitbox)
  const auto& sprites = room->GetSprites();
  for (size_t i = 0; i < sprites.size(); ++i) {
    const auto& sprite = sprites[i];
 
    // Sprites use 16-pixel coordinate system
    int sprite_x = sprite.x() * dungeon_coords::kSpriteTileSize;
    int sprite_y = sprite.y() * dungeon_coords::kSpriteTileSize;
 
    // 16x16 hitbox
    if (canvas_x >= sprite_x &&
        canvas_x < sprite_x + dungeon_coords::kSpriteTileSize &&
        canvas_y >= sprite_y &&
        canvas_y < sprite_y + dungeon_coords::kSpriteTileSize) {
      return i;
    }
  }
 
  return std::nullopt;
}
 
void SpriteInteractionHandler::SelectSprite(size_t index) {
  selected_sprite_index_ = index;
  ctx_->NotifyEntityChanged();
}
 
void SpriteInteractionHandler::ClearSelection() {
  selected_sprite_index_ = std::nullopt;
  is_dragging_ = false;
}
 
bool SpriteInteractionHandler::PreflightSprites(
    const std::vector<zelda3::Sprite>& candidate) {
  mutation_status_ = absl::OkStatus();
  if (!sprite_mutation_preflight_) {
    return true;
  }
  const auto* source_context = ctx_;
  const int room_id = ctx_->current_room_id;
  const auto* source_room = GetCurrentRoom();
  mutation_status_ = sprite_mutation_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(
        "Sprite room changed during edit preflight; repeat the edit");
  }
  if (!mutation_status_.ok() && mutation_error_callback_) {
    mutation_error_callback_(mutation_status_);
  }
  return mutation_status_.ok();
}
 
void SpriteInteractionHandler::DeleteSelected() {
  mutation_status_ = absl::OkStatus();
  if (!selected_sprite_index_.has_value() || !HasValidContext())
    return;
 
  auto* room = GetCurrentRoom();
  if (!room)
    return;
 
  auto candidate = room->GetSprites();
  if (*selected_sprite_index_ >= candidate.size())
    return;
 
  candidate.erase(candidate.begin() +
                  static_cast<ptrdiff_t>(*selected_sprite_index_));
  if (!PreflightSprites(candidate)) {
    return;
  }
  room = GetCurrentRoom();
  ctx_->NotifyMutation(MutationDomain::kSprites);
  room->GetSprites() = std::move(candidate);
  room->MarkSpritesDirty();
  ClearSelection();
  ctx_->NotifyInvalidateCache(MutationDomain::kSprites);
  ctx_->NotifyEntityChanged();
}
 
void SpriteInteractionHandler::DeleteAll() {
  mutation_status_ = absl::OkStatus();
  if (!HasValidContext()) {
    return;
  }
 
  auto* room = GetCurrentRoom();
  if (!room || room->GetSprites().empty()) {
    return;
  }
 
  if (!PreflightSprites({})) {
    return;
  }
  room = GetCurrentRoom();
  ctx_->NotifyMutation(MutationDomain::kSprites);
  room->GetSprites().clear();
  room->MarkSpritesDirty();
  ClearSelection();
  ctx_->NotifyInvalidateCache(MutationDomain::kSprites);
  ctx_->NotifyEntityChanged();
}
 
bool SpriteInteractionHandler::NudgeSelected(int delta_x, int delta_y) {
  mutation_status_ = absl::OkStatus();
  if (!selected_sprite_index_.has_value() || !HasValidContext()) {
    return false;
  }
 
  auto* room = GetCurrentRoom();
  if (!room) {
    return false;
  }
 
  auto& sprites = room->GetSprites();
  if (*selected_sprite_index_ >= sprites.size()) {
    return false;
  }
 
  auto& sprite = sprites[*selected_sprite_index_];
  const int64_t requested_x = static_cast<int64_t>(sprite.x()) + delta_x;
  const int64_t requested_y = static_cast<int64_t>(sprite.y()) + delta_y;
  const int next_x = static_cast<int>(
      std::clamp<int64_t>(requested_x, 0, dungeon_coords::kSpriteGridMax));
  const int next_y = static_cast<int>(
      std::clamp<int64_t>(requested_y, 0, dungeon_coords::kSpriteGridMax));
  if (next_x == sprite.x() && next_y == sprite.y()) {
    return false;
  }
 
  return UpdateSprite(*selected_sprite_index_, sprite.id(), next_x, next_y,
                      sprite.subtype(), sprite.layer(), sprite.key_drop());
}
 
absl::Status SpriteInteractionHandler::ValidateSpriteProperties(
    uint8_t id, int x, int y, int subtype, int layer, int key_drop) {
  if (x < 0 || x > 31 || y < 0 || y > 31 || subtype < 0 || subtype > 31 ||
      layer < 0 || layer > 1 || key_drop < 0 || key_drop > 2) {
    return absl::InvalidArgumentError(
        "Sprite fields are outside their ROM ranges");
  }
  // EncodeSprites writes Y, the high subtype bits and layer to the first
  // byte. 0xFF terminates the stream even when the remaining fields are valid.
  const int first_byte = y | ((subtype & 0x18) << 2) | (layer << 7);
  if (first_byte == 0xFF) {
    return absl::InvalidArgumentError(
        "Lower-layer sprites with subtype 24-31 cannot use Y 31: the ROM "
        "reads that encoding as the end of the sprite list");
  }
  // LoadSprites folds these exact records into the preceding sprite. Authors
  // should use its key-drop property instead of placing an ambiguous marker.
  if (id == 0xE4 && x == 0 && (y == 29 || y == 30) && subtype == 24 &&
      layer == 1) {
    return absl::InvalidArgumentError(
        "This E4 position/subtype/layer encodes a hidden key marker; use "
        "the owning sprite's Key drop property");
  }
  return absl::OkStatus();
}
 
bool SpriteInteractionHandler::UpdateSprite(size_t index, uint8_t id, int x,
                                            int y, int subtype, int layer,
                                            int key_drop) {
  mutation_status_ = absl::OkStatus();
  if (!HasValidContext() ||
      !ValidateSpriteProperties(id, x, y, subtype, layer, key_drop).ok()) {
    return false;
  }
  auto* room = GetCurrentRoom();
  if (!room || index >= room->GetSprites().size()) {
    return false;
  }
  const auto sprite = room->GetSprites()[index];
  if (sprite.id() == id && sprite.x() == x && sprite.y() == y &&
      sprite.subtype() == subtype && sprite.layer() == layer &&
      sprite.key_drop() == key_drop) {
    return false;
  }
  // Rebuild identity metadata and invalidate cached previews when changing
  // between ordinary sprites and overlords; raw setters leave those stale.
  zelda3::Sprite updated(id, static_cast<uint8_t>(x), static_cast<uint8_t>(y),
                         static_cast<uint8_t>(subtype),
                         static_cast<uint8_t>(layer));
  updated.set_key_drop(key_drop);
  updated.set_deleted(sprite.deleted());
  auto candidate = room->GetSprites();
  candidate[index] = std::move(updated);
  if (!PreflightSprites(candidate)) {
    return false;
  }
  room = GetCurrentRoom();
  ctx_->NotifyMutation(MutationDomain::kSprites);
  room->GetSprites() = std::move(candidate);
  room->MarkSpritesDirty();
  ctx_->NotifyInvalidateCache(MutationDomain::kSprites);
  ctx_->NotifyEntityChanged();
  return true;
}
 
void SpriteInteractionHandler::PlaceSpriteAtPosition(int canvas_x,
                                                     int canvas_y) {
  mutation_status_ = absl::OkStatus();
  if (!HasValidContext()) {
    placement_block_reason_ = PlacementBlockReason::kInvalidRoom;
    return;
  }
 
  auto* room = GetCurrentRoom();
  if (!room) {
    placement_block_reason_ = PlacementBlockReason::kInvalidRoom;
    return;
  }
 
  // Enforce sprite limit at placement time (matches DungeonValidator::kMaxTotalSprites).
  if (room->GetSprites().size() >= zelda3::kMaxTotalSprites) {
    placement_block_reason_ = PlacementBlockReason::kSpriteLimit;
    return;
  }
 
  placement_block_reason_ = PlacementBlockReason::kNone;
 
  auto [sprite_x, sprite_y] = CanvasToSpriteCoords(canvas_x, canvas_y);
 
  // Clamp to valid range
  sprite_x = std::clamp(sprite_x, 0, dungeon_coords::kSpriteGridMax);
  sprite_y = std::clamp(sprite_y, 0, dungeon_coords::kSpriteGridMax);
 
  // Create the sprite
  zelda3::Sprite new_sprite(preview_sprite_id_, static_cast<uint8_t>(sprite_x),
                            static_cast<uint8_t>(sprite_y), 0, 0);
  auto candidate = room->GetSprites();
  candidate.push_back(std::move(new_sprite));
  if (!PreflightSprites(candidate)) {
    placement_block_reason_ = PlacementBlockReason::kStorageValidation;
    return;
  }
  room = GetCurrentRoom();
  ctx_->NotifyMutation(MutationDomain::kSprites);
 
  // Add sprite to room
  room->GetSprites() = std::move(candidate);
  room->MarkSpritesDirty();
  TriggerSuccessToast();
 
  ctx_->NotifyInvalidateCache(MutationDomain::kSprites);
}
 
std::pair<int, int> SpriteInteractionHandler::CanvasToSpriteCoords(
    int canvas_x, int canvas_y) const {
  return {canvas_x / dungeon_coords::kSpriteTileSize,
          canvas_y / dungeon_coords::kSpriteTileSize};
}
 
}  // namespace yaze::editor