dungeon_editor_v2_undo.cc

Go to the documentation of this file.

// Undo/redo, clipboard, and room-state restore implementation for
// DungeonEditorV2. Split out of dungeon_editor_v2.cc to keep that
// translation unit within the editor source-size guardrail. Class
// declaration lives in dungeon_editor_v2.h.
 
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <exception>
#include <iterator>
#include <memory>
#include <string>
#include <unordered_set>
#include <utility>
#include <vector>
#include "absl/status/status.h"
#include "absl/strings/str_format.h"
#include "absl/types/span.h"
#include "app/editor/agent/agent_ui_theme.h"
#include "app/editor/dungeon/dungeon_canvas_viewer.h"
#include "app/editor/dungeon/dungeon_room_store.h"
#include "app/editor/dungeon/inspectors/door_editor_content.h"
#include "app/editor/dungeon/inspectors/object_editor_content.h"
#include "app/editor/dungeon/inspectors/palette_editor_content.h"
#include "app/editor/dungeon/selectors/object_selector_content.h"
#include "app/editor/dungeon/ui/window/custom_collision_panel.h"
#include "app/editor/dungeon/ui/window/dungeon_entrance_list_panel.h"
#include "app/editor/dungeon/ui/window/dungeon_entrances_panel.h"
#include "app/editor/dungeon/ui/window/item_editor_panel.h"
#include "app/editor/dungeon/ui/window/minecart_track_editor_panel.h"
#include "app/editor/dungeon/ui/window/object_tile_editor_panel.h"
#include "app/editor/dungeon/ui/window/overlay_manager_panel.h"
#include "app/editor/dungeon/ui/window/room_tag_editor_panel.h"
#include "app/editor/dungeon/ui/window/sprite_editor_panel.h"
#include "app/editor/dungeon/ui/window/water_fill_panel.h"
#include "app/editor/dungeon/widgets/dungeon_status_bar.h"
#include "app/editor/dungeon/workspace/dungeon_workbench_content.h"
#include "app/editor/dungeon/workspace/room_browser_content.h"
#include "app/editor/dungeon/workspace/room_graphics_content.h"
#include "app/editor/dungeon/workspace/room_matrix_content.h"
#include "app/editor/editor_manager.h"
#include "app/editor/events/core_events.h"
#include "app/editor/graphics/graphics_editor.h"
#include "app/editor/menu/status_bar.h"
#include "app/editor/shell/feedback/toast_manager.h"
#include "app/editor/system/session/hack_manifest_save_validation.h"
#include "app/editor/system/session/user_settings.h"
#include "app/editor/system/workspace/workspace_window_manager.h"
#include "app/emu/mesen/mesen_client_registry.h"
#include "app/emu/mesen/mesen_socket_client.h"
#include "app/emu/render/emulator_render_service.h"
#include "app/gfx/backend/irenderer.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gfx/types/snes_tile.h"
#include "app/gfx/util/palette_manager.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/ui_config.h"
#include "core/features.h"
#include "core/project.h"
#include "dungeon_editor_v2.h"
#include "imgui/imgui.h"
#include "rom/snes.h"
#include "util/log.h"
#include "util/macro.h"
#include "zelda3/dungeon/custom_object.h"
#include "zelda3/dungeon/dungeon_editor_system.h"
#include "zelda3/dungeon/dungeon_rom_addresses.h"
#include "zelda3/dungeon/dungeon_validator.h"
#include "zelda3/dungeon/object_dimensions.h"
#include "zelda3/dungeon/room.h"
#include "zelda3/dungeon/water_fill_zone.h"
#include "zelda3/resource_labels.h"
 
