dungeon_room_selector.cc

Go to the documentation of this file.

#include "dungeon_room_selector.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
#include <map>
 
#include "absl/strings/str_format.h"
#include "app/editor/core/content_registry.h"
#include "app/editor/dungeon/dungeon_entrance_edit_policy.h"
#include "app/editor/dungeon/dungeon_project_labels.h"
#include "app/editor/events/core_events.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/input.h"
#include "app/gui/core/layout_helpers.h"
#include "app/gui/core/style_guard.h"
#include "imgui/imgui.h"
#include "util/hex.h"
#include "zelda3/dungeon/dungeon_rom_addresses.h"
#include "zelda3/dungeon/room.h"
#include "zelda3/dungeon/room_entrance.h"
#include "zelda3/dungeon/room_layer_manager.h"
#include "zelda3/resource_labels.h"
 
namespace yaze::editor {
 
using ImGui::BeginChild;
using ImGui::EndChild;
using ImGui::SameLine;
 
void DungeonRoomSelector::Draw() {
  // Legacy combined view - prefer using DrawRoomSelector() and
  // DrawEntranceSelector() separately via their own EditorPanels
  DrawRoomSelector();
}
 
void DungeonRoomSelector::DrawRoomSelector(
    RoomSelectionIntent single_click_intent) {
  DrawRoomSelectorInternal(single_click_intent, true);
}
 
void DungeonRoomSelector::DrawRoomBrowser(
    RoomSelectionIntent single_click_intent) {
  DrawRoomSelectorInternal(single_click_intent, false);
}
 
void DungeonRoomSelector::RebuildRoomFilterCache() {
  filtered_room_indices_.clear();
  filtered_room_indices_.reserve(zelda3::kNumberOfRooms);
 
  for (int i = 0; i < zelda3::kNumberOfRooms; ++i) {
    std::string display_name =
        dungeon_project_labels::GetRoomLabel(project_, i);
    if (room_filter_.PassFilter(display_name.c_str()) &&
        PassesEntityTypeFilter(i)) {
      filtered_room_indices_.push_back(i);
    }
  }
}
 
bool DungeonRoomSelector::PassesEntityTypeFilter(int room_id) const {
  if (entity_type_filter_ == kFilterAll)
    return true;
  if (!rooms_ || room_id < 0 || room_id >= static_cast<int>(rooms_->size())) {
    return true;
  }
  const auto* room = rooms_->GetIfLoaded(room_id);
  if (room == nullptr) {
    return false;
  }
  switch (entity_type_filter_) {
    case kFilterHasSprites:
      return !room->GetSprites().empty();
    case kFilterHasItems:
      return !room->GetPotItems().empty();
    case kFilterHasObjects:
      return !room->GetTileObjects().empty();
    default:
      return true;
  }
}
 
void DungeonRoomSelector::DrawRoomSelectorInternal(
    RoomSelectionIntent single_click_intent, bool show_room_id_input) {
  if (!rom_ || !rom_->is_loaded()) {
    ImGui::Text(tr("ROM not loaded"));
    return;
  }
 
  if (show_room_id_input) {
    if (gui::InputHexWord("Room ID", &current_room_id_, 50.f, true)) {
      if (current_room_id_ >= zelda3::kNumberOfRooms) {
        current_room_id_ = static_cast<uint16_t>(zelda3::kNumberOfRooms - 1);
      }
 
      // Publish selection changed event
      if (auto* bus = ContentRegistry::Context::event_bus()) {
        bus->Publish(SelectionChangedEvent::CreateSingle("dungeon_room",
                                                         current_room_id_));
      }
 
      // Callback support
      if (room_selected_callback_) {
        room_selected_callback_(current_room_id_);
      }
    }
    ImGui::Separator();
  }
 
  room_filter_.Draw("Filter", ImGui::GetContentRegionAvail().x);
 
  // View mode + entity-type filter row
  {
    // View mode toggle
    if (ImGui::SmallButton(view_mode_ == kViewList ? ICON_MD_LIST " List"
                                                   : ICON_MD_FOLDER
                               " Grouped")) {
      view_mode_ = (view_mode_ == kViewList) ? kViewGrouped : kViewList;
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(
          tr("Toggle between flat list and dungeon-grouped view"));
    }
    ImGui::SameLine(0, 12);
 
    // Entity-type filter chips (compact, touch-friendly)
    const char* labels[] = {"All", "Sprites", "Items", "Objects"};
    const EntityTypeFilter values[] = {kFilterAll, kFilterHasSprites,
                                       kFilterHasItems, kFilterHasObjects};
    for (int idx = 0; idx < 4; ++idx) {
      if (idx > 0)
        ImGui::SameLine();
      bool selected = (entity_type_filter_ == values[idx]);
      if (selected) {
        ImGui::PushStyleColor(ImGuiCol_Button,
                              ImGui::GetStyleColorVec4(ImGuiCol_ButtonActive));
      }
      if (ImGui::SmallButton(labels[idx])) {
        entity_type_filter_ = values[idx];
      }
      if (selected) {
        ImGui::PopStyleColor();
      }
    }
  }
 
  // Rebuild every frame so renamed room labels appear immediately.
  std::string current_filter(room_filter_.InputBuf);
  if (current_filter != last_room_filter_) {
    last_room_filter_ = current_filter;
  }
  RebuildRoomFilterCache();
 
  // Increase row height on touch devices for easier tapping
  const bool is_touch = gui::LayoutHelpers::IsTouchDevice();
  std::optional<gui::StyleVarGuard> touch_pad_guard;
  if (is_touch) {
    float touch_pad = std::max(
        6.0f, (gui::LayoutHelpers::GetMinTouchTarget() - ImGui::GetFontSize()) *
                  0.5f);
    touch_pad_guard.emplace(ImGuiStyleVar_CellPadding,
                            ImVec2(ImGui::GetStyle().CellPadding.x, touch_pad));
  }
 
  // Dispatch to appropriate view mode
  if (view_mode_ == kViewGrouped) {
    DrawGroupedRoomList(single_click_intent);
    return;
  }
 
  // === Flat list view (original) ===
  if (ImGui::BeginTable("RoomList", 2,
                        ImGuiTableFlags_ScrollY | ImGuiTableFlags_Borders |
                            ImGuiTableFlags_RowBg |
                            ImGuiTableFlags_Resizable)) {
    ImGui::TableSetupColumn("ID", ImGuiTableColumnFlags_WidthFixed, 40.0f);
    ImGui::TableSetupColumn("Name");
    ImGui::TableHeadersRow();
 
    // Use ImGuiListClipper for virtualized rendering
    ImGuiListClipper clipper;
    clipper.Begin(static_cast<int>(filtered_room_indices_.size()));
 
    while (clipper.Step()) {
      for (int row = clipper.DisplayStart; row < clipper.DisplayEnd; ++row) {
        int room_id = filtered_room_indices_[row];
        std::string display_name =
            dungeon_project_labels::GetRoomLabel(project_, room_id);
 
        ImGui::TableNextRow();
        ImGui::TableNextColumn();
 
        char label[32];
        snprintf(label, sizeof(label), "%03X", room_id);
        if (ImGui::Selectable(label, current_room_id_ == room_id,
                              ImGuiSelectableFlags_SpanAllColumns |
                                  ImGuiSelectableFlags_AllowDoubleClick)) {
          current_room_id_ = room_id;
 
          // Publish selection changed event
          if (auto* bus = ContentRegistry::Context::event_bus()) {
            bus->Publish(
                SelectionChangedEvent::CreateSingle("dungeon_room", room_id));
          }
 
          if (ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left)) {
            if (room_intent_callback_) {
              room_intent_callback_(room_id,
                                    RoomSelectionIntent::kOpenStandalone);
            } else if (room_selected_callback_) {
              room_selected_callback_(room_id);
            }
          } else {
            if (room_intent_callback_) {
              room_intent_callback_(room_id, single_click_intent);
            } else if (room_selected_callback_) {
              room_selected_callback_(room_id);
            }
          }
        }
 
        // Context menu
        if (ImGui::BeginPopupContextItem()) {
          if (ImGui::MenuItem(tr("Open in Workbench"))) {
            current_room_id_ = room_id;
            if (room_intent_callback_) {
              room_intent_callback_(room_id,
                                    RoomSelectionIntent::kFocusInWorkbench);
            } else if (room_selected_callback_) {
              room_selected_callback_(room_id);
            }
          }
          if (ImGui::MenuItem(tr("Open as Panel"))) {
            current_room_id_ = room_id;
            if (room_intent_callback_) {
              room_intent_callback_(room_id,
                                    RoomSelectionIntent::kOpenStandalone);
            } else if (room_selected_callback_) {
              room_selected_callback_(room_id);
            }
          }
          ImGui::Separator();
          char id_buf[16];
          snprintf(id_buf, sizeof(id_buf), "0x%03X", room_id);
          if (ImGui::MenuItem(tr("Copy Room ID"))) {
            ImGui::SetClipboardText(id_buf);
          }
          ImGui::EndPopup();
        }
 
        // Tooltip with room name and thumbnail
        if (ImGui::IsItemHovered()) {
          ImGui::BeginTooltip();
          ImGui::Text("%s", display_name.c_str());
          if (rooms_) {
            auto* loaded_room = rooms_->GetIfLoaded(room_id);
            if (loaded_room != nullptr) {
              ImGui::TextDisabled(tr("Blockset: %d | Palette: %d"),
                                  loaded_room->blockset(),
                                  loaded_room->palette());
              auto& room = *loaded_room;
              zelda3::RoomLayerManager layer_mgr;
              layer_mgr.ApplyLayerMerging(room.layer_merging());
              auto& bmp = room.GetCompositeBitmap(layer_mgr);
              if (bmp.is_active() && bmp.texture() != 0) {
                ImGui::Image((ImTextureID)(intptr_t)bmp.texture(),
                             ImVec2(64, 64));
              }
            }
          }
          ImGui::EndTooltip();
        }
 
        ImGui::TableNextColumn();
        ImGui::TextUnformatted(display_name.c_str());
      }
    }
 
    ImGui::EndTable();
  }
}
 
