overworld_editor.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_OVERWORLDEDITOR_H
#define YAZE_APP_EDITOR_OVERWORLDEDITOR_H
 
#include <chrono>
#include <memory>
#include <optional>
 
#include "absl/status/status.h"
#include "app/editor/editor.h"
#include "app/editor/graphics/gfx_group_editor.h"
#include "app/editor/overworld/canvas/canvas_navigation_manager.h"
#include "app/editor/overworld/canvas/overworld_canvas_renderer.h"
#include "app/editor/overworld/core/interaction_coordinator.h"
#include "app/editor/overworld/entity/entity_editing_target.h"
#include "app/editor/overworld/entity/entity_insertion_request.h"
#include "app/editor/overworld/entity/entity_mutation_service.h"
#include "app/editor/overworld/entity/entity_workbench.h"
#include "app/editor/overworld/entity/overworld_entity_renderer.h"
#include "app/editor/overworld/lyra_terrain_canvas.h"
#include "app/editor/overworld/maps/map_properties.h"
#include "app/editor/overworld/maps/map_refresh_coordinator.h"
#include "app/editor/overworld/maps/map_texture_coordinator.h"
#include "app/editor/overworld/overworld_undo_actions.h"
#include "app/editor/overworld/painting/tile_painting_manager.h"
#include "app/editor/overworld/project_graphics_import.h"
#include "app/editor/overworld/project_graphics_source.h"
#include "app/editor/overworld/scratch_workspace.h"
#include "app/editor/overworld/tile16_editor.h"
#include "app/editor/overworld/ui/debug/debug_window_card.h"
#include "app/editor/overworld/ui/debug/usage_statistics_card.h"
#include "app/editor/overworld/ui/navigation/overworld_sidebar.h"
#include "app/editor/overworld/ui/navigation/overworld_toolbar.h"
#include "app/editor/overworld/ui/ui_constants.h"
#include "app/editor/palette/palette_editor.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/render/tilemap.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/core/input.h"
#include "app/gui/layout/adaptive_sheet_layout.h"
#include "app/gui/widgets/tile_selector_widget.h"
#include "imgui/imgui.h"
#include "rom/rom.h"
#include "zelda3/overworld/overworld.h"
#include "zelda3/overworld/overworld_upgrade_system.h"
 
// =============================================================================
// Overworld Editor - UI Layer
// =============================================================================
//
// ARCHITECTURE OVERVIEW:
// ----------------------
// The OverworldEditor is the main UI class for editing overworld maps.
// It orchestrates several subsystems:
//
//   1. TILE EDITING SYSTEM
//      - Tile16Editor: Popup for editing individual 16x16 tiles
//      - Tile selection and painting on the main canvas
//      - Undo/Redo stack for paint operations
//
//   2. ENTITY SYSTEM
//      - OverworldEntityRenderer: Draws entities on the canvas
//      - entity_operations.cc: Insertion/deletion logic
//      - overworld_entity_interaction.cc: Drag/drop and click handling
//
//   3. MAP PROPERTIES SYSTEM
//      - MapPropertiesSystem: Toolbar and context menus
//      - OverworldSidebar: Property editing tabs
//      - Graphics, palettes, music per area
//
//   4. CANVAS SYSTEM
//      - ow_map_canvas_: Main overworld display (4096x4096)
//      - blockset_canvas_: Tile16 selector
//      - scratch_canvas_: Layout workspace
//
// EDITING MODES:
// --------------
// - DRAW_TILE: Left-click paints tiles, right-click opens tile16 editor
// - MOUSE: Left-click selects entities, right-click opens context menus
//
// KEY WORKFLOWS:
// --------------
// See README.md in this directory for complete workflow documentation.
//
// SUBSYSTEM ORGANIZATION:
// -----------------------
// The class is organized into logical sections marked with comment blocks.
// Each section groups related methods and state for a specific subsystem.
// =============================================================================
 
namespace yaze {
namespace editor {
 
struct OverworldItemsSnapshot;
 
// =============================================================================
// Constants
// =============================================================================
 
constexpr unsigned int k4BPP = 4;
constexpr unsigned int kByteSize = 3;
constexpr unsigned int kMessageIdSize = 5;
constexpr unsigned int kNumSheetsToLoad = 223;
constexpr ImVec2 kOverworldCanvasSize(kOverworldMapSize * 8,
                                      kOverworldMapSize * 8);
constexpr ImVec2 kCurrentGfxCanvasSize(0x100 + 1, 0x10 * 0x40 + 1);
constexpr ImVec2 kBlocksetCanvasSize(0x100 + 1, 0x4000 + 1);
constexpr ImVec2 kGraphicsBinCanvasSize(0x100 + 1, kNumSheetsToLoad * 0x40 + 1);
 
constexpr ImGuiTableFlags kOWMapFlags =
    ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable |
    ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingStretchProp;
 
constexpr absl::string_view kWorldList =
    "Light World\0Dark World\0Extra World\0";
 
constexpr absl::string_view kGamePartComboString = "Part 0\0Part 1\0Part 2\0";
 
constexpr absl::string_view kOWMapTable = "#MapSettingsTable";
 
class OverworldEditor : public Editor, public gfx::GfxContext {
  friend class OverworldCanvasRenderer;
  friend class OverworldScratchTestPeer;
 
