@nice2dev/game-engine 1.1.5 → 1.1.7

package/dist/types/ecs/ECSOptimized.d.ts

@@ -0,0 +1,131 @@
+export type EntityId = number;
+export type ComponentTypeId = number;
+export type ArchetypeId = number;
+/** Component schema for SoA layout */
+export interface ComponentSchema {
+    /** Component type identifier */
+    typeId: ComponentTypeId;
+    /** Component name */
+    name: string;
+    /** Fields with their types */
+    fields: ComponentField[];
+    /** Total byte size per component */
+    byteSize: number;
+}
+export interface ComponentField {
+    name: string;
+    type: 'f32' | 'i32' | 'u32' | 'f64' | 'i16' | 'u16' | 'i8' | 'u8' | 'bool' | 'vec2' | 'vec3' | 'vec4' | 'mat4';
+    offset: number;
+    size: number;
+    count?: number;
+}
+export declare class SoAStorage {
+    private buffers;
+    private views;
+    private schemas;
+    private capacity;
+    private count;
+    constructor(capacity?: number);
+    /** Register a component type */
+    registerComponent(schema: ComponentSchema): void;
+    private createTypedView;
+    /** Get a field view for batch operations */
+    getFieldView<T extends TypedArray>(typeId: ComponentTypeId, fieldName: string): T | undefined;
+    /** Set component field value */
+    setField(typeId: ComponentTypeId, entityIndex: number, fieldName: string, value: number | number[]): void;
+    /** Get component field value */
+    getField(typeId: ComponentTypeId, entityIndex: number, fieldName: string): number | number[] | undefined;
+    private getElementCount;
+    /** Grow storage if needed */
+    grow(newCapacity: number): void;
+    get entityCount(): number;
+    set entityCount(value: number);
+    get storageCapacity(): number;
+}
+type TypedArray = Float32Array | Float64Array | Int32Array | Uint32Array | Int16Array | Uint16Array | Int8Array | Uint8Array;
+export interface Archetype {
+    id: ArchetypeId;
+    /** Bitmask of component types in this archetype */
+    componentMask: bigint;
+    /** Component type IDs in this archetype */
+    componentTypes: ComponentTypeId[];
+    /** SoA storage for this archetype */
+    storage: SoAStorage;
+    /** Entity IDs in this archetype */
+    entities: EntityId[];
+    /** Map from entity ID to index in storage */
+    entityToIndex: Map<EntityId, number>;
+}
+export declare class ArchetypeRegistry {
+    private archetypes;
+    private archetypeById;
+    private nextArchetypeId;
+    private componentSchemas;
+    /** Register a component schema */
+    registerComponentSchema(schema: ComponentSchema): void;
+    /** Get or create archetype for a set of components */
+    getOrCreateArchetype(componentTypes: ComponentTypeId[]): Archetype;
+    /** Find archetypes matching a query */
+    findArchetypes(requiredComponents: ComponentTypeId[], excludedComponents?: ComponentTypeId[]): Archetype[];
+    /** Get archetype by ID */
+    getArchetype(id: ArchetypeId): Archetype | undefined;
+}
+export declare class OptimizedWorld {
+    private registry;
+    private entityArchetype;
+    private nextEntityId;
+    private freeEntityIds;
+    private systems;
+    private systemGroups;
+    constructor();
+    /** Register a component schema */
+    registerComponent(schema: ComponentSchema): void;
+    /** Create a new entity with components */
+    createEntity(componentTypes: ComponentTypeId[]): EntityId;
+    /** Destroy an entity */
+    destroyEntity(id: EntityId): void;
+    /** Set component field */
+    setComponent(entityId: EntityId, componentTypeId: ComponentTypeId, fieldName: string, value: number | number[]): void;
+    /** Get component field */
+    getComponent(entityId: EntityId, componentTypeId: ComponentTypeId, fieldName: string): number | number[] | undefined;
+    /** Register a system */
+    addSystem(system: ECSSystem, group?: string): void;
+    /** Query entities */
+    query(requiredComponents: ComponentTypeId[], excludedComponents?: ComponentTypeId[]): QueryIterator;
+    /** Update all systems */
+    update(dt: number): void;
+    /** Update a specific system group */
+    updateGroup(group: string, dt: number): void;
+}
+export declare class QueryIterator implements Iterable<QueryResult> {
+    private archetypes;
+    private componentTypes;
+    constructor(archetypes: Archetype[], componentTypes: ComponentTypeId[]);
+    [Symbol.iterator](): Iterator<QueryResult>;
+    /** Get total entity count across all archetypes */
+    count(): number;
+    /** Batch iterate over archetypes for SIMD-friendly operations */
+    forEachArchetype(callback: (archetype: Archetype, count: number) => void): void;
+    /** Get raw field views for direct manipulation */
+    getFieldViews<T extends TypedArray>(componentTypeId: ComponentTypeId, fieldName: string): {
+        view: T;
+        count: number;
+    }[];
+}
+export interface QueryResult {
+    entityId: EntityId;
+    archetype: Archetype;
+    index: number;
+}
+export interface ECSSystem {
+    name: string;
+    requiredComponents: ComponentTypeId[];
+    excludedComponents?: ComponentTypeId[];
+    priority?: number;
+    update(world: OptimizedWorld, dt: number): void;
+}
+export declare const TRANSFORM_SCHEMA: ComponentSchema;
+export declare const VELOCITY_SCHEMA: ComponentSchema;
+export declare const RENDERABLE_SCHEMA: ComponentSchema;
+export declare const MovementSystem: ECSSystem;
+export {};

