@nice2dev/game-engine 1.1.5 → 1.1.6

package/dist/types/systems/TerrainSystem.d.ts

@@ -0,0 +1,290 @@
+/**
+ * @file TerrainSystem.ts
+ * @description Advanced Terrain System with Heightmap, Splatmap, and Foliage
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Heightmap terrain with LOD
+ * - Splatmap texture blending (up to 8 layers)
+ * - Foliage scattering (grass, trees, rocks)
+ * - Terrain brushes (raise, lower, smooth, flatten, noise, erosion)
+ * - Procedural generation (Perlin noise, diamond-square, hydraulic erosion)
+ * - Holes/caves support
+ * - Detail meshes and decals
+ * - Terrain chunks with streaming
+ * - Physics collision mesh generation
+ */
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Color {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export interface TerrainConfig {
+    /** Width of terrain in world units */
+    width: number;
+    /** Depth of terrain in world units */
+    depth: number;
+    /** Maximum height of terrain */
+    maxHeight: number;
+    /** Resolution of heightmap (vertices per side) */
+    heightmapResolution: number;
+    /** Resolution of splatmap (pixels per side) */
+    splatmapResolution: number;
+    /** Number of chunks per side */
+    chunksPerSide: number;
+    /** Detail resolution for grass/detail meshes */
+    detailResolution: number;
+    /** Detail resolution per patch */
+    detailResolutionPerPatch: number;
+    /** Base texture tiling */
+    basemapDistance: number;
+    /** Cast shadows */
+    castShadows: boolean;
+    /** Draw instanced */
+    drawInstanced: boolean;
+}
+export declare const DEFAULT_TERRAIN_CONFIG: TerrainConfig;
+export interface TerrainLayer {
+    id: string;
+    name: string;
+    /** Diffuse/Albedo texture ID */
+    diffuseTexture: string;
+    /** Normal map texture ID */
+    normalTexture?: string;
+    /** Mask texture (R=metallic, G=AO, B=height, A=smoothness) */
+    maskTexture?: string;
+    /** Tiling (UV scale) */
+    tileSize: Vec2;
+    /** Offset */
+    tileOffset: Vec2;
+    /** Metallic value (if no mask texture) */
+    metallic: number;
+    /** Smoothness value (if no mask texture) */
+    smoothness: number;
+    /** Specular color */
+    specularColor: Color;
+    /** Normal scale */
+    normalScale: number;
+    /** Diffuse remix (for color variation) */
+    diffuseRemapMin: Color;
+    diffuseRemapMax: Color;
+    /** Mask remix */
+    maskRemapMin: Color;
+    maskRemapMax: Color;
+}
+export declare function createTerrainLayer(id: string, name: string, diffuseTexture: string): TerrainLayer;
+export type DetailRenderMode = 'grass' | 'vertexLit' | 'grassBillboard';
+export interface DetailPrototype {
+    id: string;
+    name: string;
+    /** Mesh ID for mesh-based details, or null for grass billboards */
+    meshId?: string;
+    /** Texture ID for grass billboards */
+    textureId?: string;
+    /** Render mode */
+    renderMode: DetailRenderMode;
+    /** Use instancing */
+    useInstancing: boolean;
+    /** Health color (tinting) */
+    healthyColor: Color;
+    /** Dry color (tinting) */
+    dryColor: Color;
+    /** Minimum width */
+    minWidth: number;
+    /** Maximum width */
+    maxWidth: number;
+    /** Minimum height */
+    minHeight: number;
+    /** Maximum height */
+    maxHeight: number;
+    /** Noise spread */
+    noiseSpread: number;
+    /** Density */
+    density: number;
+    /** Align to ground normal */
+    alignToGround: number;
+    /** Position jitter */
+    positionJitter: number;
+    /** Hole edge padding */
+    holeEdgePadding: number;
+}
+export declare function createGrassDetail(id: string, name: string, textureId: string): DetailPrototype;
+export interface TreePrototype {
+    id: string;
+    name: string;
+    /** Mesh ID for tree model */
+    meshId: string;
+    /** LOD meshes (distance → mesh ID) */
+    lodMeshes: {
+        distance: number;
+        meshId: string;
+    }[];
+    /** Billboard texture for far LOD */
+    billboardTexture?: string;
+    /** Bend factor for wind */
+    bendFactor: number;
+    /** Minimum scale */
+    minScale: number;
+    /** Maximum scale */
+    maxScale: number;
+    /** Random rotation */
+    randomRotation: boolean;
+    /** Align to ground */
+    alignToGround: number;
+    /** Nav mesh area (for pathfinding) */
+    navMeshArea: number;
+}
+export declare function createTreePrototype(id: string, name: string, meshId: string): TreePrototype;
+export interface TreeInstance {
+    position: Vec3;
+    rotation: number;
+    scale: Vec3;
+    prototypeId: string;
+    color: Color;
+    lightmapColor: Color;
+}
+export type TerrainBrushType = 'raise' | 'lower' | 'flatten' | 'smooth' | 'noise' | 'erosion' | 'paint' | 'paintHoles' | 'stampHeight' | 'bridge' | 'clone';
+export interface TerrainBrush {
+    type: TerrainBrushType;
+    /** Size in world units */
+    size: number;
+    /** Strength (0-1) */
+    strength: number;
+    /** Falloff curve (0 = hard edge, 1 = smooth falloff) */
+    falloff: number;
+    /** Rotation in degrees */
+    rotation: number;
+    /** For stamp/clone: source position */
+    sourcePosition?: Vec3;
+    /** For paint: layer index */
+    layerIndex?: number;
+    /** For flatten: target height */
+    targetHeight?: number;
+    /** For noise: noise parameters */
+    noiseScale?: number;
+    noiseOctaves?: number;
+    /** Brush shape texture ID (grayscale) */
+    brushTexture?: string;
+    /** Jitter */
+    spacingJitter: number;
+    /** Scatter */
+    scatter: number;
+}
+export declare const DEFAULT_BRUSH: TerrainBrush;
+export interface TerrainChunk {
+    id: string;
+    /** Grid position */
+    gridX: number;
+    gridZ: number;
+    /** World bounds */
+    boundsMin: Vec3;
+    boundsMax: Vec3;
+    /** Is loaded */
+    isLoaded: boolean;
+    /** Current LOD level */
+    lodLevel: number;
+    /** Mesh ID */
+    meshId?: string;
+    /** Collision mesh ID */
+    collisionMeshId?: string;
+}
+export interface TerrainData {
+    id: string;
+    name: string;
+    config: TerrainConfig;
+    /** Heightmap data (normalized 0-1) */
+    heightmap: Float32Array;
+    /** Splatmap data (up to 2 textures, each RGBA for 4 layers = 8 total) */
+    splatmaps: Uint8Array[];
+    /** Hole map (1 = solid, 0 = hole) */
+    holemap: Uint8Array;
+    /** Terrain layers (textures) */
+    layers: TerrainLayer[];
+    /** Detail prototypes (grass, etc.) */
+    detailPrototypes: DetailPrototype[];
+    /** Detail density maps (one per prototype) */
+    detailMaps: Uint8Array[];
+    /** Tree prototypes */
+    treePrototypes: TreePrototype[];
+    /** Tree instances */
+    trees: TreeInstance[];
+    /** Chunks */
+    chunks: TerrainChunk[];
+    /** Metadata */
+    metadata: {
+        createdAt: number;
+        modifiedAt: number;
+        version: number;
+    };
+}
+export declare class TerrainSystem {
+    private data;
+    private undoStack;
+    private redoStack;
+    private maxUndoSteps;
+    constructor(config?: Partial<TerrainConfig>);
+    private createEmptyTerrain;
+    /** Get height at grid coordinates (0 to resolution-1) */
+    getHeightAtGrid(gridX: number, gridZ: number): number;
+    /** Set height at grid coordinates */
+    setHeightAtGrid(gridX: number, gridZ: number, height: number, recordUndo?: boolean): void;
+    /** Get interpolated height at world coordinates */
+    getHeightAtWorld(worldX: number, worldZ: number): number;
+    /** Convert world position to grid coordinates */
+    worldToGrid(worldX: number, worldZ: number): Vec2;
+    /** Convert grid coordinates to world position */
+    gridToWorld(gridX: number, gridZ: number): Vec3;
+    getNormalAtWorld(worldX: number, worldZ: number): Vec3;
+    applyBrush(brush: TerrainBrush, worldX: number, worldZ: number): void;
+    private applyHeightBrush;
+    private applyFlattenBrush;
+    private applySmoothBrush;
+    private applyNoiseBrush;
+    private applyErosionBrush;
+    private applyPaintBrush;
+    private normalizeSplatmapPixel;
+    private applyHoleBrush;
+    private applyStampBrush;
+    private calculateFalloff;
+    generatePerlinTerrain(scale?: number, octaves?: number, persistence?: number): void;
+    generateDiamondSquare(roughness?: number): void;
+    applyHydraulicErosion(iterations?: number): void;
+    private perlinNoise2D;
+    private noise2D;
+    private dot2D;
+    private hash;
+    private fade;
+    private lerp;
+    addDetailPrototype(prototype: DetailPrototype): void;
+    paintDetail(worldX: number, worldZ: number, prototypeIndex: number, radius: number, density: number): void;
+    scatterFoliage(prototypeIndex: number, minSlope?: number, maxSlope?: number, minHeight?: number, maxHeight?: number): void;
+    addTreePrototype(prototype: TreePrototype): void;
+    addTree(worldX: number, worldZ: number, prototypeId: string, scale?: number, rotation?: number): TreeInstance | null;
+    scatterTrees(prototypeId: string, density: number, minSlope?: number, maxSlope?: number, minHeight?: number, maxHeight?: number, minSpacing?: number): number;
+    removeTreesInRadius(worldX: number, worldZ: number, radius: number): number;
+    private recordHeightChange;
+    undo(): boolean;
+    redo(): boolean;
+    getData(): TerrainData;
+    setData(data: TerrainData): void;
+    serialize(): string;
+    static deserialize(json: string): TerrainSystem;
+    exportHeightmapAsRAW(): ArrayBuffer;
+    importHeightmapFromRAW(buffer: ArrayBuffer, is16bit?: boolean): void;
+    exportSplatmapAsPNG(splatmapIndex: number): ImageData | null;
+}
+export declare function createTerrain(config?: Partial<TerrainConfig>): TerrainSystem;
+export declare function createFlatTerrain(config?: Partial<TerrainConfig>): TerrainSystem;
+export declare function createHillyTerrain(config?: Partial<TerrainConfig>): TerrainSystem;
+export declare function createMountainousTerrain(config?: Partial<TerrainConfig>): TerrainSystem;
+export declare function createIslandTerrain(config?: Partial<TerrainConfig>): TerrainSystem;

package/dist/types/systems/index.d.ts

@@ -0,0 +1,182 @@
+export * from './LightingSystem';
+export * from './ParticleSystem2';
+export * from './PhysicsDebugSystem';
+export * from './TerrainSystem';
+export { NiceSaveSystem, LocalStorageAdapter, MemoryStorageAdapter, IndexedDBAdapter, createSaveSystem, DEFAULT_SAVE_CONFIG, } from './NiceSaveSystem';
+export type { SaveSlotId, SaveMetadata, SaveData, SaveSystemConfig, SaveEventType, SaveEvent, SaveEventCallback, StorageAdapter, CloudSaveAdapter, SaveMigration, Checkpoint, } from './NiceSaveSystem';
+export { NiceAchievements, createAchievementSystem, createProgressAchievement, createTieredAchievements, DEFAULT_ACHIEVEMENT_CONFIG, } from './NiceAchievements';
+export type { AchievementId, StatId, LeaderboardId, AchievementRarity, AchievementCategory, AchievementDefinition, AchievementCondition, AchievementReward, AchievementState, UnlockNotification, StatDefinition, StatState, LeaderboardDefinition, LeaderboardEntry, AchievementEventType, AchievementEvent, AchievementEventCallback, PlatformAchievementAdapter, AchievementSystemConfig, } from './NiceAchievements';
+export { NiceSkillTree, createSkillTree, createPassiveSkill, createActiveSkill, DEFAULT_SKILL_CONFIG, } from './NiceSkillTree';
+export type { SkillId, SkillTreeId, BuildPresetId, SkillType, SkillCategory, SkillModifier, SkillEffect, SkillDefinition, SkillTreeDefinition, SkillState, SkillTreeState, BuildPreset, SkillEventType, SkillEvent, SkillEventCallback, SkillTreeConfig, } from './NiceSkillTree';
+export { NiceCrafting, createCraftingSystem, DEFAULT_CRAFTING_CONFIG } from './NiceCrafting';
+export type { RecipeId, ItemId, StationId, CraftingCategoryId, CraftingQuality, RecipeDiscoveryType, CraftingItem, ItemStack, RecipeIngredient, RecipeOutput, RecipeDefinition, CraftingStationDefinition, CraftingStationState, ActiveCraft, CraftingResult, CraftingSkillState, CraftingEventType, CraftingEvent, CraftingEventCallback, CraftingConfig, } from './NiceCrafting';
+export { NiceWeather, createWeatherSystem, DEFAULT_WEATHER_CONFIG, DEFAULT_WEATHER_PRESETS, DEFAULT_SEASONS, } from './NiceWeather';
+export type { WeatherId, BiomeId, SeasonId, TimeOfDay, WeatherDefinition, WeatherState, WeatherForecast, TimeState, TimeConfig, SeasonDefinition, BiomeDefinition, EnvironmentState, WeatherEventType, WeatherEvent, WeatherEventCallback, WeatherSystemConfig, } from './NiceWeather';
+export { NiceFaction, createFactionSystem, DEFAULT_REPUTATION_TIERS, DEFAULT_FACTION_CONFIG, } from './NiceFaction';
+export type { FactionId, ReputationTier, FactionDefinition, FactionRelationship, ReputationTierDefinition, FactionState, ReputationModifier, ReputationGain, FactionReward, DiplomaticStatus, DiplomaticState, FactionEventType, FactionEvent, FactionEventCallback, FactionSystemConfig, } from './NiceFaction';
+export { NiceLoot, createLootSystem, DEFAULT_RARITY_CONFIG, DEFAULT_LOOT_CONFIG } from './NiceLoot';
+export type { LootTableId, LootItemId, RarityTier, LootItemDefinition, LootEntry, LootCondition, GuaranteedDrop, LootTableDefinition, LootDrop, LootResult, LootContext, RarityConfig, LootEventType, LootEvent, LootEventCallback, LootSystemConfig, } from './NiceLoot';
+export { NiceCamera, createCameraSystem, DEFAULT_CAMERA_CONFIG, EASING } from './NiceCamera';
+export type { CameraId, CameraMode, Vec3, Quaternion, Bounds, CameraDefinition, CameraFollowSettings, CameraOrbitSettings, CameraIsometricSettings, CameraState, CameraShake, CameraTransition, EasingFunction, CameraKeyframe, CinematicSequence, ScreenEffect, CameraEventType, CameraEvent, CameraEventCallback, CameraSystemConfig, } from './NiceCamera';
+export { NiceAudio, createAudioSystem, DEFAULT_AUDIO_CONFIG } from './NiceAudio';
+export type { SoundId, SoundBankId, AudioCategory, SoundDefinition, MusicTrack, AmbientLayer, SoundInstance, MusicState, SoundBank, AudioEventType, AudioEvent, AudioEventCallback, } from './NiceAudio';
+export { NiceInput, createInputSystem, DEFAULT_INPUT_CONFIG } from './NiceInput';
+export type { ActionId, AxisId, InputDevice, KeyCode, MouseButton, GamepadButton, GamepadAxis, KeyBinding, MouseBinding, GamepadButtonBinding, GamepadAxisBinding, TouchBinding, InputBinding, ActionDefinition, AxisDefinition, ActionState, AxisState, MouseState, TouchState, GamepadState, InputFrame, InputRecording, InputEventType, InputEvent, InputEventCallback, InputContext, InputConfig, } from './NiceInput';
+export { NiceLocalization, createLocalizationSystem, DEFAULT_LOCALIZATION_CONFIG, } from './NiceLocalization';
+export type { LocaleId, TranslationKey, Namespace, PluralCategory, Gender, TranslationValue, TranslationEntry, TranslationNamespace, LocaleDefinition, InterpolationOptions, LocaleEventType, LocaleEvent, LocaleEventCallback, LocalizationConfig, TFunction, } from './NiceLocalization';
+export { Pool, NicePool, createPoolManager, createSimplePool, createVec2Pool, createVec3Pool, DEFAULT_POOL_CONFIG, } from './NicePool';
+export type { PoolableObject, PoolFactory, PoolConfig, PoolStats, PoolEventType, PoolEvent, PoolEventCallback, Vec2Poolable, Vec3Poolable, } from './NicePool';
+export { NiceTimer, createTimerSystem, SequenceBuilder, buildSequence, DEFAULT_TIMER_CONFIG, } from './NiceTimer';
+export type { TimerId, TimerGroupId, TimerCallback, TimerCompleteCallback, TimerConfig, TimerState, ScheduledTask, SequenceStep, TimerEventType, TimerEvent, TimerEventCallback, } from './NiceTimer';
+export { NiceTween, createTweenSystem, TweenSequence, EASINGS, TWEEN_EASINGS, lerpColor, hexToRgb, rgbToHex, tweenPath, bezierPoint, } from './NiceTween';
+export type { TweenId, EasingName, EasingFn, TweenProperty, TweenConfig, TweenState, RGB, RGBA, TweenEventType, TweenEvent, TweenEventCallback, } from './NiceTween';
+export { NiceDebug, createDebugSystem, getGlobalDebug, setGlobalDebug, DEFAULT_DEBUG_CONFIG, } from './NiceDebug';
+export type { LogLevel, ProfilerCategory, LogEntry, LogFilter, ProfilerSample, FrameStats, ProfilerReport, MemorySnapshot, AllocationTracker, DebugLine, DebugCircle, DebugBox, DebugText, DebugPrimitive, AssertionConfig, DebugEventType, DebugEvent, DebugEventCallback, DebugConfig, } from './NiceDebug';
+export { NiceEvent, createEventBus, TypedEventBus, createGameEventBus, DEFAULT_EVENT_CONFIG, } from './NiceEventBus';
+export type { EventName, EventCallback, GameEvent, EventListener, QueuedEvent, EventStats, EventBusConfig, TypedEventMap, CommonGameEvents, } from './NiceEventBus';
+export { NiceScene, createSceneManager, DEFAULT_SCENE_CONFIG, DEFAULT_TRANSITION, } from './NiceSceneManager';
+export type { SceneId, SceneGroupId, SceneState, SceneDefinition, SceneInstance, TransitionType, SceneTransition, LoadingScreen, SceneEventType, SceneEvent, SceneEventCallback, SceneManagerConfig, } from './NiceSceneManager';
+export { NiceECS, createECS, defineComponent, defineSystem, DEFAULT_ECS_CONFIG } from './NiceECS';
+export type { EntityId, ComponentType, SystemId, QueryId, TagId, GroupId, PrefabId, Component, ComponentDefinition, Entity, EntityData, SystemPriority, System, QueryDefinition, Prefab, ECSEventType, ECSEvent, ECSEventCallback, ECSConfig, } from './NiceECS';
+export { NiceAnimation, createAnimationSystem, ClipBuilder, StateMachineBuilder, buildClip, buildStateMachine, DEFAULT_ANIMATION_CONFIG, } from './NiceAnimation';
+export type { AnimationId, ClipId, BoneId, StateId, PlaybackState, BlendMode as AnimBlendMode, Keyframe, AnimationClip, AnimationInstance, Bone, Skeleton, IKChain, AnimatorStateMachine, AnimationEventType, AnimationEvent, AnimationEventCallback, } from './NiceAnimation';
+export { NiceCollision, createCollisionSystem, DEFAULT_COLLISION_CONFIG } from './NiceCollision';
+export type { ColliderId as CollisionColliderId, Vec2 as CollisionVec2, AABB, Circle, OBB, Polygon, Capsule, Collider as CollisionCollider, CollisionManifold, RaycastHit as CollisionRaycastHit, CollisionEventType, CollisionEvent, CollisionEventCallback, CollisionConfig, } from './NiceCollision';
+export { NiceState, createStateMachine, StateBuilder, TransitionBuilder, MachineBuilder, state, transition, machine, createSimpleFSM, createToggleMachine, createSequenceMachine, DEFAULT_STATE_CONFIG, } from './NiceState';
+export type { MachineId, StateId as StateMachineStateId, TransitionId as StateMachineTransitionId, StateDefinition as StateMachineStateDef, GuardFunction, ActionFunction, StateEvent, } from './NiceState';
+export { NiceResource, createResourceManager, loadManifest, loadManifestFromUrl, DEFAULT_RESOURCE_CONFIG, } from './NiceResource';
+export type { AssetId, BundleId, AssetType, Asset, AssetLoader, AssetBundle, AssetManifest, ResourceEventType, ResourceEvent, ResourceEventCallback, ResourceConfig, } from './NiceResource';
+export { NiceParticle, createParticleSystem, PARTICLE_PRESETS, DEFAULT_PARTICLE_CONFIG, DEFAULT_EMITTER_CONFIG, } from './NiceParticle';
+export type { EmitterId, ParticleId, EmitterShape, EmissionMode, BlendMode as ParticleBlendMode, SortMode, Vec2 as ParticleVec2, Vec3 as ParticleVec3, Color as ParticleColor, MinMax, Curve, ValueOverLifetime, ColorOverLifetime, ColorGradient, Particle, BoxShape, CircleShape, SphereShape, ConeShape, LineShape, RingShape, PointShape, ShapeConfig, GravityForce, WindForce, AttractorForce, VortexForce, NoiseForce, DragForce, Force, Burst, EmissionConfig, TextureConfig, TrailConfig, CollisionConfig as ParticleCollisionConfig, SubEmitterConfig, EmitterConfig, EmitterInstance, ParticleEventType, ParticleEvent, ParticleEventCallback, ParticleSystemConfig, } from './NiceParticle';
+export { NicePhysics, createPhysicsWorld, createDynamicBody, createStaticBody, createKinematicBody, DEFAULT_PHYSICS_CONFIG, DEFAULT_MATERIAL, } from './NicePhysics';
+export type { BodyId, ColliderId as PhysicsColliderId, JointId, BodyType, ColliderType, JointType, Vec2 as PhysicsVec2, Vec3 as PhysicsVec3, Quaternion as PhysicsQuaternion, PhysicsMaterial, BaseCollider, BoxCollider, CircleCollider, SphereCollider, CapsuleCollider, PolygonCollider, PlaneCollider, Collider as PhysicsCollider, RigidBodyConfig, RigidBody, BaseJoint, FixedJoint, DistanceJoint, SpringJoint, RevoluteJoint, PrismaticJoint, RopeJoint, Joint, ContactPoint, CollisionInfo, RaycastHit as PhysicsRaycastHit, RaycastOptions, OverlapResult, PhysicsEventType, PhysicsEvent, PhysicsEventCallback, PhysicsConfig, } from './NicePhysics';
+export { NiceNavigation, createNavigationSystem, pathToPositions, getPathProgress, DEFAULT_NAVIGATION_CONFIG, } from './NiceNavigation';
+export type { NavMeshId, AgentId, ObstacleId, WaypointId, AreaId, PathfindingAlgorithm, HeuristicType, Vec2 as NavVec2, Vec3 as NavVec3, CellType, GridCell, NavigationGrid, GridConfig, NavMeshVertex, NavMeshEdge, NavMeshPolygon, NavMesh, Waypoint, WaypointGraph, PathNode, NavigationPath, PathRequest, PathResult, AgentState, NavigationAgent, AgentConfig, ObstacleShape, DynamicObstacle, FlowField, NavigationArea, NavigationEventType, NavigationEvent, NavigationEventCallback, NavigationConfig, } from './NiceNavigation';
+export { NiceUI, createUISystem, createPanel, createLabel, createButton, createProgressBar, createTextInput, Easings, DEFAULT_UI_CONFIG, DEFAULT_STYLE, } from './NiceUI';
+export type { WidgetId, LayerId, StyleId, WidgetType, AnchorPreset, LayoutType, Vec2 as UIVec2, Rect, Color as UIColor, Padding, TextStyle, BackgroundStyle, BorderStyle, WidgetStyle, Theme, WidgetConfig, Widget, UILayer, InputState, UIAnimation, UIEventType, UIEvent, UIEventCallback, UIConfig, } from './NiceUI';
+export { NiceSpawner, createSpawnerSystem, DEFAULT_SPAWNER_CONFIG } from './NiceSpawner';
+export type { SpawnerId, SpawnPointId, WaveId, SpawnPattern, SpawnCondition, SpawnRequest, SpawnResult, SpawnerEventType, SpawnerEvent, SpawnerEventCallback, SpawnerConfig, } from './NiceSpawner';
+export { NiceDamage, createDamageSystem, DEFAULT_DAMAGE_CONFIG } from './NiceDamage';
+export type { DamageModifier, DamageResult, DamageEventType, DamageEvent, DamageEventCallback, DamageConfig, } from './NiceDamage';
+export { NiceAbility, createAbilitySystem, DEFAULT_ABILITY_CONFIG } from './NiceAbility';
+export type { AbilityId, AbilityState, AbilityCost, AbilityEffect, AbilityDefinition, AbilityEventType, AbilityEvent, AbilityEventCallback, AbilityConfig, } from './NiceAbility';
+export { NiceMinimap, createMinimapSystem, DEFAULT_MINIMAP_CONFIG } from './NiceMinimap';
+export type { MinimapMarker, MinimapEventType, MinimapEvent, MinimapEventCallback, MinimapConfig, } from './NiceMinimap';
+export { NiceLeaderboard, createLeaderboardSystem, DEFAULT_LEADERBOARD_CONFIG, } from './NiceLeaderboard';
+export type { EntryId, LeaderboardEventType, LeaderboardEvent, LeaderboardEventCallback, LeaderboardConfig, } from './NiceLeaderboard';
+export { NiceTutorial, createTutorialSystem, DEFAULT_TUTORIAL_CONFIG } from './NiceTutorial';
+export type { TutorialId, StepId, TutorialStep, TutorialDefinition, TutorialProgress, TutorialState, TutorialEventType, TutorialEvent, TutorialEventCallback, TutorialConfig, } from './NiceTutorial';
+export { NiceBuilding, createBuildingSystem, DEFAULT_BUILDING_CONFIG } from './NiceBuilding';
+export type { BuildingId, BlueprintId, GridCell as BuildingGridCell, BuildingState, BuildingInstance, BuildingEventType, BuildingEvent, BuildingEventCallback, BuildingConfig, } from './NiceBuilding';
+export { NiceLevel, createLevelSystem, DEFAULT_LEVEL_CONFIG } from './NiceLevel';
+export type { LevelId, LevelDefinition, LevelState, LevelEventType, LevelEvent, LevelEventCallback, LevelConfig, } from './NiceLevel';
+export { NiceFog, createFogSystem, DEFAULT_FOG_CONFIG } from './NiceFog';
+export type { FogCell, FogEventType, FogEvent, FogEventCallback, FogConfig } from './NiceFog';
+export { NiceReplay, createReplaySystem, DEFAULT_REPLAY_CONFIG } from './NiceReplay';
+export type { ReplayId, PlaybackState as ReplayPlaybackState, ReplayFrame, ReplayMetadata, ReplayData, ReplayEventType, ReplayEvent, ReplayEventCallback, ReplayConfig, } from './NiceReplay';
+export { NiceScore, createScoreSystem, DEFAULT_SCORE_CONFIG } from './NiceScore';
+export type { MultiplierType, ScorePopup, ComboState, ScoreEventType, ScoreEvent, ScoreEventCallback, ScoreConfig, } from './NiceScore';
+export { NiceFormation, createFormationSystem, DEFAULT_FORMATION_CONFIG } from './NiceFormation';
+export type { FormationId, UnitId, FormationPattern, FormationSlot, FormationEventType, FormationEvent, FormationEventCallback, FormationConfig, } from './NiceFormation';
+export { NiceWave, createWaveSystem, DEFAULT_WAVE_CONFIG } from './NiceWave';
+export type { WaveId as WaveSystemWaveId, WaveObjective, WaveDefinition, WaveState, WaveEventType, WaveEvent, WaveEventCallback, } from './NiceWave';
+export { NiceProfile, createProfileSystem, DEFAULT_PROFILE_CONFIG } from './NiceProfile';
+export type { ProfileId, BadgeId, TitleId, ProfileBadge, ProfileTitle, ProfileCustomization, ProfilePreferences, PlaySession, ProfileEventType, ProfileEvent, ProfileEventCallback, ProfileConfig, } from './NiceProfile';
+export { NiceMatch, createMatchSystem, DEFAULT_MATCH_CONFIG } from './NiceMatch';
+export type { MatchId, LobbyId, PartyId, PlayerId as MatchPlayerId, MatchState, MatchPlayer, LobbySettings, LobbyState, Party, MatchEventType, MatchEvent, MatchEventCallback, MatchConfig, } from './NiceMatch';
+export { NiceAchievementUI, createAchievementUISystem, DEFAULT_ACHIEVEMENT_UI_CONFIG, } from './NiceAchievementUI';
+export type { NotificationPosition, AchievementNotification, AchievementUIEventType, AchievementUIEvent, AchievementUIEventCallback, AchievementUIConfig, } from './NiceAchievementUI';
+export { NiceController, createControllerSystem, DEFAULT_CONTROLLER_CONFIG, } from './NiceController';
+export type { ControllerId, ButtonState, AxisState as ControllerAxisState, ControllerState, ActionBinding, ControllerEventType, ControllerEvent, ControllerEventCallback, ControllerConfig, } from './NiceController';
+export { NiceProcedural, createProceduralSystem, SeededRandom, PerlinNoise, WorleyNoise, DungeonGenerator, MazeGenerator, HeightmapGenerator, NameGenerator, WaveFunctionCollapse, } from './NiceProcedural';
+export type { DungeonConfig, DungeonResult, MazeConfig, HeightmapConfig, WFCTile, WFCConfig, } from './NiceProcedural';
+export { NiceVFX, createVFXSystem, VFX_COLORS, DEFAULT_VFX_CONFIG } from './NiceVFX';
+export type { TrailEffect, TextPopup, ImpactEffect, VFXEventType, VFXEvent, VFXConfig, } from './NiceVFX';
+export { NiceCommand, createCommandSystem, BaseCommand, FunctionCommand, PropertyCommand, BatchCommand, createCommand, createPropertyCommand, createBatchCommand, DEFAULT_COMMAND_CONFIG, } from './NiceCommand';
+export type { CommandId, Command, CommandEventType, CommandEvent, CommandConfig, } from './NiceCommand';
+export { NiceGrid, createGrid, createBooleanGrid, createNumberGrid, SparseGrid, createSparseGrid, DIRECTIONS, CARDINAL_DIRECTIONS, ALL_DIRECTIONS, } from './NiceGrid';
+export type { GridPosition, GridSize, GridCellCallback, GridCellPredicate, GridCellMapper, CardinalDirection, DiagonalDirection, Direction, GridCell as NiceGridCell, } from './NiceGrid';
+export { NiceTilemap, Tileset, TilemapLayer, createTilemap, createIsometricTilemap, createHexTilemap, AUTOTILE_BLOB_47, } from './NiceTilemap';
+export type { TilePosition, WorldPosition, TileRect, TileData, TileProperties, Tile, TileAnimation, TilesetConfig, LayerConfig, AutoTileRule, AutoTileConfig, TilemapEventType, TilemapEvent, TilemapConfig, Chunk, } from './NiceTilemap';
+export { NiceStateMachine, State, HierarchicalStateMachine, PushdownStateMachine, createStateMachine as createNiceStateMachine, createHierarchicalStateMachine, createPushdownStateMachine, } from './NiceStateMachine';
+export type { StateId as NiceStateId, ActionType, TransitionConfig, StateMachineEventType, StateMachineEvent, StateMachineConfig, } from './NiceStateMachine';
+export { NiceCoroutine, createCoroutineSystem, WaitForSeconds, WaitForFrames, WaitForCondition, WaitForCoroutine, WaitForAll, WaitForAny, waitForSeconds, waitForFrames, waitUntil, waitForCoroutine, waitForAll, waitForAny, DEFAULT_COROUTINE_CONFIG, } from './NiceCoroutine';
+export type { CoroutineId, CoroutineFunction, YieldInstruction, CoroutineState, CoroutineInstance, CoroutineEventType, CoroutineEvent, CoroutineConfig, } from './NiceCoroutine';
+export { NiceEntityPool, createEntityPool, registerCommonComponents, BasePooledComponent, TransformComponent, VelocityComponent, SpriteComponent, HealthComponent, LifetimeComponent, DEFAULT_ENTITY_POOL_CONFIG, } from './NiceEntityPool';
+export type { EntityId as PooledEntityId, ComponentType as PooledComponentType, PooledComponent, ComponentFactory, ComponentInitializer, PooledEntity, PrefabDefinition, PoolStatistics, EntityPoolEventType, EntityPoolEvent, EntityPoolConfig, } from './NiceEntityPool';
+export { Signal, ComputedSignal, SignalArray, SignalMap, signal, computed, effect, batch, derived, combine, when, createStore, signalArray, signalMap, } from './NiceSignal';
+export type { SignalListener, Unsubscribe, Cleanup, EffectFn, ReadableSignal, WritableSignal, SignalStore, } from './NiceSignal';
+export { NiceMessageBus, createMessageBus, createTypedChannel, DEFAULT_MESSAGE_BUS_CONFIG, } from './NiceMessageBus';
+export type { MessageType, ChannelId, SubscriberId, Message, MessageHandler, MessageFilter, Middleware, Subscription, Request, Response, MessageBusEventType, MessageBusEvent, MessageBusConfig, TypedChannel, } from './NiceMessageBus';
+export { ServiceContainer, ContainerBuilder, getGlobalContainer, resetGlobalContainer, createServiceContainer, createContainerBuilder, Injectable, Inject, } from './NiceServiceLocator';
+export type { ServiceId, ServiceFactory, ServiceLifetime, ServiceDefinition, ServiceRegistration, ServiceEventType, ServiceEvent, Disposable, Initializable, } from './NiceServiceLocator';
+export { NiceLogger, ConsoleTransport, MemoryTransport, RemoteTransport, createLogger, createConsoleTransport, createMemoryTransport, createRemoteTransport, getGlobalLogger, setGlobalLogger, log, LOG_LEVELS, DEFAULT_LOGGER_CONFIG, } from './NiceLogger';
+export type { LogLevel as NiceLogLevel, LogCategory, LogEntry as NiceLogEntry, LogTransport, ConsoleTransportConfig, RemoteTransportConfig, LoggerConfig, } from './NiceLogger';
+export { NiceAssetLoader, createAssetLoader, createAssetBundle, defineAsset, ImageLoader, AudioLoader, JsonLoader, TextLoader, BinaryLoader, SpritesheetLoader, DEFAULT_ASSET_LOADER_CONFIG, } from './NiceAssetLoader';
+export type { AssetId as NiceAssetId, AssetType as NiceAssetType, AssetDefinition, LoadedAsset, LoadProgress as AssetLoadProgress, AssetBundle as NiceAssetBundle, AssetEventType, AssetEvent, AssetLoaderConfig, AssetTypeLoader, SpritesheetFrame, SpritesheetData, } from './NiceAssetLoader';
+export * from './NiceDialogue';
+export * from './NiceQuest';
+export * from './NiceInventory';
+export * from './NiceAI';
+export * from './NiceNetwork';
+export * from './NiceAccessibility';
+export * from './NiceAction';
+export * from './NiceAnalytics';
+export * from './NiceArena';
+export * from './NiceBehavior';
+export * from './NiceChat';
+export * from './NiceCheat';
+export * from './NiceClimbing';
+export * from './NiceCloud';
+export * from './NiceCombo';
+export * from './NiceCooking';
+export * from './NiceCutscene';
+export * from './NiceDayNight';
+export * from './NiceEquipment';
+export * from './NiceFarming';
+export * from './NiceFishing';
+export * from './NiceGesture';
+export * from './NiceGrappling';
+export * from './NiceGuild';
+export * from './NiceHaptics';
+export * from './NiceLighting';
+export * from './NiceLocomotion';
+export * from './NiceLOD';
+export * from './NiceMining';
+export * from './NiceModding';
+export * from './NiceMount';
+export * from './NiceNotification';
+export * from './NiceObjective';
+export * from './NiceParty';
+export * from './NicePerformance';
+export * from './NicePet';
+export * from './NicePhotoMode';
+export * from './NicePostProcess';
+export * from './NiceProjectile';
+export * from './NiceQTE';
+export * from './NiceRanking';
+export * from './NiceReputation';
+export * from './NiceScreenshot';
+export * from './NiceSerialization';
+export * from './NiceShop';
+export * from './NiceSocial';
+export * from './NiceStatus';
+export * from './NiceStealth';
+export * from './NiceStreaming';
+export * from './NiceSwimming';
+export * from './NiceTarget';
+export * from './NiceTerrain';
+export * from './NiceTrading';
+export * from './NiceVehicle';
+export * from './NiceVoice';
+export * from './NiceWater';
+export * from './NiceAchievement';
+export * from './NiceAugment';
+export * from './NiceCompanion';
+export * from './NiceGacha';
+export * from './NiceBattlePass';
+export * from './NiceAuction';
+export * from './NiceDungeon';
+export * from './NicePvP';
+export * from './NiceEnchant';
+export * from './NiceRaid';

package/dist/types/templates/FightingTemplate.d.ts

@@ -0,0 +1,179 @@
+import type { Vec2 } from '../core/types';
+export type FighterState = 'idle' | 'walking' | 'jumping' | 'crouching' | 'attacking' | 'hitstun' | 'blockstun' | 'knockdown' | 'wakeup' | 'dash' | 'backdash' | 'throw' | 'thrown';
+export type AttackType = 'light' | 'medium' | 'heavy' | 'special' | 'super';
+export type AttackLevel = 'low' | 'mid' | 'high' | 'overhead' | 'unblockable';
+export type BlockType = 'standing' | 'crouching' | 'air';
+export interface Hitbox {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    active: boolean;
+    damage: number;
+    hitstun: number;
+    blockstun: number;
+    knockback: Vec2;
+    level: AttackLevel;
+    type: AttackType;
+    canCancel: boolean;
+    cancelWindow: number;
+    priority: number;
+}
+export interface Hurtbox {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    vulnerableToLow: boolean;
+    vulnerableToHigh: boolean;
+    invincible: boolean;
+}
+export interface MoveFrame {
+    frameIndex: number;
+    hitboxes: Hitbox[];
+    hurtboxes: Hurtbox[];
+    positionOffset: Vec2;
+    canCancel: boolean;
+    invincible: boolean;
+    armor: number;
+    pushbox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+export interface Move {
+    id: string;
+    name: string;
+    inputSequence: string[];
+    type: AttackType;
+    startup: number;
+    active: number;
+    recovery: number;
+    damage: number;
+    meterGain: number;
+    meterCost: number;
+    frames: MoveFrame[];
+    canComboFrom: string[];
+    onHit: 'normal' | 'launch' | 'sweep' | 'wallbounce' | 'groundbounce';
+    onBlock: 'safe' | 'punishable' | 'plus';
+    frameAdvantageOnHit: number;
+    frameAdvantageOnBlock: number;
+}
+export interface ComboRoute {
+    id: string;
+    name: string;
+    moves: string[];
+    damage: number;
+    meterBuild: number;
+    difficulty: 'easy' | 'medium' | 'hard' | 'expert';
+}
+export interface CharacterDef {
+    id: string;
+    name: string;
+    health: number;
+    walkSpeed: number;
+    dashSpeed: number;
+    jumpHeight: number;
+    jumpDuration: number;
+    airDashes: number;
+    moves: Move[];
+    combos: ComboRoute[];
+    defaultHurtboxes: Hurtbox[];
+    defaultPushbox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+export interface FighterInput {
+    up: boolean;
+    down: boolean;
+    left: boolean;
+    right: boolean;
+    lightPunch: boolean;
+    mediumPunch: boolean;
+    heavyPunch: boolean;
+    lightKick: boolean;
+    mediumKick: boolean;
+    heavyKick: boolean;
+}
+export interface InputBufferEntry {
+    input: FighterInput;
+    frame: number;
+    processed: boolean;
+}
+export interface FighterState2 {
+    position: Vec2;
+    velocity: Vec2;
+    health: number;
+    meter: number;
+    state: FighterState;
+    facing: 1 | -1;
+    currentMove: string | null;
+    currentFrame: number;
+    hitstun: number;
+    blockstun: number;
+    airborne: boolean;
+    comboCount: number;
+    comboDamage: number;
+    inputBuffer: InputBufferEntry[];
+    canAct: boolean;
+}
+export interface FightingGameConfig {
+    roundTime: number;
+    roundsToWin: number;
+    maxHealth: number;
+    maxMeter: number;
+    meterPerDamage: number;
+    meterPerBlock: number;
+    inputBufferSize: number;
+    comboScaling: number;
+    gravityScale: number;
+    pushbackOnBlock: number;
+    pushbackOnHit: number;
+    wallBounceVelocity: Vec2;
+    groundBounceVelocity: number;
+    throwRange: number;
+    throwStartup: number;
+    throwDamage: number;
+    wakeupFrames: number;
+    techWindow: number;
+}
+export interface FightingGameState {
+    frame: number;
+    player1: FighterState2;
+    player2: FighterState2;
+    player1Wins: number;
+    player2Wins: number;
+    roundTime: number;
+    roundActive: boolean;
+    slowMotionFrames: number;
+    hitStop: number;
+}
+export declare const DEFAULT_FIGHTING_CONFIG: FightingGameConfig;
+export declare function parseDirection(input: FighterInput): string;
+export declare function getInputNotation(input: FighterInput, facing: 1 | -1): string[];
+export declare function checkMotionInput(buffer: InputBufferEntry[], motion: string[], window: number): boolean;
+export declare function hitboxesOverlap(h1: Hitbox, h2: Hurtbox): boolean;
+export declare function checkHit(attackerMove: Move, attackerFrame: number, attackerPos: Vec2, attackerFacing: 1 | -1, defenderHurtboxes: Hurtbox[], defenderPos: Vec2): Hitbox | null;
+export declare function canBlock(defender: FighterState2, hitLevel: AttackLevel, blockType: BlockType): boolean;
+export declare function applyHit(attacker: FighterState2, defender: FighterState2, hitbox: Hitbox, config: FightingGameConfig, blocked: boolean): void;
+export declare function resetCombo(fighter: FighterState2): void;
+export declare function createFighterState(position: Vec2, facing: 1 | -1, config: FightingGameConfig): FighterState2;
+export declare function createFightingGameState(config: FightingGameConfig): FightingGameState;
+export declare function serializeFighterState(state: FighterState2): string;
+export declare function deserializeFighterState(data: string, _config: FightingGameConfig): FighterState2;
+export declare function advanceFrame(state: FightingGameState, p1Input: FighterInput, p2Input: FighterInput, config: FightingGameConfig): void;
+export declare const PRESET_JABS: Move;
+export declare const PRESET_HEAVY_PUNCH: Move;
+export declare const PRESET_SWEEP: Move;
+export declare const PRESET_SHORYUKEN: Move;
+export declare function createMove(partial: Partial<Move>): Move;
+export declare function createCharacter(partial: Partial<CharacterDef>): CharacterDef;
+export declare function createComboRoute(id: string, name: string, moves: string[], damage: number, difficulty: ComboRoute['difficulty']): ComboRoute;
+export declare function createHitbox(partial: Partial<Hitbox>): Hitbox;