namespace yaze::editor {
 
absl::Status DungeonEditorV2::Undo() {
  // Finalize any in-progress edit before undoing.
  if (pending_undo_.room_id >= 0) {
    FinalizeUndoAction(pending_undo_.room_id);
  }
  if (pending_collision_undo_.room_id >= 0) {
    FinalizeCollisionUndoAction(pending_collision_undo_.room_id);
  }
  if (pending_water_fill_undo_.room_id >= 0) {
    FinalizeWaterFillUndoAction(pending_water_fill_undo_.room_id);
  }
  const std::string description = undo_manager_.GetUndoDescription();
  undo_restore_triggered_ping_ = false;
  auto status = undo_manager_.Undo();
  if (status.ok()) {
    if (!undo_restore_triggered_ping_) {
      if (auto* viewer = GetViewerForRoom(current_room_id_)) {
        viewer->TriggerChangePing();
      }
    }
    if (dependencies_.toast_manager) {
      dependencies_.toast_manager->Show(
          description.empty() ? "Undid last dungeon edit"
                              : absl::StrFormat("Undid: %s", description),
          ToastType::kInfo, 2.0f);
    }
  }
  undo_restore_triggered_ping_ = false;
  return status;
}
 
absl::Status DungeonEditorV2::Redo() {
  // Finalize any in-progress edit before redoing.
  if (pending_undo_.room_id >= 0) {
    FinalizeUndoAction(pending_undo_.room_id);
  }
  if (pending_collision_undo_.room_id >= 0) {
    FinalizeCollisionUndoAction(pending_collision_undo_.room_id);
  }
  if (pending_water_fill_undo_.room_id >= 0) {
    FinalizeWaterFillUndoAction(pending_water_fill_undo_.room_id);
  }
  const std::string description = undo_manager_.GetRedoDescription();
  undo_restore_triggered_ping_ = false;
  auto status = undo_manager_.Redo();
  if (status.ok()) {
    if (!undo_restore_triggered_ping_) {
      if (auto* viewer = GetViewerForRoom(current_room_id_)) {
        viewer->TriggerChangePing();
      }
    }
    if (dependencies_.toast_manager) {
      dependencies_.toast_manager->Show(
          description.empty() ? "Redid last dungeon edit"
                              : absl::StrFormat("Redid: %s", description),
          ToastType::kInfo, 2.0f);
    }
  }
  undo_restore_triggered_ping_ = false;
  return status;
}
 
absl::Status DungeonEditorV2::Cut() {
  if (auto* viewer = GetViewerForRoom(current_room_id_)) {
    viewer->object_interaction().HandleCopySelected();
    viewer->object_interaction().HandleDeleteSelected();
  }
  return absl::OkStatus();
}
 
absl::Status DungeonEditorV2::Copy() {
  if (auto* viewer = GetViewerForRoom(current_room_id_)) {
    viewer->object_interaction().HandleCopySelected();
  }
  return absl::OkStatus();
}
 
absl::Status DungeonEditorV2::Paste() {
  if (auto* viewer = GetViewerForRoom(current_room_id_)) {
    viewer->object_interaction().HandlePasteObjects();
  }
  return absl::OkStatus();
}
 
void DungeonEditorV2::BeginUndoSnapshot(int room_id) {
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size()))
    return;
 
  // Detect leaked undo snapshots (double-Begin without Finalize).
  if (has_pending_undo_) {
    LOG_ERROR("DungeonEditor",
              "BeginUndoSnapshot called twice without FinalizeUndoAction. "
              "Previous snapshot for room %d is being leaked. Finalizing now.",
              pending_undo_.room_id);
    // Auto-finalize the leaked snapshot to prevent silent state loss.
    if (pending_undo_.room_id >= 0) {
      FinalizeUndoAction(pending_undo_.room_id);
    }
  }
 
  pending_undo_.room_id = room_id;
  pending_undo_.before_objects = rooms_[room_id].GetTileObjects();
  pending_undo_.before_selection.clear();
  if (auto* viewer = GetViewerForRoom(room_id);
      viewer &&
      (!IsWorkbenchWorkflowEnabled() || viewer->current_room_id() == room_id)) {
    pending_undo_.before_selection =
        viewer->object_interaction().GetSelectedObjectIndices();
  }
  has_pending_undo_ = true;
}
 
void DungeonEditorV2::FinalizeUndoAction(int room_id) {
  if (pending_undo_.room_id < 0 || pending_undo_.room_id != room_id)
    return;
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size()))
    return;
 
  auto after_objects = rooms_[room_id].GetTileObjects();
  std::vector<size_t> after_selection;
  if (auto* viewer = GetViewerForRoom(room_id);
      viewer &&
      (!IsWorkbenchWorkflowEnabled() || viewer->current_room_id() == room_id)) {
    after_selection = viewer->object_interaction().GetSelectedObjectIndices();
  }
 
  auto action = std::make_unique<DungeonObjectsAction>(
      room_id, std::move(pending_undo_.before_objects),
      std::move(pending_undo_.before_selection), std::move(after_objects),
      std::move(after_selection),
      [this](int rid, const std::vector<zelda3::RoomObject>& objects,
             const std::vector<size_t>& selected_indices) {
        RestoreRoomObjects(rid, objects, selected_indices);
      });
  undo_manager_.Push(std::move(action));
  if (minecart_track_editor_panel_) {
    minecart_track_editor_panel_->InvalidateRoomAudit();
  }
 
  pending_undo_.room_id = -1;
  pending_undo_.before_objects.clear();
  pending_undo_.before_selection.clear();
  has_pending_undo_ = false;
}
 
