session_types.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_SESSION_TYPES_H_
#define YAZE_APP_EDITOR_SESSION_TYPES_H_
 
#include <array>
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "app/editor/code/project_file_editor.h"
#include "app/editor/editor.h"
#include "app/editor/graphics/gfx_group_workspace_state.h"
#include "core/asar_wrapper.h"  // For AsarSymbol (backend-agnostic symbol shape)
#include "core/features.h"
#include "core/project.h"
#include "rom/rom.h"
#include "util/rom_hash.h"
#include "zelda3/game_data.h"
 
namespace yaze::core {
class AsarWrapper;
class VersionManager;
}  // namespace yaze::core
 
namespace yaze::zelda3 {
class Overworld;
}
 
namespace yaze::editor {
 
class EditorDependencies;
class EditorRegistry;
class UserSettings;
 
// Forward declarations for legacy accessors
class AssemblyEditor;
class MemoryEditor;
class DungeonEditorV2;
class GraphicsEditor;
class ScreenEditor;
class MessageEditor;
class MusicEditor;
class OverworldEditor;
class PaletteEditor;
class SpriteEditor;
class SettingsPanel;
 
class EditorSet {
 public:
  explicit EditorSet(Rom* rom = nullptr, zelda3::GameData* game_data = nullptr,
                     UserSettings* user_settings = nullptr,
                     size_t session_id = 0,
                     EditorRegistry* editor_registry = nullptr);
  ~EditorSet();
 
  void set_user_settings(UserSettings* settings);
  void SetGameData(zelda3::GameData* game_data);
 
  void ApplyDependencies(const EditorDependencies& dependencies);
 
  // Give materialized editors one terminal detach pass while their external
  // WorkspaceWindowManager panels are still alive.
  void PrepareForSessionTeardown();
 
  size_t session_id() const { return session_id_; }
 
  // Generic accessors
  Editor* GetEditor(EditorType type) const;
  // Returns an already-created editor without materializing a lazy editor.
  Editor* GetExistingEditor(EditorType type) const { return FindEditor(type); }
 
  template <typename T>
  T* GetEditorAs(EditorType type) const {
    return static_cast<T*>(GetEditor(type));
  }
 
  // Convenience helpers that avoid requiring concrete editor headers.
  // Prefer these from higher-level systems (EditorManager, UI) to keep compile
  // dependencies minimal.
  void OpenAssemblyFolder(const std::string& folder_path) const;
  void ChangeActiveAssemblyFile(std::string_view path) const;
  core::AsarWrapper* GetAsarWrapper() const;
 
  // Backend-agnostic accessor for assembly symbols (works for both Asar
  // and z3dk backends). Returns the assembly editor's last-known symbol
  // table. Empty if no editor / no assemble has happened yet.
  const std::map<std::string, core::AsarSymbol>& GetAssemblySymbols() const;
  int LoadedDungeonRoomCount() const;
  int TotalDungeonRoomCount() const;
  std::vector<std::pair<uint32_t, uint32_t>> CollectDungeonWriteRanges() const;
  bool HasPendingGraphicsChanges() const;
  bool HasPendingScreenChanges() const;
  // Reset cached Screen Editor models only when that lazy editor already
  // exists. ROM replacement must not materialize an otherwise-unused editor.
  void InvalidateScreenRomBackedState();
  bool HasPendingProjectDraftChanges() const;
  absl::Status PrepareProjectSave();
  zelda3::Overworld* GetOverworldData() const;
 
  // Deprecated named accessors (legacy compatibility)
  [[deprecated("Use GetEditorAs<AssemblyEditor>(EditorType::kAssembly)")]]
  AssemblyEditor* GetAssemblyEditor() const;
  [[deprecated("Use GetEditorAs<DungeonEditorV2>(EditorType::kDungeon)")]]
  DungeonEditorV2* GetDungeonEditor() const;
  [[deprecated("Use GetEditorAs<GraphicsEditor>(EditorType::kGraphics)")]]
  GraphicsEditor* GetGraphicsEditor() const;
  [[deprecated("Use GetEditorAs<MusicEditor>(EditorType::kMusic)")]]
  MusicEditor* GetMusicEditor() const;
  [[deprecated("Use GetEditorAs<OverworldEditor>(EditorType::kOverworld)")]]
  OverworldEditor* GetOverworldEditor() const;
  [[deprecated("Use GetEditorAs<PaletteEditor>(EditorType::kPalette)")]]
  PaletteEditor* GetPaletteEditor() const;
  [[deprecated("Use GetEditorAs<ScreenEditor>(EditorType::kScreen)")]]
  ScreenEditor* GetScreenEditor() const;
  [[deprecated("Use GetEditorAs<SpriteEditor>(EditorType::kSprite)")]]
  SpriteEditor* GetSpriteEditor() const;
  [[deprecated("Use GetEditorAs<SettingsPanel>(EditorType::kSettings)")]]
  SettingsPanel* GetSettingsPanel() const;
  [[deprecated("Use GetEditorAs<MessageEditor>(EditorType::kMessage)")]]
  MessageEditor* GetMessageEditor() const;
  [[deprecated("Use GetEditorAs<MemoryEditor>(EditorType::kHex)")]]
  MemoryEditor* GetMemoryEditor() const;
 