 public:
  // ===========================================================================
  // Construction and Initialization
  // ===========================================================================
 
  explicit OverworldEditor(Rom* rom) : rom_(rom) {
    type_ = EditorType::kOverworld;
    gfx_group_editor_.SetRom(rom);
    gfx_group_editor_.SetUndoManager(&undo_manager_);
    // MapPropertiesSystem will be initialized after maps_bmp_ and canvas are
    // ready
  }
 
  explicit OverworldEditor(Rom* rom, const EditorDependencies& deps)
      : OverworldEditor(rom) {
    dependencies_ = deps;
  }
  ~OverworldEditor() override;
  void SetMainGraphicsUsageCallback(
      GfxGroupEditor::MainUsageCallback callback) {
    gfx_group_editor_.SetMainUsageCallback(std::move(callback));
  }
  void SetRoomsetGraphicsUsageCallback(
      GfxGroupEditor::RoomsetUsageCallback callback) {
    gfx_group_editor_.SetRoomsetUsageCallback(std::move(callback));
  }
  void PrepareForSessionTeardown() override {
    gfx_group_editor_.DetachRuntimeContext();
  }
 
  void SetDependencies(const EditorDependencies& deps) override {
    Editor::SetDependencies(deps);
    gfx_group_editor_.SetWorkspaceState(deps.gfx_group_workspace);
  }
 
  void SetGameData(zelda3::GameData* game_data) override {
    game_data_ = game_data;
    overworld_.SetGameData(game_data);
    tile16_editor_.SetGameData(game_data);
    gfx_group_editor_.SetGameData(game_data);
  }
 
  // ===========================================================================
  // Editor Interface Implementation
  // ===========================================================================
 
  void Initialize() override;
  absl::Status Load() override;
  absl::Status Update() final;
  absl::Status Undo() override;
  absl::Status Redo() override;
  absl::Status Cut() override { return absl::UnimplementedError("Cut"); }
  absl::Status Copy() override;
  absl::Status Paste() override;
  absl::StatusOr<int> ApplyTile16Stencil(
      int map_id, const std::vector<GuardedTileCell>& cells);
  absl::Status Find() override { return absl::UnimplementedError("Find"); }
  absl::Status Save() override;
  absl::Status BeginSaveTransaction() override;
  void RollbackSaveTransaction() override;
  void CommitSaveTransaction() override;
  absl::Status Clear() override;
  bool HasPendingProjectDraftChanges() const {
    return lyra_canvas_.dirty() || scratch_space_dirty_ ||
           (graphics_source_ && graphics_source_->any_dirty());
  }
  bool HasUnpublishedProjectGraphics() const {
    return graphics_source_ && graphics_source_->any_dirty();
  }
  absl::Status OpenProjectGraphicsSource();
  absl::StatusOr<ProjectGraphicsImportPlan> PreviewProjectGraphicsImport(
      const std::string& pack, const ProjectGraphicsImportBindings& bindings);
  absl::Status ApplyProjectGraphicsImport(
      const std::string& pack, const ProjectGraphicsImportBindings& bindings);
  absl::Status PlaceProjectGraphicsImport(int world_x, int world_y);
  absl::Status PublishProjectGraphicsSource();
  void SetProjectContextProvider(
      std::function<project::YazeProject*()> provider) {
    project_context_provider_ = std::move(provider);
  }
  absl::Status PrepareProjectSave();
  void ProjectSaveCommitted() { lyra_canvas_.ProjectSaveCommitted(); }
  void ContributeStatus(StatusBar* status_bar) override;
  void DrawEditorMenu() override;
  void DrawEditMenuItems() override;
  EditorContextSnapshot BuildContextSnapshot() const override;
 
  zelda3::Overworld& overworld() { return overworld_; }
  // One 512x512 overworld screen for tools that draw areas outside this
  // editor (the Cutscene Camera). Builds its texture on first use; nullptr
  // for an invalid ID or a screen that is not built yet.
  const gfx::Bitmap* AreaScreenBitmap(int map_id);
 
  int jump_to_tab() { return jump_to_tab_; }
  int jump_to_tab_ = -1;
  // Regular entrance IDs share numbers with room IDs but not meaning; the
  // dungeon editor resolves the entrance's room.
  int jump_to_entrance_ = -1;
 
  // ===========================================================================
  // ROM State
  // ===========================================================================
 
