Namespace MoonBark.GridPlacement.Core.Interfaces
Classes
- CacheMetrics
Cache performance metrics.
- ExternalSourceMetadata
Metadata about external data sources. Used by placeable data providers and related adapters.
- Result<T>
Lightweight generic result type used by integration-facing interfaces such as IPlaceableInventoryAdapter and IPlaceablePersistenceAdapter.
- UserScopeData
Simple data container for user scope information.
Structs
- MoveGhostState
Represents the current state of a move ghost entity.
- ValidationComponent
Pure domain validation component for placement validation results. No ECS dependencies.
Interfaces
- IBuildingConfiguration
Interface for building configuration
- ICache
Simplified cache interface for string keys (most common use case).
- ICache<TKey, TValue>
Generic cache interface for Core components. Provides unified caching functionality with dependency injection support.
- IDefinitionAsset
Engine-agnostic definition asset abstraction. Prefer this for domain modeling; IResource remains as the underlying contract.
- IEffectsSink
Interface for visual effects in the placement system. Handles preview rendering, feedback effects, and visual indicators.
- IGridBuildingSession
Represents a GridBuilding session (match/world) in Core. Provides access to shared services and user scopes. This is intentionally minimal and engine-agnostic; Godot roots or other hosts can adapt it to their own lifetime model.
- IGridCalculator
Interface for grid calculation operations.
- IGridConfiguration
Core interface defining physical grid boundaries and layout metadata.
- IGridPlacementComponent
Pure C# interface for grid placement components. No Godot dependencies - can be unit tested without engine. Godot-specific extensions are in MoonBark.GridPlacement.Godot.Interfaces.
- IGridPlacementConfiguration
Configuration interface for grid placement settings.
- IGridPlacementCore
Façade interface for core grid placement operations. ZERO Friflo dependencies — implementations may wrap ECS internally but this interface is engine-agnostic.
- IGridPositioner
Represents a positioning reference for grid-based placement.
- IGridTargetingSystem
Core interface for the grid targeting system. Handles grid-based position targeting and snapping.
- IGridTile
Specialized interface for tile-based placements. Represents a direct modification of a grid/TileMap rather than a scene object.
Core concept: TileTypeId identifies the semantic tile type (e.g., "grass", "water"). The actual Godot tile coordinates (TileSetId, SourceId, AtlasCoords) are resolved by TileTypeMapping in the moonbark-idle layer at runtime.
Boundary: Core knows only TileTypeId. Godot-specific mapping stays in moonbark-idle.
- IIndicatorTemplate
Represents a template for creating rule check indicators.
- IManipulation
Interface for manipulation operations exposed by the manipulation system. Used by the Godot layer to trigger placement operations without depending on ECS types.
All methods that take an EntityStore parameter are internal ECS details hidden behind this interface. The Godot layer uses the overloads without EntityStore, which use the internal store reference.
- IManipulationSystem
Interface for manipulation system
- IMapLayer
Generic abstraction for a grid-based map layer. GridPlacement has no reference to Tiled or any specific map format.
- IPlaceable
Common interface for all placeable implementations.
Provides a contract that both engine-agnostic (POCS) and engine-specific implementations must follow, enabling interchangeability while maintaining clean separation between core logic and engine-specific functionality.
Implementation pattern: - Core.Placeable: Pure C# implementation for UI and logic - Godot.GodotPlaceableWrapper: Wraps core + adds Godot-specific methods - Future engines can add their own wrappers
- IPlaceableDataProvider
Interface for loading placeable data from external sources
- IPlacementContext
Core interface for placement context operations. Provides access to grid configuration without engine-specific dependencies. This interface is engine-agnostic and can be implemented by Godot, Unity, or other engine adapters.
- IPlacementExecution
Interface for placement execution events exposed to the Godot layer. Used by PlacementSceneAdapter to subscribe to placement events without depending on ECS types.
- IPlacementInputBridge
Defines the boundary for placement input operations. Exposes actions necessary for external systems (like Godot UIs or AI) to interact with the core ECS placement pipeline.
- IPlacementPreview
Interface for placement preview events exposed to the Godot layer. Used by PlacementSceneAdapter to subscribe to preview events without depending on ECS types.
- IPlacementRule
Interface for placement rules, enabling POCS testing of validation logic without Godot dependencies.
In Godot, this maps to PlacementRule (extends Resource). In C# tests, we can use MockPlacementRule.
- IPlacementValidator
Interface for placement validation. Implementations validate placement requests based on rules, occupancy, and configuration.
- IResolver<TInput, TOutput>
Base resolver interface for resolving inputs to outputs
- IRuleIndicatorServices
Engine-agnostic facade for rule indicator queries.
Implementations live in adapter layers (Godot, Unity, etc.) and expose a small surface for leaf adapters (visual indicators) to ask:
- "Is this grid position valid under the current placement rules?"
- "Give me a validation result for this grid position."
This must remain free of engine types so that the same contract can be implemented by different plugin frontends.
- IRuntimeCheckable
Pure C# interface for runtime issue checking. Returns list of validation issue messages.
- IRuntimeChecks
Interface for runtime checks and validation. Mirrors functionality from GDScript runtime_checks.gd
- IServiceCompositionRoot
Interface for service composition root to enable Godot-free dependency injection
- IStateComponent
Interface for state management components. Provides access to state data and state change notifications.
- ITargeting
Interface for targeting state exposed by the targeting service. Used by the Godot layer to get current targeting information without depending on ECS types.
Enums
- CacheEvictionPolicy
Cache eviction policies.