void DungeonRoomSelector::RebuildEntranceFilterCache() {
  constexpr int kNumSpawnPoints = zelda3::kNumDungeonSpawnPoints;
  constexpr int kNumEntrances = zelda3::kNumRegularDungeonEntrances;
  constexpr int kTotalEntries = zelda3::kNumDungeonEntranceSlots;
 
  filtered_entrance_indices_.clear();
  filtered_entrance_indices_.reserve(kTotalEntries);
 
  for (int i = 0; i < kTotalEntries; i++) {
    std::string display_name;
 
    if (i < kNumSpawnPoints) {
      display_name = absl::StrFormat("Spawn Point %d", i);
    } else {
      int entrance_id = i - kNumSpawnPoints;
      if (entrance_id < kNumEntrances) {
        display_name = zelda3::GetEntranceLabel(entrance_id);
      } else {
        display_name = absl::StrFormat("Unknown Entrance %d", i);
      }
    }
 
    int room_id = (entrances_ && i < static_cast<int>(entrances_->size()))
                      ? (*entrances_)[i].room_
                      : 0;
 
    char filter_text[256];
    snprintf(filter_text, sizeof(filter_text), "%s %03X", display_name.c_str(),
             room_id);
 
    if (entrance_filter_.PassFilter(filter_text)) {
      filtered_entrance_indices_.push_back(i);
    }
  }
}
 