  bool IsRomLoaded() const override { return rom_ && rom_->is_loaded(); }
  std::string GetRomStatus() const override {
    if (!rom_)
      return "No ROM loaded";
    if (!rom_->is_loaded())
      return "ROM failed to load";
    return absl::StrFormat("ROM loaded: %s", rom_->title());
  }
 
  Rom* rom() const { return rom_; }
  absl::Status EditProjectMapAuthoring(core::LyraAuthoringState after) {
    return lyra_canvas_.EditAuthoring(std::move(after), overworld_,
                                      undo_manager_);
  }
  // Project ownership is resolved through the session provider. The manager
  // loads native assets before invoking either explicit lifecycle action.
  absl::Status CreateLyraTerrain();
  absl::Status OpenLyraTerrain(const std::string& path);
  absl::Status SaveProjectTerrainAs(project::YazeProject* project,
                                    const std::string& project_path);
  LyraTerrainCanvas lyra_canvas_;
  absl::Status lyra_canvas_status_;
  // Project terrain occupies the lower Special World rows without expanding
  // the ROM model or materializing legacy maps for those IDs.
  int DisplayedMapCount() const;
  bool IsProjectTerrainMap(int map_id) const;
  bool is_lyra_preview() const { return overworld_.is_lyra_preview(); }
  bool lyra_a0_terrain_writable() const {
    return overworld_.lyra_a0_terrain_writable();
  }
  absl::Status PaintLyraA0Terrain(int map_id, int x, int y, uint16_t tile);
  absl::Status SaveLyraA0TerrainAs(const std::string& filename);
  // A Lyra preview retains pointers and caches derived from one ROM image.
  // Session replacement must be checked before the manager mutates the ROM.
  absl::Status CheckRomReplacement(const Rom& replacement) const;
  bool overlay_preview_enabled() const { return show_overlay_preview_; }
 
  static bool NormalizeMapSelection(int& current_world, int& current_map,
                                    int map_count = zelda3::kNumOverworldMaps);
 
  void set_current_map(int map_id) {
    if (map_id >= 0 && map_id < DisplayedMapCount()) {
      // Finalize any pending paint operation before switching maps
      FinalizePaintOperation();
      lyra_canvas_.FinishStroke(undo_manager_);
      current_map_ = map_id;
      current_world_ =
          map_id / 0x40;  // Calculate which world the map belongs to
      if (const auto* map = overworld_.overworld_map(current_map_)) {
        current_parent_ = map->parent();
      } else {
        current_parent_ = current_map_;
      }
      if (!IsProjectTerrainMap(map_id)) {
        overworld_.set_current_map(current_map_);
        overworld_.set_current_world(current_world_);
      }
    }
  }
  void SetCurrentMap(int map_id) { set_current_map(map_id); }
  void SelectMapForEditing(int map_id, bool respect_pin = true);
 
  void set_current_tile16(int tile_id) { current_tile16_ = tile_id; }
  int current_tile16_id() const { return current_tile16_; }
  // Opens a Tile16's editable quadrants, focused on the requested quadrant.
  // The selected map at invocation supplies the sheet and palette context.
  absl::Status OpenGraphicsForTile16Quadrant(int tile16_id, int quadrant);
  // Uses the map/tile captured by the context menu, not the hovered or pinned
  // map. The clicked quadrant is focused first.
  absl::Status OpenGraphicsForContextTile16(
      const OverworldContextTarget& target);
  const TilePaintingManager* tile_painting() const {
    return tile_painting_.get();
  }
  const gfx::Bitmap& map_bitmap(int map_id) const {
    return maps_bmp_.at(map_id);
  }
  bool map_pinned() const { return current_map_lock_; }
  int current_map_id() const { return current_map_; }
  int current_world_id() const { return current_world_; }
  int hovered_map_id() const { return hovered_map_; }
 
  // ===========================================================================
  // Graphics Loading
  // ===========================================================================
 
  absl::Status LoadGraphics();
  absl::Status SyncProjectGraphicsPreview(bool force = false);
 
  // ===========================================================================
  // Entity Interaction API
  // ===========================================================================
 
  void SetCurrentEntity(zelda3::GameEntity* entity);
  zelda3::GameEntity* current_entity() const { return current_entity_; }
 
  void NotifyEntityModified(zelda3::GameEntity* entity);
  absl::Status ApplyEntranceEdit(zelda3::OverworldEntrance* target,
                                 const zelda3::OverworldEntrance& draft);
  absl::Status ApplyExitEdit(zelda3::OverworldExit* target,
                             const zelda3::OverworldExit& draft);
  void OpenEntityEditor(zelda3::GameEntity* entity);
 
  void RequestJumpToRoom(int room_id) { jump_to_tab_ = room_id; }
 
  void RequestJumpToEntrance(int entrance_id) {
    jump_to_entrance_ = entrance_id;
  }
 
  EntityMutationService* entity_mutation_service() {
    return entity_mutation_service_.get();
  }
 
