object_selector_content.cc

Go to the documentation of this file.

// Related header
#include "object_selector_content.h"
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <initializer_list>
#include <memory>
#include <string>
#include <vector>
#include "util/i18n/tr.h"
 
// Third-party library headers
#include "absl/strings/str_format.h"
#include "editor/dungeon/dungeon_canvas_viewer.h"
#include "gfx/types/snes_palette.h"
#include "imgui/imgui.h"
 
// Project headers
#include "app/editor/agent/agent_ui_theme.h"
#include "app/editor/dungeon/dungeon_selection_snapshot.h"
#include "app/editor/dungeon/interaction/ghost_preview_feedback.h"
#include "app/editor/shell/feedback/toast_manager.h"
#include "app/gui/core/icons.h"
#include "app/gui/widgets/themed_widgets.h"
#include "rom/rom.h"
#include "zelda3/dungeon/dungeon_limits.h"
#include "zelda3/dungeon/dungeon_object_editor.h"
#include "zelda3/dungeon/dungeon_validator.h"
#include "zelda3/dungeon/object_layer_semantics.h"
#include "zelda3/dungeon/room_object.h"
 
namespace yaze {
namespace editor {
 
namespace {
 
struct UsageChip {
  const char* icon = "";
  std::string value;
  ImVec4 color;
};
 
void DrawInlineInspectButton(const std::function<void()>& callback) {
  if (!callback) {
    return;
  }
 
  const char* label = ICON_MD_OPEN_IN_NEW " Inspect";
  const ImGuiStyle& style = ImGui::GetStyle();
  const float button_width =
      ImGui::CalcTextSize(label).x + style.FramePadding.x * 2.0f;
  const float next_x =
      ImGui::GetItemRectMax().x + style.ItemSpacing.x + button_width;
  const float line_right =
      ImGui::GetWindowPos().x + ImGui::GetWindowContentRegionMax().x;
  if (next_x <= line_right) {
    ImGui::SameLine();
  }
  if (ImGui::SmallButton(label)) {
    callback();
  }
}
 
void DrawUsageChips(std::initializer_list<UsageChip> chips) {
  if (chips.size() == 0) {
    return;
  }
 
  const int columns = ImGui::GetContentRegionAvail().x < 330.0f ? 2 : 4;
  constexpr ImGuiTableFlags kFlags =
      ImGuiTableFlags_SizingStretchSame | ImGuiTableFlags_NoPadOuterX;
  if (!ImGui::BeginTable("##ObjectSelectorUsageChips", columns, kFlags)) {
    return;
  }
 
  for (const UsageChip& chip : chips) {
    ImGui::TableNextColumn();
    ImGui::TextColored(chip.color, "%s %s", chip.icon, chip.value.c_str());
  }
  ImGui::EndTable();
}
 
}  // namespace
 
ObjectSelectorContent::ObjectSelectorContent(
    Rom* rom, DungeonCanvasViewer* canvas_viewer,
    std::shared_ptr<zelda3::DungeonObjectEditor> object_editor,
    ToastManager* toast_manager)
    : rom_(rom),
      canvas_viewer_(canvas_viewer),
      object_selector_(rom),
      object_editor_(object_editor),
      toast_manager_(toast_manager) {
  // Wire up object selector callback
  object_selector_.SetObjectSelectedCallback(
      [this](const zelda3::RoomObject& obj) {
        preview_object_ = obj;
        has_preview_object_ = true;
        if (canvas_viewer_) {
          canvas_viewer_->SetPreviewObject(preview_object_);
          canvas_viewer_->SetObjectInteractionEnabled(true);
        }
 
        // Sync with backend editor if available
        if (object_editor_) {
          object_editor_->SetMode(zelda3::DungeonObjectEditor::Mode::kInsert);
          object_editor_->SetCurrentObjectType(obj.id_);
        }
      });
  object_selector_.SetPlacementInvalidatedCallback(
      [this]() { CancelPlacement(); });
}
 
DungeonCanvasViewer* ObjectSelectorContent::ResolveCanvasViewer() {
  if (canvas_viewer_provider_) {
    canvas_viewer_ = canvas_viewer_provider_();
  }
  return canvas_viewer_;
}
 
void ObjectSelectorContent::Draw(bool* p_open) {
  (void)p_open;
  DrawContent(true);
}
 
bool ObjectSelectorContent::DrawMinecartPalette() {
  ResolveCanvasViewer();
  return object_selector_.DrawMinecartPalette();
}
 
void ObjectSelectorContent::DrawInWorkbench() {
  DrawContent(false);
}
 
void ObjectSelectorContent::DrawContent(bool show_placement_summary) {
  ResolveCanvasViewer();
 
  const int max_objects = static_cast<int>(zelda3::kMaxTileObjects);
  const int max_sprites = static_cast<int>(zelda3::kMaxTotalSprites);
  const int max_doors = static_cast<int>(zelda3::kMaxDoors);
 
  // Check if placement was blocked by ROM limits
  if (canvas_viewer_) {
    auto& coordinator =
        canvas_viewer_->object_interaction().entity_coordinator();
 
    auto& tile_handler = coordinator.tile_handler();
    if (tile_handler.was_placement_blocked()) {
      const auto reason = tile_handler.placement_block_reason();
      tile_handler.clear_placement_blocked();
      switch (reason) {
        case TileObjectHandler::PlacementBlockReason::kObjectLimit:
          SetPlacementError(absl::StrFormat(
              "Object limit reached (%d max) - placement blocked",
              max_objects));
          break;
        case TileObjectHandler::PlacementBlockReason::kInvalidRoom:
          SetPlacementError("Invalid room target - placement blocked");
          break;
        case TileObjectHandler::PlacementBlockReason::kChestValidation:
          SetPlacementError(
              std::string(tile_handler.mutation_status().message()));
          break;
        case TileObjectHandler::PlacementBlockReason::kNone:
        default:
          SetPlacementError("Object placement blocked");
          break;
      }
    }
 
    auto& sprite_handler = coordinator.sprite_handler();
    if (sprite_handler.was_placement_blocked()) {
      const auto reason = sprite_handler.placement_block_reason();
      sprite_handler.clear_placement_blocked();
      switch (reason) {
        case SpriteInteractionHandler::PlacementBlockReason::kSpriteLimit:
          SetPlacementError(absl::StrFormat(
              "Sprite limit reached (%d max) - placement blocked",
              max_sprites));
          break;
        case SpriteInteractionHandler::PlacementBlockReason::kInvalidRoom:
          SetPlacementError("Invalid room target - sprite placement blocked");
          break;
        case SpriteInteractionHandler::PlacementBlockReason::kStorageValidation:
          SetPlacementError(
              std::string(sprite_handler.mutation_status().message()));
          break;
        case SpriteInteractionHandler::PlacementBlockReason::kNone:
        default:
          SetPlacementError("Sprite placement blocked");
          break;
      }
    }
 
    auto& door_handler = coordinator.door_handler();
    if (door_handler.was_placement_blocked()) {
      const auto reason = door_handler.placement_block_reason();
      door_handler.clear_placement_blocked();
      switch (reason) {
        case DoorInteractionHandler::PlacementBlockReason::kDoorLimit:
          SetPlacementError(absl::StrFormat(
              "Door limit reached (%d max) - placement blocked", max_doors));
          break;
        case DoorInteractionHandler::PlacementBlockReason::kInvalidPosition:
          SetPlacementError("Invalid door position - must be near a wall");
          break;
        case DoorInteractionHandler::PlacementBlockReason::kInvalidRoom:
          SetPlacementError("Invalid room target - door placement blocked");
          break;
        case DoorInteractionHandler::PlacementBlockReason::kStorageValidation:
          SetPlacementError(
              std::string(door_handler.mutation_status().message()));
          break;
        case DoorInteractionHandler::PlacementBlockReason::kNone:
        default:
          SetPlacementError("Door placement blocked");
          break;
      }
    }
  }
 
  DrawInteractionSummary(show_placement_summary);
  if (show_placement_summary)
    DrawObjectSelector();
  else
    object_selector_.DrawWorkbenchBrowser();
}
 
void ObjectSelectorContent::SelectObject(int obj_id) {
  object_selector_.SelectObject(obj_id);
}
 
void ObjectSelectorContent::SetAgentOptimizedLayout(bool enabled) {
  // In agent mode, we might force tabs open or change layout
  (void)enabled;
}
 
void ObjectSelectorContent::SetPlacementError(const std::string& message) {
  // Avoid refreshing the timer for repeated identical errors; keeps the
  // message stable during rapid blocked clicks.
  if (message == last_placement_error_ && placement_error_time_ >= 0.0) {
    double elapsed = ImGui::GetTime() - placement_error_time_;
    if (elapsed < kPlacementErrorDuration) {
      return;
    }
  }
  last_placement_error_ = message;
  placement_error_time_ = ImGui::GetTime();
  if (toast_manager_) {
    toast_manager_->Show(message, ToastType::kError, 4.0f);
  }
}
 
void ObjectSelectorContent::DrawObjectSelector(float minimum_grid_height) {
  // Delegate to the DungeonObjectSelector component
  object_selector_.DrawObjectAssetBrowser(minimum_grid_height);
}
 
void ObjectSelectorContent::DrawInteractionSummary(
    bool show_placement_summary) {
  const auto& theme = AgentUI::GetTheme();
  auto* viewer = ResolveCanvasViewer();
  const auto snapshot = viewer != nullptr
                            ? BuildDungeonSelectionSnapshot(
                                  viewer->object_interaction(), viewer->rooms(),
                                  viewer->current_room_id())
                            : DungeonSelectionSnapshot{};
 
  bool drew_primary_status = false;
  if (!last_placement_error_.empty()) {
    double elapsed = ImGui::GetTime() - placement_error_time_;
    if (!toast_manager_ && elapsed < kPlacementErrorDuration) {
      ImGui::TextColored(theme.status_error, ICON_MD_WARNING " %s",
                         last_placement_error_.c_str());
      drew_primary_status = true;
    } else if (elapsed >= kPlacementErrorDuration) {
      last_placement_error_.clear();
    }
  }
 
  const auto* preview =
      viewer ? viewer->object_interaction().GetPlacementPreview() : nullptr;
  const bool is_placing = preview != nullptr;
  if (!is_placing && has_preview_object_) {
    has_preview_object_ = false;
  }
 
  if (is_placing && show_placement_summary) {
    if (drew_primary_status) {
      ImGui::Spacing();
    }
    ImGui::TextColored(theme.status_warning,
                       ICON_MD_ADD_CIRCLE " Queued 0x%03X %s", preview->id_,
                       zelda3::GetObjectName(preview->id_).c_str());
    const char* cancel_label = ICON_MD_CANCEL " Cancel";
    const float cancel_width = ImGui::CalcTextSize(cancel_label).x +
                               ImGui::GetStyle().FramePadding.x * 2.0f;
    const float next_x = ImGui::GetItemRectMax().x +
                         ImGui::GetStyle().ItemSpacing.x + cancel_width;
    const float line_right =
        ImGui::GetWindowPos().x + ImGui::GetWindowContentRegionMax().x;
    if (next_x <= line_right) {
      ImGui::SameLine();
    }
    if (ImGui::SmallButton(cancel_label)) {
      CancelPlacement();
    }
    drew_primary_status = true;
  }
 
  // Capacity and validation detail belongs in the wider standalone picker.
  // A full-height inspector is still narrow, so preserve that space for the
  // object grid while keeping placement and error feedback visible above.
  const ImVec2 available = ImGui::GetContentRegionAvail();
  const bool show_secondary_status =
      available.x >= 420.0f && available.y >= 260.0f;
  if (!is_placing && show_secondary_status &&
      snapshot.kind == DungeonSelectionKind::ObjectSingle) {
    ImGui::TextColored(theme.status_success,
                       ICON_MD_CHECK_CIRCLE " 1 object selected");
    DrawInlineInspectButton(open_object_editor_callback_);
  } else if (!is_placing && show_secondary_status &&
             snapshot.kind == DungeonSelectionKind::ObjectMulti) {
    ImGui::TextColored(theme.status_success,
                       ICON_MD_SELECT_ALL " %zu objects selected",
                       snapshot.count);
    DrawInlineInspectButton(open_object_editor_callback_);
  } else if (!is_placing && show_secondary_status &&
             (snapshot.kind == DungeonSelectionKind::Door ||
              snapshot.kind == DungeonSelectionKind::Sprite ||
              snapshot.kind == DungeonSelectionKind::Item)) {
    ImGui::TextColored(theme.status_success,
                       ICON_MD_MANAGE_SEARCH " 1 %s selected",
                       GetDungeonSelectionKindLabel(snapshot.kind));
    DrawInlineInspectButton(open_object_editor_callback_);
  } else if (!is_placing && show_secondary_status &&
             (snapshot.kind == DungeonSelectionKind::EntityMulti ||
              snapshot.kind == DungeonSelectionKind::Mixed)) {
    ImGui::TextColored(theme.status_success, ICON_MD_SELECT_ALL " %s",
                       GetDungeonSelectionSummaryText(snapshot).c_str());
    DrawInlineInspectButton(open_object_editor_callback_);
  }
 
  if (!show_secondary_status) {
    return;
  }
 
  auto* rooms = object_selector_.get_rooms();
  if (rooms && current_room_id_ >= 0 &&
      current_room_id_ < zelda3::kNumberOfRooms) {
    const auto& room = (*rooms)[current_room_id_];
    size_t object_count = room.GetTileObjects().size();
    size_t sprite_count = room.GetSprites().size();
    size_t door_count = room.GetDoors().size();
    int chest_count = 0;
    for (const auto& obj : room.GetTileObjects()) {
      if (zelda3::UsesRoomObjectStream(obj) &&
          zelda3::IsStatefulChestObjectId(obj.id_)) {
        chest_count++;
      }
    }
 
    const int kMaxObjects = static_cast<int>(zelda3::kMaxTileObjects);
    const int kMaxSprites = static_cast<int>(zelda3::kMaxTotalSprites);
    const int kMaxDoors = static_cast<int>(zelda3::kMaxDoors);
    const int kMaxChests = static_cast<int>(zelda3::kMaxChests);
 
    auto usage_color = [&](size_t count, int max_val,
                           bool exact_capacity_warning) -> ImVec4 {
      if (exact_capacity_warning) {
        return GetPlacementSummaryColor(theme, count, max_val,
                                        theme.text_secondary_gray);
      }
      float ratio = static_cast<float>(count) / static_cast<float>(max_val);
      if (ratio >= 1.0f) {
        return theme.status_error;
      }
      if (ratio >= 0.75f) {
        return theme.status_warning;
      }
      return theme.text_secondary_gray;
    };
 
    zelda3::DungeonValidator validator;
    auto result = validator.ValidateRoom(room);
 
    ImGui::Spacing();
    DrawUsageChips(
        {{ICON_MD_WIDGETS, absl::StrFormat("%zu/%d", object_count, kMaxObjects),
          usage_color(object_count, kMaxObjects, true)},
         {ICON_MD_PEST_CONTROL,
          absl::StrFormat("%zu/%d", sprite_count, kMaxSprites),
          usage_color(sprite_count, kMaxSprites, true)},
         {ICON_MD_DOOR_FRONT, absl::StrFormat("%zu/%d", door_count, kMaxDoors),
          usage_color(door_count, kMaxDoors, true)},
         {ICON_MD_INVENTORY_2,
          absl::StrFormat("%d/%d", chest_count, kMaxChests),
          usage_color(chest_count, kMaxChests, false)}});
 
    if (!result.errors.empty() || !result.warnings.empty()) {
      ImGui::TextColored(
          result.errors.empty() ? theme.status_warning : theme.status_error,
          tr("%s %zu issue%s"),
          result.errors.empty() ? ICON_MD_WARNING : ICON_MD_ERROR,
          result.errors.size() + result.warnings.size(),
          (result.errors.size() + result.warnings.size()) == 1 ? "" : "s");
      if (ImGui::IsItemHovered()) {
        ImGui::BeginTooltip();
        for (const auto& err : result.errors) {
          ImGui::TextColored(theme.status_error, ICON_MD_ERROR " %s",
                             err.c_str());
        }
        for (const auto& warn : result.warnings) {
          ImGui::TextColored(theme.status_warning, ICON_MD_WARNING " %s",
                             warn.c_str());
        }
        ImGui::EndTooltip();
      }
    }
  }
}
 
void ObjectSelectorContent::CancelPlacement() {
  has_preview_object_ = false;
  if (canvas_viewer_) {
    canvas_viewer_->ClearPreviewObject();
    canvas_viewer_->object_interaction().CancelPlacement();
  }
}
 
void ObjectSelectorContent::DetachRuntimeContext() {
  CancelPlacement();
  canvas_viewer_ = nullptr;
  canvas_viewer_provider_ = {};
  open_object_editor_callback_ = {};
  rom_ = nullptr;
  object_editor_.reset();
  object_selector_.DetachRuntimeContext();
}
 
}  // namespace editor
}  // namespace yaze