void DungeonRoomSelector::DrawEntranceSelector() {
  DrawEntranceSelectorInternal(true);
}
 
void DungeonRoomSelector::DrawEntranceBrowser() {
  DrawEntranceSelectorInternal(false);
}
 
void DungeonRoomSelector::DrawEntranceSelectorInternal(bool show_properties) {
  if (!rom_ || !rom_->is_loaded()) {
    ImGui::Text(tr("ROM not loaded"));
    return;
  }
 
  if (!entrances_) {
    ImGui::Text(tr("Entrances not loaded"));
    return;
  }
 
  if (show_properties) {
    if (current_entrance_id_ < 0 ||
        current_entrance_id_ >= static_cast<int>(entrances_->size())) {
      current_entrance_id_ = 0;
    }
    auto& current_entrance = (*entrances_)[current_entrance_id_];
    const bool properties_editable =
        CanEditDungeonEntrance(current_entrance_id_, current_entrance);
    bool changed = false;
 
    // Keep the full property editor in the standalone entrance panel.
    if (!properties_editable) {
      ImGui::TextWrapped(tr(kDungeonSpawnReadOnlyReason));
    }
    ImGui::BeginDisabled(!properties_editable);
    if (ImGui::BeginTable("EntranceProps", 4, ImGuiTableFlags_Borders)) {
      ImGui::TableSetupColumn("Core", ImGuiTableColumnFlags_WidthStretch);
      ImGui::TableSetupColumn("Position", ImGuiTableColumnFlags_WidthStretch);
      ImGui::TableSetupColumn("Camera", ImGuiTableColumnFlags_WidthStretch);
      ImGui::TableSetupColumn("Scroll", ImGuiTableColumnFlags_WidthStretch);
      ImGui::TableHeadersRow();
 
      ImGui::TableNextRow();
      ImGui::TableNextColumn();
      ImGui::Text(tr("Entr ID: %04X"), current_entrance.entrance_id_);
      changed |= gui::InputHexWord("Room ID", &current_entrance.room_);
      changed |= gui::InputHexByte("Dungeon", &current_entrance.dungeon_id_);
      changed |= gui::InputHexByte("Music", &current_entrance.music_);
 
      ImGui::TableNextColumn();
      changed |= gui::InputHexWord("Player X", &current_entrance.x_position_);
      changed |= gui::InputHexWord("Player Y", &current_entrance.y_position_);
      changed |= gui::InputHexByte("Blockset", &current_entrance.blockset_);
      changed |= gui::InputHexByte("Floor", &current_entrance.floor_);
 
      ImGui::TableNextColumn();
      changed |=
          gui::InputHexWord("Cam Trg X", &current_entrance.camera_trigger_x_);
      changed |=
          gui::InputHexWord("Cam Trg Y", &current_entrance.camera_trigger_y_);
      changed |= gui::InputHexWord("Exit", &current_entrance.exit_);
 
      ImGui::TableNextColumn();
      changed |= gui::InputHexWord("Scroll X", &current_entrance.camera_x_);
      changed |= gui::InputHexWord("Scroll Y", &current_entrance.camera_y_);
 
      ImGui::EndTable();
    }
    ImGui::EndDisabled();
 
    ImGui::Separator();
    if (ImGui::CollapsingHeader(tr("Camera Boundaries"))) {
      ImGui::Text(tr("                North   East    South   West"));
      ImGui::BeginDisabled(!properties_editable);
      ImGui::Text(tr("Quadrant      "));
      SameLine();
      changed |= gui::InputHexByte("##QN",
                                   &current_entrance.camera_boundary_qn_, 40.f);
      SameLine();
      changed |= gui::InputHexByte("##QE",
                                   &current_entrance.camera_boundary_qe_, 40.f);
      SameLine();
      changed |= gui::InputHexByte("##QS",
                                   &current_entrance.camera_boundary_qs_, 40.f);
      SameLine();
      changed |= gui::InputHexByte("##QW",
                                   &current_entrance.camera_boundary_qw_, 40.f);
 
      ImGui::Text(tr("Full Room     "));
      SameLine();
      changed |= gui::InputHexByte("##FN",
                                   &current_entrance.camera_boundary_fn_, 40.f);
      SameLine();
      changed |= gui::InputHexByte("##FE",
                                   &current_entrance.camera_boundary_fe_, 40.f);
      SameLine();
      changed |= gui::InputHexByte("##FS",
                                   &current_entrance.camera_boundary_fs_, 40.f);
      SameLine();
      changed |= gui::InputHexByte("##FW",
                                   &current_entrance.camera_boundary_fw_, 40.f);
      ImGui::EndDisabled();
    }
    MarkDungeonEntranceDirtyIfEditable(current_entrance_id_, current_entrance,
                                       changed);
    ImGui::Separator();
  }
 
  entrance_filter_.Draw("Filter", ImGui::GetContentRegionAvail().x);
 
  // Rebuild cache if filter changed
  std::string current_filter(entrance_filter_.InputBuf);
  if (current_filter != last_entrance_filter_ ||
      filtered_entrance_indices_.empty()) {
    last_entrance_filter_ = current_filter;
    RebuildEntranceFilterCache();
  }
 
  constexpr int kNumSpawnPoints = zelda3::kNumDungeonSpawnPoints;
 
  if (ImGui::BeginTable("EntranceList", 3,
                        ImGuiTableFlags_ScrollY | ImGuiTableFlags_Borders |
                            ImGuiTableFlags_RowBg |
                            ImGuiTableFlags_Resizable)) {
    ImGui::TableSetupColumn("ID", ImGuiTableColumnFlags_WidthFixed, 40.0f);
    ImGui::TableSetupColumn("Room", ImGuiTableColumnFlags_WidthFixed, 50.0f);
    ImGui::TableSetupColumn("Name");
    ImGui::TableHeadersRow();
 
    // Use ImGuiListClipper for virtualized rendering
    ImGuiListClipper clipper;
    clipper.Begin(static_cast<int>(filtered_entrance_indices_.size()));
 
    while (clipper.Step()) {
      for (int row = clipper.DisplayStart; row < clipper.DisplayEnd; ++row) {
        int i = filtered_entrance_indices_[row];
        std::string display_name;
 
        if (i < kNumSpawnPoints) {
          display_name = absl::StrFormat("Spawn Point %d", i);
        } else {
          int entrance_id = i - kNumSpawnPoints;
          display_name = zelda3::GetEntranceLabel(entrance_id);
        }
 
        int room_id = (i < static_cast<int>(entrances_->size()))
                          ? (*entrances_)[i].room_
                          : 0;
 
        ImGui::TableNextRow();
        ImGui::TableNextColumn();
 
        char label[32];
        snprintf(label, sizeof(label), "%02X", i);
        if (ImGui::Selectable(label, current_entrance_id_ == i,
                              ImGuiSelectableFlags_SpanAllColumns)) {
          current_entrance_id_ = i;
          if (i < static_cast<int>(entrances_->size())) {
            // Publish selection changed event
            if (auto* bus = ContentRegistry::Context::event_bus()) {
              bus->Publish(
                  SelectionChangedEvent::CreateSingle("dungeon_entrance", i));
            }
 
            // Legacy callback support
            if (entrance_selected_callback_) {
              entrance_selected_callback_(i);
            } else if (room_selected_callback_) {
              room_selected_callback_(room_id);
            }
          }
        }
 
        ImGui::TableNextColumn();
        ImGui::Text("%03X", room_id);
 
        ImGui::TableNextColumn();
        ImGui::TextUnformatted(display_name.c_str());
      }
    }
 
    ImGui::EndTable();
  }
}
 
}  // namespace yaze::editor
 