  zelda3::OverworldEntrance& edit_entrance() { return edit_entrance_; }
  zelda3::OverworldExit& edit_exit() { return edit_exit_; }
  zelda3::OverworldItem& edit_item() { return edit_item_; }
  zelda3::Sprite& edit_sprite() { return edit_sprite_; }
 
  std::optional<OverworldEntityInsertionRequest> TakePendingEntityInsertion() {
    auto request = std::move(pending_entity_insertion_);
    pending_entity_insertion_.reset();
    return request;
  }
  std::string& insert_error() { return insert_error_; }
 
  gui::Canvas& ow_map_canvas() { return ow_map_canvas_; }
  int game_state() const { return game_state_; }
  // Preview only; does not rewrite story progression or entity placements.
  void SetPreviewStoryState(int state);
 
  void SetSelectionBrush(TileBrush brush);
  void ClearSelectionBrush();
  const TileBrush* selection_brush() const;
  int GetTile16UsageCount(int tile_id) const;
  std::string GetTile16ScopeLabel() const;
 
  // ===========================================================================
  // Entity System - Insertion and Editing
  // ===========================================================================
  // Entity operations are delegated to entity_operations.cc helper functions.
  // Entity rendering is handled by OverworldEntityRenderer.
  // Entity interaction (drag/drop) is in overworld_entity_interaction.cc.
 
  void HandleEntityInsertion(const std::string& entity_type,
                             const OverworldContextTarget& target);
  void RequestItemInsertPopup(
      const std::optional<OverworldContextTarget>& target);
  void DrawItemInsertPopup();
  bool TryPlaceArmedItem();
 
  void HandleTile16Edit(const OverworldContextTarget& target);
  bool SampleContextTile16(const OverworldContextTarget& target);
 
  bool SelectItemByIdentity(const zelda3::OverworldItem& item_identity);
 
  void ClearSelectedItem();
 
  std::optional<zelda3::OverworldItem> selected_item_identity() const {
    return selected_item_identity_;
  }
 
  zelda3::OverworldItem* GetSelectedItem();
  const zelda3::OverworldItem* GetSelectedItem() const;
 
  bool DuplicateSelectedItem(int offset_x = 16, int offset_y = 0);
 
  bool NudgeSelectedItem(int delta_x, int delta_y);
 
  bool DeleteSelectedItem();
  bool DeleteItemByIdentity(const zelda3::OverworldItem& item_identity);
 
  // ===========================================================================
  // Keyboard Shortcuts
  // ===========================================================================
 
  void ToggleBrushTool() {
    if (tile_painting_)
      tile_painting_->ToggleBrushTool();
  }
  void ActivateFillTool() {
    if (tile_painting_)
      tile_painting_->ActivateFillTool();
  }
  void CycleTileSelection(int delta);
  // Map/view toggles bound through ShortcutManager (F11, Cmd/Ctrl+L,
  // Cmd/Ctrl+T, Cmd/Ctrl+Shift+I).
  void ToggleMapLock();
  void ToggleCanvasFullscreen();
  void ToggleTile16EditorWindow();
  bool Tile16MenuEnabled() const;
  void ToggleItemListWindow();
  void SetEditingMode(EditingMode mode);
  void SelectAdjacentMap(int dx, int dy);
  void JumpToMap(int map_id);
  // Navigate to an inspected Tile16 without changing ROM or edit history.
  void LocateOverworldTile(int map_id, int world_x, int world_y);
  void SwitchToWorld(int world);
  // View requests; applied when the canvas child begins (safe anywhere).
  void ZoomIn();
  void ZoomOut();
  void ZoomToFit();
  void ResetOverworldView();
  void CenterOverworldView();
  void SetEntityEditMode(EntityEditMode mode);
  void ToggleEntityVisibility() { show_entities_ = !show_entities_; }
  bool entities_visible() const { return show_entities_; }
  void ToggleGrid();
  bool grid_visible() const;
  void OpenMapPropertiesWindow();
 
  void RequestTile16Selection(int tile_id);
 
  bool PickTile16FromHoveredCanvas();
 
  // ===========================================================================
  // WindowContent View Hooks
  // ===========================================================================
  // These are used by focused WindowContent wrappers around Overworld views.
  // Drawing is delegated to OverworldCanvasRenderer.
 
  absl::Status DrawAreaGraphics() {
    if (is_lyra_preview()) {
      ImGui::TextDisabled("Lyra preview: area graphics editing unavailable");
      return absl::OkStatus();
    }
    NormalizeCurrentSelectionState();
    if (ImGui::Button("Edit / Import Project Graphics"))
      status_.Update(OpenProjectGraphicsSource());
    if (!canvas_renderer_)
      return absl::FailedPreconditionError("Renderer not initialized");
    return canvas_renderer_->DrawAreaGraphics();
  }
  absl::Status DrawTile16Selector() {
    if (is_lyra_preview()) {
      ImGui::TextDisabled("Lyra preview: Tile16 editing unavailable");
      return absl::OkStatus();
    }
    if (!canvas_renderer_)
      return absl::FailedPreconditionError("Renderer not initialized");
    return canvas_renderer_->DrawTile16Selector();
  }
  void DrawMapProperties() {
    if (is_lyra_preview()) {
      ImGui::TextDisabled("Lyra preview: map properties editing unavailable");
      return;
    }
    NormalizeCurrentSelectionState();
    if (canvas_renderer_)
      canvas_renderer_->DrawMapProperties();
  }
 