void DungeonEditorV2::RestoreRoomObjects(
    int room_id, const std::vector<zelda3::RoomObject>& objects,
    const std::vector<size_t>& selected_indices) {
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size()))
    return;
 
  auto& room = rooms_[room_id];
  const auto previous_objects = room.GetTileObjects();
  room.SetTileObjects(objects);
  room.RenderRoomGraphics();
  if (auto* viewer = GetViewerForRoom(room_id)) {
    std::vector<size_t> valid_selection;
    for (size_t index : selected_indices) {
      if (index < objects.size()) {
        valid_selection.push_back(index);
      }
    }
    if (!IsWorkbenchWorkflowEnabled() || viewer->current_room_id() == room_id) {
      viewer->object_interaction().SetSelectedObjects(valid_selection);
    }
    viewer->TriggerObjectChangePing(previous_objects, objects);
    undo_restore_triggered_ping_ = true;
  }
  if (minecart_track_editor_panel_) {
    minecart_track_editor_panel_->InvalidateRoomAudit();
  }
}
 
void DungeonEditorV2::BeginCollisionUndoSnapshot(int room_id) {
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size()))
    return;
 
  if (pending_collision_undo_.room_id >= 0) {
    FinalizeCollisionUndoAction(pending_collision_undo_.room_id);
  }
 
  pending_collision_undo_.room_id = room_id;
  pending_collision_undo_.before = rooms_[room_id].custom_collision();
}
 
void DungeonEditorV2::FinalizeCollisionUndoAction(int room_id) {
  if (pending_collision_undo_.room_id < 0 ||
      pending_collision_undo_.room_id != room_id) {
    return;
  }
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size()))
    return;
 
  auto after = rooms_[room_id].custom_collision();
  if (pending_collision_undo_.before.has_data == after.has_data &&
      pending_collision_undo_.before.tiles == after.tiles) {
    pending_collision_undo_.room_id = -1;
    pending_collision_undo_.before = {};
    return;
  }
 
  auto action = std::make_unique<DungeonCustomCollisionAction>(
      room_id, std::move(pending_collision_undo_.before), std::move(after),
      [this](int rid, const zelda3::CustomCollisionMap& map) {
        RestoreRoomCustomCollision(rid, map);
      });
  undo_manager_.Push(std::move(action));
  if (minecart_track_editor_panel_) {
    minecart_track_editor_panel_->InvalidateRoomAudit();
  }
 
  pending_collision_undo_.room_id = -1;
  pending_collision_undo_.before = {};
}
 
void DungeonEditorV2::RestoreRoomCustomCollision(
    int room_id, const zelda3::CustomCollisionMap& map) {
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size()))
    return;
 
  auto& room = rooms_[room_id];
  room.custom_collision() = map;
  room.MarkCustomCollisionDirty();
  if (minecart_track_editor_panel_) {
    minecart_track_editor_panel_->InvalidateRoomAudit();
  }
}
 
namespace {
 
bool HasAnyCustomCollision(const zelda3::CustomCollisionMap& map) {
  return map.has_data || std::any_of(map.tiles.begin(), map.tiles.end(),
                                     [](uint8_t tile) { return tile != 0; });
}
 
bool CollisionMapsEqual(const zelda3::CustomCollisionMap& lhs,
                        const zelda3::CustomCollisionMap& rhs) {
  return lhs.has_data == rhs.has_data && lhs.tiles == rhs.tiles;
}
 
struct CollisionRollbackEntry {
  zelda3::Room* room = nullptr;
  zelda3::CustomCollisionMap map;
  bool dirty = false;
};
 
class CollisionBatchRollback {
 public:
  explicit CollisionBatchRollback(std::vector<CollisionRollbackEntry> entries)
      : entries_(std::move(entries)) {}
 