// ============================================================================
// Grouped view + Blockset group name helper (appended)
// ============================================================================
 
namespace yaze::editor {
 
const char* DungeonRoomSelector::GetBlocksetGroupName(uint8_t blockset) {
  // ALttP blockset -> dungeon name mapping (vanilla ROM)
  switch (blockset) {
    case 0:
      return "Hyrule Castle";
    case 1:
      return "Eastern Palace";
    case 2:
      return "Desert Palace";
    case 3:
      return "Tower of Hera";
    case 4:
      return "Agahnim's Tower";
    case 5:
      return "Palace of Darkness";
    case 6:
      return "Swamp Palace";
    case 7:
      return "Skull Woods";
    case 8:
      return "Thieves' Town";
    case 9:
      return "Ice Palace";
    case 10:
      return "Misery Mire";
    case 11:
      return "Turtle Rock";
    case 12:
      return "Ganon's Tower";
    case 13:
      return "Cave";
    case 14:
      return "Sanctuary / Church";
    case 15:
      return "Houses / Interior";
    case 16:
      return "Shops";
    case 17:
      return "Fairy Fountain";
    case 18:
      return "Underground";
    case 19:
      return "Master Sword";
    case 20:
      return "Fortune Teller";
    case 21:
      return "Tower (Ganon)";
    case 22:
      return "Chris Houlihan";
    case 23:
      return "Links House";
    case 24:
      return "Tomb";
    default:
      return "Unknown";
  }
}
 
void DungeonRoomSelector::DrawGroupedRoomList(
    RoomSelectionIntent single_click_intent) {
  // Build groups from filtered rooms
  // Group key = blockset (if rooms loaded), else "Unloaded"
  struct GroupInfo {
    std::string name;
    std::vector<int> room_ids;
  };
  std::map<int, GroupInfo> groups;
 
  for (int room_id : filtered_room_indices_) {
    int key = 255;  // Unknown/unloaded
    std::string group_name = "Unloaded";
    if (rooms_ && room_id >= 0 && room_id < static_cast<int>(rooms_->size())) {
      size_t dungeon_index = 0;
      if (const auto* dungeon = dungeon_project_labels::FindDungeonForRoom(
              project_, room_id, &dungeon_index)) {
        key = -static_cast<int>(dungeon_index) - 1;
        group_name = dungeon_project_labels::FormatDungeonName(*dungeon);
      } else if (auto* loaded_room = rooms_->GetIfLoaded(room_id)) {
        key = loaded_room->blockset();
        group_name = GetBlocksetGroupName(static_cast<uint8_t>(key));
      }
    }
    auto& g = groups[key];
    g.name = group_name;
    g.room_ids.push_back(room_id);
  }
 
  // Draw as scrollable child with collapsible tree nodes
  if (ImGui::BeginChild("##GroupedRoomList", ImVec2(0, 0), false,
                        ImGuiWindowFlags_None)) {
    for (auto& [key, group] : groups) {
      char header[64];
      snprintf(header, sizeof(header), "%s (%zu rooms)##grp%d",
               group.name.c_str(), group.room_ids.size(), key);
 
      // Auto-open the group that contains the currently selected room
      bool has_current =
          std::find(group.room_ids.begin(), group.room_ids.end(),
                    static_cast<int>(current_room_id_)) != group.room_ids.end();
      if (has_current) {
        ImGui::SetNextItemOpen(
            true, pending_scroll_room_id_ == static_cast<int>(current_room_id_)
                      ? ImGuiCond_Always
                      : ImGuiCond_Once);
      }
 
      if (ImGui::CollapsingHeader(header)) {
        for (int room_id : group.room_ids) {
          std::string display_name =
              dungeon_project_labels::GetRoomLabel(project_, room_id);
          char label[64];
          snprintf(label, sizeof(label), "%03X  %s##r%d", room_id,
                   display_name.c_str(), room_id);
 
          const bool is_current = current_room_id_ == room_id;
          if (ImGui::Selectable(label, is_current,
                                ImGuiSelectableFlags_AllowDoubleClick)) {
            current_room_id_ = room_id;
 
            if (auto* bus = ContentRegistry::Context::event_bus()) {
              bus->Publish(
                  SelectionChangedEvent::CreateSingle("dungeon_room", room_id));
            }
 
            if (ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left)) {
              if (room_intent_callback_) {
                room_intent_callback_(room_id,
                                      RoomSelectionIntent::kOpenStandalone);
              } else if (room_selected_callback_) {
                room_selected_callback_(room_id);
              }
            } else {
              if (room_intent_callback_) {
                room_intent_callback_(room_id, single_click_intent);
              } else if (room_selected_callback_) {
                room_selected_callback_(room_id);
              }
            }
          }
          if (is_current && pending_scroll_room_id_ == room_id) {
            ImGui::SetScrollHereY(0.5f);
            pending_scroll_room_id_ = -1;
          }
 
          // Tooltip with thumbnail
          if (ImGui::IsItemHovered() && rooms_) {
            auto* loaded_room = rooms_->GetIfLoaded(room_id);
            if (loaded_room != nullptr) {
              ImGui::BeginTooltip();
              ImGui::Text("%s", display_name.c_str());
              ImGui::TextDisabled(tr("Blockset: %d | Palette: %d"),
                                  loaded_room->blockset(),
                                  loaded_room->palette());
              auto& room = *loaded_room;
              zelda3::RoomLayerManager layer_mgr;
              layer_mgr.ApplyLayerMerging(room.layer_merging());
              auto& bmp = room.GetCompositeBitmap(layer_mgr);
              if (bmp.is_active() && bmp.texture() != 0) {
                ImGui::Image((ImTextureID)(intptr_t)bmp.texture(),
                             ImVec2(64, 64));
              }
              ImGui::EndTooltip();
            }
          }
        }
      }
    }
  }
  ImGui::EndChild();
}
 
}  // namespace yaze::editor