  void InvalidateGraphicsCache(int map_id = -1) {
    if (map_refresh_)
      map_refresh_->InvalidateGraphicsCache(map_id);
  }
  absl::Status DrawScratchSpace();
  void DrawTile8Selector() {
    if (is_lyra_preview()) {
      ImGui::TextDisabled("Lyra preview: Tile8 editing unavailable");
      return;
    }
    if (canvas_renderer_)
      canvas_renderer_->DrawTile8Selector();
  }
  absl::Status UpdateGfxGroupEditor();
  void DrawV3Settings() {
    if (is_lyra_preview()) {
      ImGui::TextDisabled("Lyra preview: overworld settings unavailable");
      return;
    }
    NormalizeCurrentSelectionState();
    if (canvas_renderer_)
      canvas_renderer_->DrawV3Settings();
  }
 
  UsageStatisticsCard* usage_stats_card() { return usage_stats_card_.get(); }
 
  DebugWindowCard* debug_window_card() { return debug_window_card_.get(); }
 
  Tile16Editor& tile16_editor() { return tile16_editor_; }
  const Tile16Editor& tile16_editor() const { return tile16_editor_; }
 
  const gfx::Tilemap& tile16_blockset() const { return tile16_blockset_; }
  const gfx::Bitmap& current_gfx_bmp_for_testing() const {
    return current_gfx_bmp_;
  }
 
  OverworldEntityWorkbench* GetWorkbench();
 
  void DrawOverworldCanvas();
 
 private:
  void FocusLyraTerrain();
  project::YazeProject* TerrainProject() const {
    return project_context_provider_ ? project_context_provider_()
                                     : dependencies_.project;
  }
  std::function<project::YazeProject*()> project_context_provider_;
  friend class AuthoringSaveWorkflowTestPeer;
  friend class ProjectGraphicsImportSaveTestPeer;
  friend class ProjectGraphicsImportWorkflowTestPeer;
  void DrawProjectGraphicsSource();
  void DrawProjectGraphicsImport();
  std::string ProjectGraphicsPath() const;
  absl::Status ReloadProjectGraphics();
  absl::Status RefreshPendingProjectGraphics();
  absl::StatusOr<ProjectGraphicsImportContext> GraphicsImportContext();
  std::shared_ptr<ProjectGraphicsSource> graphics_source_;
  const project::YazeProject* graphics_source_project_ = nullptr;
  bool graphics_source_open_ = false;
  bool graphics_import_applied_ = false;
  int graphics_source_tile_ = 0;
  int graphics_source_palette_ = 5;
  int graphics_source_index_ = 1;
  absl::Status graphics_source_status_;
  std::string graphics_source_message_;
  zelda3::OverworldGraphicsPreview graphics_preview_baseline_;
  std::array<char, 1024> graphics_import_path_{};
  std::optional<ProjectGraphicsImportAsset> graphics_import_asset_;
  std::optional<ProjectGraphicsImportPlan> graphics_import_plan_;
  ProjectGraphicsImportBindings graphics_import_bindings_;
  ProjectGraphicsImportBindings graphics_import_applied_bindings_;
  std::string graphics_import_pack_;
  bool graphics_import_ranges_reviewed_ = false;
 
  // Identifies the exact descriptor image bound to this model. The session
  // reload path may restore those bytes after a refused ROM replacement.
  std::string lyra_loaded_rom_sha1_;
  int lyra_terrain_brush_ = 0x2103;
  std::string graphics_preview_config_path_;
  // ===========================================================================
  // Entity Interaction System
  // ===========================================================================
  // Handles mouse interactions with entities in MOUSE mode.
 
 
  bool NormalizeCurrentSelectionState();
 
  // ===========================================================================
  // Map Refresh System (delegated to MapRefreshCoordinator)
  // ===========================================================================
 
  void InitMapRefreshCoordinator();
  void InitMapTextureCoordinator();
  void InitInteractionCoordinator();
 