  ~CollisionBatchRollback() {
    if (committed_) {
      return;
    }
    for (const auto& entry : entries_) {
      entry.room->custom_collision() = entry.map;
      if (entry.dirty) {
        entry.room->MarkCustomCollisionDirty();
      } else {
        entry.room->ClearCustomCollisionDirty();
      }
    }
  }
 
  void Commit() { committed_ = true; }
 
 private:
  std::vector<CollisionRollbackEntry> entries_;
  bool committed_ = false;
};
 
}  // namespace
 
absl::Status DungeonEditorV2::ApplyMinecartCollisionBatch(
    const std::vector<zelda3::TrackCollisionResult>& preview,
    const zelda3::GeneratorOptions& options) {
  if (preview.empty()) {
    return absl::InvalidArgumentError("Minecart collision preview is empty");
  }
 
  std::unordered_set<int> seen_room_ids;
  std::vector<DungeonCustomCollisionSnapshot> before;
  std::vector<DungeonCustomCollisionSnapshot> after;
  std::vector<CollisionRollbackEntry> rollback_entries;
  before.reserve(preview.size());
  after.reserve(preview.size());
  rollback_entries.reserve(preview.size());
 
  // Validate the complete batch before changing rooms or undo history.
  for (const auto& expected : preview) {
    const int room_id = expected.room_id;
    if (!IsValidRoomId(room_id)) {
      return absl::OutOfRangeError(absl::StrFormat(
          "Minecart collision room 0x%03X is out of range", room_id));
    }
    if (!seen_room_ids.insert(room_id).second) {
      return absl::InvalidArgumentError(absl::StrFormat(
          "Minecart collision preview contains duplicate room 0x%03X",
          room_id));
    }
 
    zelda3::Room* room = rooms_.GetIfMaterialized(room_id);
    if (room == nullptr) {
      return absl::FailedPreconditionError(absl::StrFormat(
          "Minecart collision room 0x%03X is not loaded", room_id));
    }
    if (HasAnyCustomCollision(room->custom_collision())) {
      return absl::FailedPreconditionError(absl::StrFormat(
          "Room 0x%03X already has custom collision; generation will not "
          "replace it",
          room_id));
    }
 
    ASSIGN_OR_RETURN(auto current,
                     zelda3::GenerateTrackCollision(room, options));
    current.room_id = room_id;
    if (!current.collision_map.has_data || current.tiles_generated <= 0) {
      return absl::FailedPreconditionError(absl::StrFormat(
          "Room 0x%03X no longer contains supported minecart track pieces",
          room_id));
    }
    if (!CollisionMapsEqual(current.collision_map, expected.collision_map) ||
        current.tiles_generated != expected.tiles_generated ||
        current.stop_count != expected.stop_count ||
        current.corner_count != expected.corner_count ||
        current.switch_count != expected.switch_count) {
      return absl::FailedPreconditionError(absl::StrFormat(
          "Minecart collision preview for room 0x%03X is stale; preview "
          "again before applying",
          room_id));
    }
 
    before.push_back({room_id, room->custom_collision()});
    after.push_back({room_id, current.collision_map});
    rollback_entries.push_back(
        {room, room->custom_collision(), room->custom_collision_dirty()});
  }
 
  if (pending_undo_.room_id >= 0 || pending_collision_undo_.room_id >= 0 ||
      pending_water_fill_undo_.room_id >= 0) {
    return absl::FailedPreconditionError(
        "Finish the current dungeon edit before applying minecart collision");
  }
 
  auto action = std::make_unique<DungeonCustomCollisionBatchAction>(
      before, after,
      [this](const std::vector<DungeonCustomCollisionSnapshot>& snapshots) {
        return RestoreRoomCustomCollisionBatch(snapshots);
      });
 
  CollisionBatchRollback rollback(std::move(rollback_entries));
  for (const auto& snapshot : after) {
    auto* room = rooms_.GetIfMaterialized(snapshot.room_id);
    room->custom_collision() = snapshot.map;
    room->MarkCustomCollisionDirty();
  }
  try {
    undo_manager_.Push(std::move(action));
  } catch (const std::exception& error) {
    return absl::InternalError(absl::StrFormat(
        "Could not record minecart collision undo: %s", error.what()));
  }
  rollback.Commit();
  if (minecart_track_editor_panel_) {
    minecart_track_editor_panel_->InvalidateRoomAudit();
  }
 
  for (const auto& snapshot : after) {
    if (auto* viewer = GetViewerForRoom(snapshot.room_id)) {
      viewer->TriggerChangePing();
    }
  }
  return absl::OkStatus();
}
 