package/dist/types/ecs/World.d.ts

@@ -1,5 +1,5 @@
-import type { EntityId, Component, ComponentType, Vec2, Color } from '../core/types';
 import { EventBus } from '../core/EventBus';
+import type { EntityId, Component, ComponentType, Vec2, Color } from '../core/types';
 export interface Entity {
     readonly id: EntityId;
     name: string;

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

@@ -1 +1,2 @@
 export { World, System, createDefaultComponent, type Entity, type TransformComponent, type SpriteComponent, type ShapeComponent, type Collider2DComponent, type RigidBody2DComponent, type TextComponent, type AnimatorComponent, type ScriptComponent, type AudioSourceComponent, type ParticleEmitterComponent, type CameraTargetComponent, type BuiltInComponent, type ComponentMap, type SpriteAnimation, type AnimationFrame, } from './World';
+export { SoAStorage, ArchetypeRegistry, OptimizedWorld, QueryIterator, MovementSystem, TRANSFORM_SCHEMA, VELOCITY_SCHEMA, RENDERABLE_SCHEMA, type EntityId, type ComponentTypeId, type ArchetypeId, type ComponentSchema, type ComponentField, type Archetype, type QueryResult, type ECSSystem, } from './ECSOptimized';

package/dist/types/editor/AchievementEditor.d.ts

@@ -0,0 +1,193 @@
+/**
+ * @file AchievementEditor.ts
+ * @description Achievement/Trophy Editor system with progress tracking
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Achievement definitions with tiers
+ * - Progress tracking (counters, milestones)
+ * - Conditions and triggers
+ * - Rewards integration
+ * - Categories and rarity
+ * - Hidden achievements
+ * - Achievement chains
+ * - Statistics integration
+ * - Retroactive unlocks
+ * - Platform sync (Steam, Xbox, PlayStation, etc.)
+ */
+export type AchievementRarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary' | 'secret';
+export type AchievementCategory = 'story' | 'exploration' | 'combat' | 'collection' | 'social' | 'challenge' | 'mastery' | 'secret' | 'seasonal' | 'dlc' | 'custom';
+export type TriggerType = 'stat' | 'event' | 'quest' | 'item' | 'level' | 'skill' | 'time' | 'location' | 'boss' | 'achievement' | 'custom';
+export type ComparisonOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte';
+export interface AchievementTrigger {
+    id: string;
+    type: TriggerType;
+    target: string;
+    operator: ComparisonOperator;
+    value: number | string | boolean;
+    description?: string;
+}
+export interface AchievementCondition {
+    triggers: AchievementTrigger[];
+    logic: 'and' | 'or';
+    description?: string;
+}
+export interface AchievementTier {
+    tier: number;
+    name: string;
+    description: string;
+    targetValue: number;
+    rewards?: AchievementReward[];
+    icon?: string;
+    pointValue: number;
+}
+export interface AchievementReward {
+    type: 'item' | 'currency' | 'title' | 'badge' | 'cosmetic' | 'unlock' | 'points' | 'custom';
+    target: string;
+    amount: number;
+    description?: string;
+}
+export interface Achievement {
+    id: string;
+    name: string;
+    description: string;
+    hint?: string;
+    category: AchievementCategory;
+    rarity: AchievementRarity;
+    tags: string[];
+    icon: string;
+    iconLocked?: string;
+    color?: string;
+    bannerImage?: string;
+    soundEffect?: string;
+    conditions: AchievementCondition[];
+    isProgressBased: boolean;
+    currentProgress: number;
+    maxProgress: number;
+    progressFormat?: string;
+    hasTiers: boolean;
+    tiers?: AchievementTier[];
+    currentTier: number;
+    rewards: AchievementReward[];
+    pointValue: number;
+    isHidden: boolean;
+    showProgressWhenHidden: boolean;
+    revealCondition?: AchievementCondition;
+    chainId?: string;
+    chainOrder?: number;
+    prerequisiteIds?: string[];
+    isUnlocked: boolean;
+    unlockedAt?: number;
+    unlockedBy?: string;
+    platformId?: string;
+    platform?: string;
+    createdAt: number;
+    modifiedAt: number;
+    version: number;
+}
+export interface AchievementChain {
+    id: string;
+    name: string;
+    description: string;
+    achievementIds: string[];
+    completionRewards?: AchievementReward[];
+    isCompleted: boolean;
+}
+export interface Statistic {
+    id: string;
+    name: string;
+    description: string;
+    value: number;
+    type: 'counter' | 'max' | 'min' | 'average' | 'total_time' | 'custom';
+    format?: string;
+    isPublic: boolean;
+    linkedAchievements: string[];
+}
+export interface AchievementProgress {
+    achievementId: string;
+    playerId: string;
+    progress: number;
+    tier: number;
+    isUnlocked: boolean;
+    unlockedAt?: number;
+    progressHistory: ProgressHistoryEntry[];
+}
+export interface ProgressHistoryEntry {
+    timestamp: number;
+    progress: number;
+    reason?: string;
+}
+export declare class AchievementManager {
+    private achievements;
+    private chains;
+    private statistics;
+    private playerProgress;
+    private playerStats;
+    private totalPoints;
+    private onAchievementUnlocked?;
+    private onAchievementProgress?;
+    private onTierUnlocked?;
+    private onChainCompleted?;
+    private onStatisticUpdated?;
+    private onRewardGranted?;
+    private onPointsAdded?;
+    private customTriggerEvaluator?;
+    createAchievement(name: string, category: AchievementCategory): Achievement;
+    getAchievement(id: string): Achievement | undefined;
+    updateAchievement(id: string, updates: Partial<Achievement>): boolean;
+    deleteAchievement(id: string): boolean;
+    getAllAchievements(): Achievement[];
+    getAchievementsByCategory(category: AchievementCategory): Achievement[];
+    createTrigger(type: TriggerType, target: string, operator: ComparisonOperator, value: number | string | boolean): AchievementTrigger;
+    addCondition(achievementId: string, condition: AchievementCondition): boolean;
+    addTier(achievementId: string, name: string, targetValue: number, pointValue?: number): boolean;
+    setTierRewards(achievementId: string, tierIndex: number, rewards: AchievementReward[]): boolean;
+    addReward(achievementId: string, reward: AchievementReward): boolean;
+    createReward(type: AchievementReward['type'], target: string, amount: number): AchievementReward;
+    createChain(name: string, description?: string): AchievementChain;
+    addToChain(chainId: string, achievementId: string): boolean;
+    getChain(chainId: string): AchievementChain | undefined;
+    getAllChains(): AchievementChain[];
+    createStatistic(name: string, type?: Statistic['type'], initialValue?: number): Statistic;
+    getStatistic(id: string): Statistic | undefined;
+    linkStatisticToAchievement(statId: string, achievementId: string): boolean;
+    updateProgress(achievementId: string, playerId: string, progress: number, reason?: string): void;
+    incrementProgress(achievementId: string, playerId: string, amount?: number, reason?: string): void;
+    getProgress(achievementId: string, playerId: string): number;
+    unlockAchievement(achievementId: string, playerId: string): boolean;
+    isUnlocked(achievementId: string, playerId: string): boolean;
+    private checkChainCompletion;
+    updateStatistic(statId: string, playerId: string, value: number): void;
+    incrementStatistic(statId: string, playerId: string, amount?: number): void;
+    getStatisticValue(statId: string, playerId: string): number;
+    processEvent(eventType: string, eventData: Record<string, unknown>, playerId: string): void;
+    private evaluateCondition;
+    private evaluateTrigger;
+    private compare;
+    private grantReward;
+    private addPoints;
+    getTotalPoints(playerId: string): number;
+    setOnAchievementUnlocked(callback: (achievement: Achievement, playerId: string) => void): void;
+    setOnAchievementProgress(callback: (achievement: Achievement, playerId: string, progress: number) => void): void;
+    setOnTierUnlocked(callback: (achievement: Achievement, tier: AchievementTier, playerId: string) => void): void;
+    setOnChainCompleted(callback: (chain: AchievementChain, playerId: string) => void): void;
+    setOnStatisticUpdated(callback: (stat: Statistic, playerId: string, value: number) => void): void;
+    setOnRewardGranted(callback: (reward: AchievementReward, playerId: string) => void): void;
+    setOnPointsAdded(callback: (playerId: string, points: number, total: number) => void): void;
+    setCustomTriggerEvaluator(evaluator: (trigger: AchievementTrigger, playerId: string) => boolean): void;
+    getUnlockedAchievements(playerId: string): Achievement[];
+    getLockedAchievements(playerId: string): Achievement[];
+    getHiddenAchievements(): Achievement[];
+    getVisibleAchievements(playerId: string): Achievement[];
+    getCompletionPercentage(playerId: string): number;
+    getAchievementsByRarity(rarity: AchievementRarity): Achievement[];
+    searchAchievements(query: string): Achievement[];
+    processRetroactive(playerId: string): void;
+    exportAchievements(): string;
+    importAchievements(json: string): boolean;
+    exportProgress(playerId: string): string;
+    importProgress(playerId: string, json: string): boolean;
+}
+export declare function createAchievementManager(): AchievementManager;
+export declare function createAchievementTrigger(type: TriggerType, target: string, operator: ComparisonOperator, value: number | string | boolean): AchievementTrigger;
+export declare function createAchievementCondition(triggers: AchievementTrigger[], logic?: 'and' | 'or'): AchievementCondition;

package/dist/types/editor/AnimationRetargeting.d.ts

@@ -0,0 +1,200 @@
+/**
+ * @file AnimationRetargeting.ts
+ * @description Animation Retargeting system for applying animations cross-skeletons
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Skeleton hierarchy definition
+ * - Bone mapping between source and target skeletons
+ * - Auto-mapping based on bone names
+ * - Manual mapping adjustment
+ * - Bone transforms (rotation, position, scale adjustments)
+ * - Animation clip retargeting
+ * - Root motion handling
+ * - Finger/hand mapping for humanoids
+ * - Mirror animations (left/right swap)
+ * - Blend shape mapping
+ * - IK adjustment options
+ */
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface BoneTransform {
+    position: Vector3;
+    rotation: Quaternion;
+    scale: Vector3;
+}
+export interface Bone {
+    id: string;
+    name: string;
+    parentId: string | null;
+    localTransform: BoneTransform;
+    worldTransform?: BoneTransform;
+    length: number;
+    children: string[];
+    humanoidBone?: HumanoidBone;
+    constraints?: BoneConstraints;
+}
+export interface BoneConstraints {
+    rotationMin?: Vector3;
+    rotationMax?: Vector3;
+    twist?: {
+        min: number;
+        max: number;
+    };
+    swing?: {
+        yMin: number;
+        yMax: number;
+        xMin: number;
+        xMax: number;
+    };
+}
+export type HumanoidBone = 'Hips' | 'Spine' | 'Chest' | 'UpperChest' | 'Neck' | 'Head' | 'LeftShoulder' | 'LeftUpperArm' | 'LeftLowerArm' | 'LeftHand' | 'RightShoulder' | 'RightUpperArm' | 'RightLowerArm' | 'RightHand' | 'LeftUpperLeg' | 'LeftLowerLeg' | 'LeftFoot' | 'LeftToes' | 'RightUpperLeg' | 'RightLowerLeg' | 'RightFoot' | 'RightToes' | 'LeftThumbProximal' | 'LeftThumbIntermediate' | 'LeftThumbDistal' | 'LeftIndexProximal' | 'LeftIndexIntermediate' | 'LeftIndexDistal' | 'LeftMiddleProximal' | 'LeftMiddleIntermediate' | 'LeftMiddleDistal' | 'LeftRingProximal' | 'LeftRingIntermediate' | 'LeftRingDistal' | 'LeftLittleProximal' | 'LeftLittleIntermediate' | 'LeftLittleDistal' | 'RightThumbProximal' | 'RightThumbIntermediate' | 'RightThumbDistal' | 'RightIndexProximal' | 'RightIndexIntermediate' | 'RightIndexDistal' | 'RightMiddleProximal' | 'RightMiddleIntermediate' | 'RightMiddleDistal' | 'RightRingProximal' | 'RightRingIntermediate' | 'RightRingDistal' | 'RightLittleProximal' | 'RightLittleIntermediate' | 'RightLittleDistal';
+export interface Skeleton {
+    id: string;
+    name: string;
+    bones: Map<string, Bone>;
+    rootBoneId: string;
+    isHumanoid: boolean;
+    humanoidMapping?: Map<HumanoidBone, string>;
+    tPose?: Map<string, BoneTransform>;
+    scale: number;
+    upAxis: 'y' | 'z';
+    forwardAxis: 'z' | 'x' | '-z' | '-x';
+}
+export interface BoneMapping {
+    sourceBoneId: string;
+    targetBoneId: string;
+    mappingType: 'direct' | 'twist' | 'copy' | 'ignore';
+    rotationOffset?: Quaternion;
+    positionOffset?: Vector3;
+    scaleMultiplier?: Vector3;
+    twistWeight?: number;
+    isMirroredPair?: boolean;
+    mirrorBoneId?: string;
+}
+export interface AnimationKeyframe {
+    time: number;
+    value: number | Vector3 | Quaternion;
+    inTangent?: number | Vector3;
+    outTangent?: number | Vector3;
+    interpolation: 'linear' | 'step' | 'cubic' | 'hermite';
+}
+export interface AnimationTrack {
+    boneId: string;
+    property: 'position' | 'rotation' | 'scale' | 'blendShape';
+    keyframes: AnimationKeyframe[];
+    blendShapeName?: string;
+}
+export interface AnimationClip {
+    id: string;
+    name: string;
+    duration: number;
+    frameRate: number;
+    tracks: AnimationTrack[];
+    hasRootMotion: boolean;
+    rootMotionBoneId?: string;
+    isLooping: boolean;
+    loopTime?: number;
+    events?: AnimationEvent[];
+    sourceSkeletonId: string;
+}
+export interface AnimationEvent {
+    time: number;
+    name: string;
+    data?: unknown;
+}
+export interface RetargetingProfile {
+    id: string;
+    name: string;
+    description: string;
+    sourceSkeletonId: string;
+    targetSkeletonId: string;
+    boneMappings: BoneMapping[];
+    globalScale: number;
+    globalRotationOffset: Quaternion;
+    rootMotionScale: Vector3;
+    preserveHipHeight: boolean;
+    adjustArmLength: boolean;
+    adjustLegLength: boolean;
+    useSourcePose: boolean;
+    mirrorMode: 'none' | 'x' | 'z';
+    useFootIK: boolean;
+    useHandIK: boolean;
+    footGroundOffset: number;
+    createdAt: number;
+    modifiedAt: number;
+}
+export interface RetargetingResult {
+    success: boolean;
+    clip?: AnimationClip;
+    warnings: string[];
+    errors: string[];
+    unmappedBones: string[];
+    scaleDifferences: Map<string, number>;
+}
+export declare class AnimationRetargeting {
+    private skeletons;
+    private profiles;
+    private clips;
+    private humanoidNamePatterns;
+    private mirrorPairs;
+    constructor();
+    private buildNamePatterns;
+    private buildMirrorPairs;
+    registerSkeleton(skeleton: Skeleton): void;
+    getSkeleton(id: string): Skeleton | undefined;
+    createSkeleton(name: string, bones: Bone[]): Skeleton;
+    markAsHumanoid(skeletonId: string): boolean;
+    private autoDetectHumanoidMapping;
+    setHumanoidBoneMapping(skeletonId: string, humanoidBone: HumanoidBone, boneId: string): boolean;
+    createRetargetingProfile(name: string, sourceSkeletonId: string, targetSkeletonId: string): RetargetingProfile | null;
+    private autoGenerateMappings;
+    private findMatchingBone;
+    getProfile(id: string): RetargetingProfile | undefined;
+    updateProfile(id: string, updates: Partial<RetargetingProfile>): boolean;
+    setBoneMapping(profileId: string, mapping: BoneMapping): boolean;
+    removeBoneMapping(profileId: string, sourceBoneId: string): boolean;
+    registerClip(clip: AnimationClip): void;
+    getClip(id: string): AnimationClip | undefined;
+    retargetClip(clipId: string, profileId: string): RetargetingResult;
+    private retargetTrack;
+    private retargetKeyframe;
+    private retargetRotation;
+    private retargetPosition;
+    private retargetScale;
+    private mirrorTrack;
+    private adjustRootMotion;
+    getBoneHierarchy(skeletonId: string): BoneHierarchyNode[];
+    getMappingVisualization(profileId: string): MappingVisualization[];
+    serializeProfile(profileId: string): string | null;
+    deserializeProfile(json: string): RetargetingProfile | null;
+    serializeSkeleton(skeletonId: string): string | null;
+    deserializeSkeleton(json: string): Skeleton | null;
+}
+export interface BoneHierarchyNode {
+    id: string;
+    name: string;
+    humanoidBone?: HumanoidBone;
+    children: BoneHierarchyNode[];
+}
+export interface MappingVisualization {
+    sourceBoneId: string;
+    sourceBoneName: string;
+    targetBoneId: string;
+    targetBoneName: string;
+    mappingType: string;
+    hasOffset: boolean;
+    isMirrorPair: boolean;
+}
+export declare function createAnimationRetargeting(): AnimationRetargeting;
+export declare function createBone(name: string, parentId?: string | null, transform?: Partial<BoneTransform>): Bone;
+export declare function createAnimationClip(name: string, sourceSkeletonId: string, duration?: number, frameRate?: number): AnimationClip;