  // Convenience delegation methods for internal use
  void RefreshChildMap(int map_index) {
    if (map_refresh_ && !IsProjectTerrainMap(map_index))
      map_refresh_->RefreshChildMap(map_index);
  }
  void RefreshOverworldMap() {
    if (map_refresh_ && !IsProjectTerrainMap(current_map_))
      map_refresh_->RefreshOverworldMap();
  }
  void RefreshOverworldMapOnDemand(int map_index) {
    if (map_refresh_ && !IsProjectTerrainMap(map_index))
      map_refresh_->RefreshOverworldMapOnDemand(map_index);
  }
  void RefreshChildMapOnDemand(int map_index) {
    if (map_refresh_ && !IsProjectTerrainMap(map_index))
      map_refresh_->RefreshChildMapOnDemand(map_index);
  }
  absl::Status RefreshMapPalette(int map_id = -1) {
    if (IsProjectTerrainMap(map_id < 0 ? current_map_ : map_id))
      return absl::OkStatus();
    if (map_refresh_)
      return map_refresh_->RefreshMapPalette(map_id);
    return absl::FailedPreconditionError(
        "MapRefreshCoordinator not initialized");
  }
  void RefreshMapProperties(int map_id = -1) {
    if (map_refresh_ &&
        !IsProjectTerrainMap(map_id < 0 ? current_map_ : map_id))
      map_refresh_->RefreshMapProperties(map_id);
  }
  absl::Status RefreshTile16Blockset() {
    if (IsProjectTerrainMap(current_map_))
      return absl::OkStatus();
    if (map_refresh_)
      return map_refresh_->RefreshTile16Blockset();
    return absl::FailedPreconditionError(
        "MapRefreshCoordinator not initialized");
  }
  void UpdateBlocksetWithPendingTileChanges() {
    if (map_refresh_ && !IsProjectTerrainMap(current_map_))
      map_refresh_->UpdateBlocksetWithPendingTileChanges();
  }
  void ForceRefreshGraphics(int map_index) {
    if (map_refresh_ && !IsProjectTerrainMap(map_index))
      map_refresh_->ForceRefreshGraphics(map_index);
  }
  void RefreshSiblingMapGraphics(int map_index, bool include_self = false) {
    if (map_refresh_ && !IsProjectTerrainMap(map_index))
      map_refresh_->RefreshSiblingMapGraphics(map_index, include_self);
  }
 
  // ===========================================================================
  // Tile Editing System
  // ===========================================================================
  // Handles tile painting and selection on the main canvas.
 
  void InitTilePaintingManager();
 
  void CheckForOverworldEdits();
 
  absl::Status CheckForCurrentMap();
 
  void HandleMapInteraction();
  void UpdateBlocksetSelectorState();
 
  void ScrollBlocksetCanvasToCurrentTile();
 
  void InitCanvasNavigationManager();
 
  // Canvas navigation (delegated to CanvasNavigationManager)
  void DrawEntityPopups();
  void OpenEntityContextMenu(zelda3::GameEntity* entity);
  void DrawEntityContextMenu();
  zelda3::GameEntity* ResolveEditingEntity();
 
  // ===========================================================================
  // Texture and Graphics Loading
  // ===========================================================================
 
  absl::Status LoadSpriteGraphics();
 
  void ProcessDeferredTextures();
 
  void RefreshMapsForSheetEdits();
 
  void EnsureMapTexture(int map_index);
  void PrimeWorldMaps(int world, bool process_texture_queue = false);
  // ===========================================================================
  // Canvas Navigation (delegated to CanvasNavigationManager)
  // ===========================================================================
 
  // ===========================================================================
  // Canvas Automation API
  // ===========================================================================
  // Integration with automation testing system.
 
  void SetupCanvasAutomation();
  gui::Canvas* GetOverworldCanvas() { return &ow_map_canvas_; }
  bool AutomationSetTile(int x, int y, int tile_id);
  int AutomationGetTile(int x, int y);
 
  // ===========================================================================
  // Scratch Space System
  // ===========================================================================
  // Workspace for planning tile layouts before placing them on the map.
 
  absl::Status SaveCurrentSelectionToScratch();
  absl::Status LoadScratchToSelection();
  absl::Status ClearScratchSpace();
  void DrawScratchSpaceEdits();
  void DrawScratchSpacePattern();
  void DrawScratchSpaceSelection();
  void UpdateScratchBitmapTile(int tile_x, int tile_y, int tile_id);
  absl::Status LoadScratchPad();
  absl::Status SaveScratchPad();
  void BeginScratchEdit();
  void FinishScratchEdit(const std::string& description);
  absl::Status RestoreScratchState(const ScratchWorkspaceState& state);
  absl::Status FlushScratchPadIfDirty();
  absl::Status RebuildScratchBitmapFromTileData();
  void MarkScratchSpaceDirty();
 
  // ===========================================================================
  // Undo/Redo System
  // ===========================================================================
  // Tracks tile paint operations for undo/redo functionality.
  // Operations within 500ms are batched to reduce undo point count.
 
  struct OverworldUndoPoint {
    int map_id = 0;
    int world = 0;  // 0=Light, 1=Dark, 2=Special
    std::vector<std::pair<std::pair<int, int>, int>>
        tile_changes;  // ((x,y), old_tile_id)
    std::chrono::steady_clock::time_point timestamp;
  };
 