absl::Status DungeonEditorV2::RestoreRoomCustomCollisionBatch(
    const std::vector<DungeonCustomCollisionSnapshot>& snapshots) {
  std::unordered_set<int> seen_room_ids;
  for (const auto& snapshot : snapshots) {
    if (!IsValidRoomId(snapshot.room_id)) {
      return absl::OutOfRangeError("Collision undo room ID is out of range");
    }
    if (!seen_room_ids.insert(snapshot.room_id).second) {
      return absl::InvalidArgumentError(
          "Collision undo contains a duplicate room ID");
    }
    if (rooms_.GetIfMaterialized(snapshot.room_id) == nullptr) {
      return absl::FailedPreconditionError(
          "Collision undo target room is not loaded");
    }
  }
 
  for (const auto& snapshot : snapshots) {
    auto& room = *rooms_.GetIfMaterialized(snapshot.room_id);
    room.custom_collision() = snapshot.map;
    room.MarkCustomCollisionDirty();
    if (auto* viewer = GetViewerForRoom(snapshot.room_id)) {
      viewer->TriggerChangePing();
      undo_restore_triggered_ping_ = true;
    }
  }
  if (minecart_track_editor_panel_) {
    minecart_track_editor_panel_->InvalidateRoomAudit();
  }
  return absl::OkStatus();
}
 
namespace {
 
WaterFillSnapshot MakeWaterFillSnapshot(const zelda3::Room& room) {
  WaterFillSnapshot snap;
  snap.sram_bit_mask = room.water_fill_sram_bit_mask();
 
  const auto& zone = room.water_fill_zone();
  // Preserve deterministic ordering (ascending offsets) for stable diffs.
  for (size_t i = 0; i < zone.tiles.size(); ++i) {
    if (zone.tiles[i] != 0) {
      snap.offsets.push_back(static_cast<uint16_t>(i));
    }
  }
  return snap;
}
 
}  // namespace
 
void DungeonEditorV2::BeginWaterFillUndoSnapshot(int room_id) {
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size()))
    return;
 
  if (pending_water_fill_undo_.room_id >= 0) {
    FinalizeWaterFillUndoAction(pending_water_fill_undo_.room_id);
  }
 
  pending_water_fill_undo_.room_id = room_id;
  pending_water_fill_undo_.before = MakeWaterFillSnapshot(rooms_[room_id]);
}
 
void DungeonEditorV2::FinalizeWaterFillUndoAction(int room_id) {
  if (pending_water_fill_undo_.room_id < 0 ||
      pending_water_fill_undo_.room_id != room_id) {
    return;
  }
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size()))
    return;
 
  auto after = MakeWaterFillSnapshot(rooms_[room_id]);
  if (pending_water_fill_undo_.before.sram_bit_mask == after.sram_bit_mask &&
      pending_water_fill_undo_.before.offsets == after.offsets) {
    pending_water_fill_undo_.room_id = -1;
    pending_water_fill_undo_.before = {};
    return;
  }
 
  auto action = std::make_unique<DungeonWaterFillAction>(
      room_id, std::move(pending_water_fill_undo_.before), std::move(after),
      [this](int rid, const WaterFillSnapshot& snap) {
        RestoreRoomWaterFill(rid, snap);
      });
  undo_manager_.Push(std::move(action));
 
  pending_water_fill_undo_.room_id = -1;
  pending_water_fill_undo_.before = {};
}
 
void DungeonEditorV2::RestoreRoomWaterFill(int room_id,
                                           const WaterFillSnapshot& snap) {
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size()))
    return;
 
  auto& room = rooms_[room_id];
  room.ClearWaterFillZone();
  room.set_water_fill_sram_bit_mask(snap.sram_bit_mask);
  for (uint16_t off : snap.offsets) {
    const int x = static_cast<int>(off % 64);
    const int y = static_cast<int>(off / 64);
    room.SetWaterFillTile(x, y, /*filled=*/true);
  }
  room.MarkWaterFillDirty();
}
 
}  // namespace yaze::editor