  GfxGroupWorkspaceState* gfx_group_workspace() {
    return gfx_group_workspace_.get();
  }
  const GfxGroupWorkspaceState* gfx_group_workspace() const {
    return gfx_group_workspace_.get();
  }
 
  std::vector<Editor*> active_editors_;
 
 private:
  using EditorFactory = std::function<std::unique_ptr<Editor>()>;
 
  Editor* FindEditor(EditorType type) const;
  Editor* EnsureEditorCreated(EditorType type) const;
  bool ShouldTrackAsActiveEditor(EditorType type) const;
  void TrackActiveEditor(Editor* editor);
 
  size_t session_id_ = 0;
  Rom* rom_ = nullptr;
  zelda3::GameData* game_data_ = nullptr;
  UserSettings* user_settings_ = nullptr;
  EditorRegistry* editor_registry_ = nullptr;
 
  std::optional<EditorDependencies> dependencies_;
  mutable std::unordered_map<EditorType, std::unique_ptr<Editor>> editors_;
  std::unordered_map<EditorType, EditorFactory> editor_factories_;
  bool session_teardown_prepared_ = false;
 
  std::unique_ptr<GfxGroupWorkspaceState> gfx_group_workspace_;
};
 
struct RomBaselineIdentity {
  util::RomIdentityHashes hashes;
  std::string normalized_path;
  // Retained across our own saves, reset when loading/replacing ROM bytes.
  std::string editing_source_path;
};
 
struct RomSession {
  Rom rom;
  // Identity of loaded/committed bytes, independent of pending raw/model edits.
  // Empty sessions have no baseline. Session activation must never capture it.
  std::optional<RomBaselineIdentity> rom_baseline;
  void CaptureRomIdentity(bool preserve_editing_source = false);
 
  zelda3::GameData game_data;
  // Display copies have stable addresses across user and per-frame activation.
  // Authored pixels remain in game_data.sheet_store; loaded palette colors stay
  // in game_data.gfx_bitmaps. Allocate only after graphics are loaded.
  void ReloadGraphicsDisplay();
  void ActivateGraphicsDisplay();
  void ResetGraphicsDisplay();
 
  EditorSet editors;
  std::string custom_name;  // User-defined session name
  std::string filepath;     // ROM filepath for duplicate detection
  core::FeatureFlags::Flags feature_flags;  // Per-session feature flags
  // Full project/save policy snapshot for this ROM. An empty optional means
  // the session has not yet been bound to a project context and must not save.
  std::optional<project::YazeProject> project_context;
  bool project_dirty = false;
 
  // True when the gfx group tables (blocksets, spritesets, palettesets) in
  // game_data differ from the ROM buffer. Derived from the data, so every
  // edit path counts without extra dirty flags.
  bool HasPendingGfxGroupChanges() const;
  // A restored backup is staged for inspection and must never be committed by
  // the periodic autosave path. Explicit Save ROM / Save As clears this flag.
  bool backup_restore_pending = false;
  ProjectFileEditorState project_file_editor_state;
  // VersionManager keeps a raw project pointer internally, so its lifetime
  // must be tied to the stable, session-owned project_context above. Editors
  // cache this pointer for their entire lifetime.
  std::unique_ptr<core::VersionManager> version_manager;
  bool game_data_loaded = false;
  std::array<bool, kEditorTypeCount> editor_initialized{};
  std::array<bool, kEditorTypeCount> editor_assets_loaded{};
 
  RomSession() = default;
  RomSession(UserSettings* user_settings, size_t session_id,
             EditorRegistry* editor_registry = nullptr);
  explicit RomSession(Rom&& r, UserSettings* user_settings = nullptr,
                      size_t session_id = 0,
                      EditorRegistry* editor_registry = nullptr);
  ~RomSession();
 
 private:
  std::unique_ptr<std::array<gfx::Bitmap, zelda3::kNumGfxSheets>>
      graphics_display_;
 
 public:
  size_t session_id() const { return editors.session_id(); }
 
  // Get display name (custom name or ROM title)
  std::string GetDisplayName() const;
};
 
}  // namespace yaze::editor
 
#endif  // YAZE_APP_EDITOR_SESSION_TYPES_H_