  void CreateUndoPoint(int map_id, int world, int x, int y, int old_tile_id);
  void FinalizePaintOperation();
  auto& GetWorldTiles(int world);
  OverworldItemsSnapshot CaptureItemUndoSnapshot() const;
  void RestoreItemUndoSnapshot(const OverworldItemsSnapshot& snapshot);
  void PushItemUndoAction(OverworldItemsSnapshot before,
                          std::string description);
  absl::Status ApplyOverworldPropertyEdit(const OverworldPropertyEdit& edit,
                                          bool record_undo = true);
  absl::Status ApplyOverworldPropertyEdits(
      const std::vector<OverworldPropertyEdit>& edits,
      const std::string& description, bool record_undo = true);
  absl::Status RenameProjectResourceLabelWithUndo(const std::string& type,
                                                  int id,
                                                  const std::string& label);
 
  // ===========================================================================
  // Editing Mode State
  // ===========================================================================
 
  EditingMode current_mode = EditingMode::DRAW_TILE;
  EditingMode previous_mode = EditingMode::DRAW_TILE;
  EntityEditMode entity_edit_mode_ = EntityEditMode::NONE;
 
  enum OverworldProperty {
    LW_AREA_GFX,
    DW_AREA_GFX,
    LW_AREA_PAL,
    DW_AREA_PAL,
    LW_SPR_GFX_PART1,
    LW_SPR_GFX_PART2,
    DW_SPR_GFX_PART1,
    DW_SPR_GFX_PART2,
    LW_SPR_PAL_PART1,
    LW_SPR_PAL_PART2,
    DW_SPR_PAL_PART1,
    DW_SPR_PAL_PART2,
  };
 
  // ===========================================================================
  // Current Selection State
  // ===========================================================================
 
  int current_world_ = 0;   // 0=Light, 1=Dark, 2=Special
  int current_map_ = 0;     // Current map index (0-159)
  int current_parent_ = 0;  // Parent map for multi-area
  int hovered_map_ = -1;    // Physical screen under the cursor, or -1
  int current_blockset_ = 0;
  int game_state_ = 1;      // 0=Beginning, 1=Pendants, 2=Crystals
  int current_tile16_ = 0;  // Selected tile16 for painting
  int selected_entrance_ = 0;
  int selected_usage_map_ = 0xFFFF;
 
  // Selected tile IDs for rectangle selection
  std::vector<int> selected_tile16_ids_;
 
  // ===========================================================================
  // Loading State
  // ===========================================================================
 
  bool all_gfx_loaded_ = false;
  bool map_blockset_loaded_ = false;
 
  std::optional<int> pending_tile16_selection_after_gfx_;
 
  // ===========================================================================
  // Canvas Interaction State
  // ===========================================================================
 
  bool overworld_canvas_fullscreen_ = false;
  bool is_dragging_entity_ = false;
  std::optional<OverworldItemsSnapshot> drag_item_snapshot_;
  bool dragged_entity_free_movement_ = false;
  bool current_map_lock_ = false;
 
  // ===========================================================================
  // Property Windows (Standalone, Not PanelManager)
  // ===========================================================================
 
  bool show_custom_bg_color_editor_ = false;
  bool show_overlay_editor_ = false;
  // Area subscreen overlays (sky, fog, lava, canopy, rain) are shown by
  // default, like the game; the toolbar toggle hides them.
  bool show_overlay_preview_ = true;
  bool show_entities_ = true;
 
  // ===========================================================================
  // UI Subsystem Components
  // ===========================================================================
 
  std::unique_ptr<OverworldCanvasRenderer> canvas_renderer_;
  std::unique_ptr<CanvasNavigationManager> canvas_nav_;
  std::unique_ptr<TilePaintingManager> tile_painting_;
  std::unique_ptr<zelda3::OverworldUpgradeSystem> upgrade_system_;
  std::unique_ptr<EntityMutationService> entity_mutation_service_;
  std::unique_ptr<OverworldInteractionCoordinator> interaction_coordinator_;
  std::unique_ptr<MapRefreshCoordinator> map_refresh_;
  std::unique_ptr<OverworldMapTextureCoordinator> map_texture_;
  std::unique_ptr<MapPropertiesSystem> map_properties_system_;
  std::unique_ptr<OverworldSidebar> sidebar_;
  std::unique_ptr<OverworldEntityRenderer> entity_renderer_;
  std::unique_ptr<OverworldToolbar> toolbar_;
 
  // ===========================================================================
  // Scratch Space System (Unified Single Workspace)
  // ===========================================================================
 
