interaction_context.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_DUNGEON_INTERACTION_INTERACTION_CONTEXT_H_
#define YAZE_APP_EDITOR_DUNGEON_INTERACTION_INTERACTION_CONTEXT_H_
 
#include <array>
#include <cstdint>
#include <functional>
#include <optional>
 
#include "absl/status/status.h"
#include "app/editor/dungeon/dungeon_coordinates.h"
#include "app/editor/dungeon/dungeon_room_store.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gui/canvas/canvas.h"
#include "rom/rom.h"
#include "zelda3/dungeon/room.h"
 
namespace yaze {
namespace editor {
 
class ObjectSelection;
struct DungeonSelectionEditPlan;
 
enum class EntityType {
  None,
  Object,  // Room tile objects
  Door,    // Door entities
  Sprite,  // Enemy/NPC sprites
  Item     // Pot items
};
 
enum class MutationDomain : uint8_t {
  kUnknown = 0,
  kTileObjects,
  kDoors,
  kSprites,
  kItems,
  kCustomCollision,
  kWaterFill,
};
 
struct SelectedEntity {
  EntityType type = EntityType::None;
  size_t index = 0;  // Index into the respective container
 
  bool operator==(const SelectedEntity& other) const {
    return type == other.type && index == other.index;
  }
};
 
struct InteractionContext {
  // Core dependencies (required)
  gui::Canvas* canvas = nullptr;
  Rom* rom = nullptr;
  DungeonRoomStore* rooms = nullptr;
  int current_room_id = 0;
  ObjectSelection* selection = nullptr;
 
  // Palette for rendering previews
  gfx::PaletteGroup current_palette_group;
 
  // Unified callbacks
  // A complete, validated selection edit is published by the editor as one
  // undo action. Continuous edits share a gesture until the finish callback.
  std::function<absl::Status(const DungeonSelectionEditPlan&, bool continuous)>
      on_selection_edit;
  std::function<void()> on_selection_edit_finished;
  std::function<void(const absl::Status&)> on_selection_edit_error;
 
  // Called before any state modification (for undo snapshots)
  std::function<void()> on_mutation;
 
  // Called after rendering changes require cache refresh
  std::function<void()> on_invalidate_cache;
 
  // Called when selection state changes
  std::function<void()> on_selection_changed;
 
  // Called when entity (door/sprite/item) changes
  std::function<void()> on_entity_changed;
 
  // View-derived eligibility for tile-object selection. This is intentionally
  // separate from ObjectSelection's explicit stored-layer filter: hiding BG1
  // or BG2 must remove that content from canvas hit-testing without changing
  // which stored object stream the user chose to target.
  std::function<bool(int, const zelda3::RoomObject&)>
      is_object_visible_for_selection;
 
  // Called when an interactive door-pair badge requests navigation to the
  // adjacent room. The optional door index is in the target room.
  std::function<void(int target_room_id,
                     std::optional<size_t> target_door_index, int target_tile_x,
                     int target_tile_y)>
      on_door_pair_navigation;
 
  // Last mutation/invalidation domain (best-effort). Set by Notify* helpers so
  // the editor can route undo capture and expensive rerenders appropriately.
  mutable MutationDomain last_mutation_domain = MutationDomain::kUnknown;
  mutable MutationDomain last_invalidation_domain = MutationDomain::kUnknown;
 
  bool IsValid() const { return canvas != nullptr && rooms != nullptr; }
 
  zelda3::Room* GetCurrentRoom() const {
    if (!rooms || !dungeon_coords::IsValidRoomId(current_room_id)) {
      return nullptr;
    }
    return &(*rooms)[current_room_id];
  }
 
  const zelda3::Room* GetCurrentRoomConst() const {
    if (!rooms || !dungeon_coords::IsValidRoomId(current_room_id)) {
      return nullptr;
    }
    return &(*rooms)[current_room_id];
  }
 
  bool IsObjectVisibleForSelection(const zelda3::RoomObject& object) const {
    return !is_object_visible_for_selection ||
           is_object_visible_for_selection(current_room_id, object);
  }
 
  void NotifyMutation(MutationDomain domain = MutationDomain::kUnknown) const {
    last_mutation_domain = domain;
    if (on_mutation)
      on_mutation();
  }
 
  void NotifyInvalidateCache(
      MutationDomain domain = MutationDomain::kUnknown) const {
    last_invalidation_domain = domain;
    if (on_invalidate_cache)
      on_invalidate_cache();
  }
 
  void NotifySelectionChanged() const {
    if (on_selection_changed)
      on_selection_changed();
  }
 
  void NotifyEntityChanged() const {
    if (on_entity_changed)
      on_entity_changed();
  }
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_DUNGEON_INTERACTION_INTERACTION_CONTEXT_H_