  ScratchWorkspace scratch_workspace_;
  gfx::Bitmap scratch_bitmap_;
  std::optional<ScratchWorkspaceState> scratch_edit_before_;
  bool scratch_space_dirty_ = false;
  absl::Status scratch_load_status_;
  absl::Status scratch_action_status_;
  absl::Status scratch_save_status_;
  bool scratch_initialized_ = false;
  std::filesystem::path scratch_path_;
  uint64_t scratch_name_id_ = 0;
  std::array<char, 129> scratch_name_buffer_{};
  uint64_t scratch_resize_id_ = 0;
  std::array<int, 2> scratch_resize_dimensions_{16, 16};
  int scratch_preview_map_ = -1;
  uint64_t scratch_preview_revision_ = 0;
  bool scratch_paint_gesture_owned_ = false;
  bool scratch_select_active_ = false;
  ImVec2 scratch_select_min_{-1, -1};
  ImVec2 scratch_select_max_{-1, -1};
  bool scratch_selecting_ = false;
  ImVec2 scratch_drag_start_{-1, -1};
  gui::AdaptiveSheetScaleMode scratch_scale_mode_ =
      gui::AdaptiveSheetScaleMode::kFit;
 
  // ===========================================================================
  // Core Data References
  // ===========================================================================
 
  gfx::Tilemap tile16_blockset_;
 
  Rom* rom_;
  zelda3::GameData* game_data_ = nullptr;
  gfx::IRenderer* renderer_;
 
  // Sub-editors
  Tile16Editor tile16_editor_{rom_, &tile16_blockset_};
  GfxGroupEditor gfx_group_editor_;
  PaletteEditor palette_editor_;
 
  // ===========================================================================
  // Graphics Data
  // ===========================================================================
 
  gfx::SnesPalette palette_;
  gfx::Bitmap selected_tile_bmp_;
  gfx::Bitmap tile16_blockset_bmp_;
  gfx::Bitmap current_gfx_bmp_;
  gfx::Bitmap all_gfx_bmp;
  std::array<gfx::Bitmap, zelda3::kExpandedMapCount> maps_bmp_;
  gfx::BitmapTable current_graphics_set_;
  std::vector<gfx::Bitmap> sprite_previews_;
 
  // ===========================================================================
  // Overworld Data Layer
  // ===========================================================================
 
  zelda3::Overworld overworld_{rom_};
  bool map_tile_save_transaction_open_ = false;
  zelda3::OverworldBlockset refresh_blockset_;
 
  // ===========================================================================
  // Entity State
  // ===========================================================================
 
  zelda3::OverworldEntranceTileTypes entrance_tiletypes_ = {};
 
  zelda3::GameEntity* current_entity_ = nullptr;
  zelda3::GameEntity* dragged_entity_ = nullptr;
  std::optional<zelda3::OverworldItem> selected_item_identity_;
  std::optional<OverworldEntityEditingTarget> editing_target_;
 
  // Edit buffers for popups (session-specific)
  zelda3::OverworldEntrance edit_entrance_;
  zelda3::OverworldExit edit_exit_;
  zelda3::OverworldItem edit_item_;
  zelda3::Sprite edit_sprite_;
 
  // Deferred entity insertion (needed for popup flow from context menu)
  std::optional<OverworldEntityInsertionRequest> pending_entity_insertion_;
  std::optional<OverworldContextTarget> item_insert_target_;
  bool item_insert_popup_requested_ = false;
  bool item_placement_armed_ = false;
  uint8_t armed_item_id_ = 0;
  std::string insert_error_;
 
  // ===========================================================================
  // Canvas Components
  // ===========================================================================
 
  gui::Canvas ow_map_canvas_{"OwMap", kOverworldCanvasSize,
                             gui::CanvasGridSize::k64x64};
  gui::Canvas current_gfx_canvas_{"CurrentGfx", kCurrentGfxCanvasSize,
                                  gui::CanvasGridSize::k32x32};
  gui::Canvas blockset_canvas_{"OwBlockset", kBlocksetCanvasSize,
                               gui::CanvasGridSize::k32x32};
  std::unique_ptr<gui::TileSelectorWidget> blockset_selector_;
  gui::Canvas graphics_bin_canvas_{"GraphicsBin", kGraphicsBinCanvasSize,
                                   gui::CanvasGridSize::k16x16};
  gui::Canvas properties_canvas_;
  gui::Canvas scratch_canvas_{"ScratchSpace", ImVec2(320, 480),
                              gui::CanvasGridSize::k16x16};
 
  // ===========================================================================
  // Panel Cards
  // ===========================================================================
 
  std::unique_ptr<UsageStatisticsCard> usage_stats_card_;
  std::unique_ptr<DebugWindowCard> debug_window_card_;
 
  absl::Status status_;
 
  // ===========================================================================
  // Undo/Redo State
  // ===========================================================================
 
  std::optional<OverworldUndoPoint> current_paint_operation_;
 
  // ===========================================================================
  // Event Listeners
  // ===========================================================================
 
  int palette_listener_id_ = -1;
};
}  // namespace editor
}  // namespace yaze
 
#endif