@nice2dev/game-engine 0.1.0

package/dist/types/runtime3d/SceneEditor3D.d.ts

@@ -0,0 +1,186 @@
+import type { EntityId } from '../core/types';
+import type { Vec3, Quaternion, World3D, MeshPrimitive } from './Runtime3D';
+export type Gizmo3DMode = 'translate' | 'rotate' | 'scale';
+export type Gizmo3DAxis = 'x' | 'y' | 'z' | 'xy' | 'xz' | 'yz' | 'none';
+export type Gizmo3DSpace = 'world' | 'local';
+export interface Gizmo3DState {
+    mode: Gizmo3DMode;
+    activeAxis: Gizmo3DAxis;
+    space: Gizmo3DSpace;
+    dragging: boolean;
+    startPosition: Vec3;
+    startRotation: Quaternion;
+    startScale: Vec3;
+}
+export declare function createGizmo3DState(): Gizmo3DState;
+export interface PlacementConfig {
+    snapEnabled: boolean;
+    gridSize: number;
+    surfaceSnap: boolean;
+    randomRotation: boolean;
+}
+export declare const DEFAULT_PLACEMENT_CONFIG: PlacementConfig;
+export declare function snapToGrid3D(pos: Vec3, gridSize: number): Vec3;
+export declare function placeObject(world: World3D, primitive: MeshPrimitive, position: Vec3, config: PlacementConfig): EntityId;
+export interface TerrainConfig {
+    width: number;
+    depth: number;
+    resolution: number;
+    maxHeight: number;
+}
+export declare const DEFAULT_TERRAIN_CONFIG: TerrainConfig;
+export declare class Terrain3D {
+    readonly config: TerrainConfig;
+    readonly heightmap: Float32Array;
+    constructor(config?: Partial<TerrainConfig>);
+    getHeight(gridX: number, gridZ: number): number;
+    setHeight(gridX: number, gridZ: number, h: number): void;
+    /** Get interpolated height at world coordinates. */
+    getHeightAtWorld(worldX: number, worldZ: number): number;
+    /** Raise/lower terrain around a point. */
+    brush(worldX: number, worldZ: number, radius: number, strength: number): void;
+    /** Flatten terrain around a point to a given height. */
+    flatten(worldX: number, worldZ: number, radius: number, targetHeight: number): void;
+    /** Export heightmap to a simple JSON-serialisable format. */
+    serialize(): {
+        config: TerrainConfig;
+        heights: number[];
+    };
+    static deserialize(data: {
+        config: TerrainConfig;
+        heights: number[];
+    }): Terrain3D;
+}
+export interface SkyboxConfig {
+    type: 'color' | 'cubemap' | 'hdri';
+    color?: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    textureIds?: string[];
+}
+export declare const DEFAULT_SKYBOX: SkyboxConfig;
+export interface ModelAsset {
+    id: string;
+    name: string;
+    format: 'gltf' | 'glb' | 'fbx' | 'obj';
+    meshCount: number;
+    materialCount: number;
+    animationCount: number;
+    boneCount: number;
+}
+export interface AnimationRetargetMap {
+    /** Maps source bone name → target bone name. */
+    boneMapping: Record<string, string>;
+}
+export interface IKChain {
+    name: string;
+    root: string;
+    tip: string;
+    poleTarget?: Vec3;
+    iterations: number;
+    tolerance: number;
+}
+export interface BlendTreeNode {
+    name: string;
+    animationId: string | null;
+    children: BlendTreeNode[];
+    blendParameter: string;
+    threshold: number;
+}
+export declare function createBlendTree(rootName: string): BlendTreeNode;
+export declare function addBlendTreeChild(parent: BlendTreeNode, animationId: string, threshold: number, name?: string): BlendTreeNode;
+/** Evaluate blend tree → returns pairs of [animId, weight]. */
+export declare function evaluateBlendTree(node: BlendTreeNode, parameterValue: number): Array<{
+    animationId: string;
+    weight: number;
+}>;
+export interface ShaderUniform {
+    name: string;
+    type: 'float' | 'vec2' | 'vec3' | 'vec4' | 'mat4' | 'sampler2D';
+    value: number | number[] | string;
+}
+export interface ShaderDef {
+    id: string;
+    name: string;
+    vertexSource?: string;
+    fragmentSource?: string;
+    uniforms: ShaderUniform[];
+}
+export interface DecalDef {
+    textureId: string;
+    size: Vec3;
+    angle: number;
+    opacity: number;
+}
+/** Material library for managing PBR materials. */
+export declare class MaterialLibrary {
+    private materials;
+    add(mat: import('./Runtime3D').Material3D): void;
+    get(id: string): import('./Runtime3D').Material3D | undefined;
+    remove(id: string): boolean;
+    all(): import('./Runtime3D').Material3D[];
+    /** Duplicate a material with a new id. */
+    clone(sourceId: string, newName?: string): import('./Runtime3D').Material3D | null;
+    /** Export all materials to JSON-serialisable array. */
+    serialize(): import('./Runtime3D').Material3D[];
+    load(materials: import('./Runtime3D').Material3D[]): void;
+}
+export interface FPSTemplateConfig {
+    moveSpeed: number;
+    lookSensitivity: number;
+    jumpForce: number;
+    gravity: number;
+    weaponSlots: number;
+    healthMax: number;
+    crosshairSize: number;
+}
+export declare const DEFAULT_FPS_CONFIG: FPSTemplateConfig;
+export interface ThirdPersonTemplateConfig {
+    moveSpeed: number;
+    sprintMultiplier: number;
+    jumpForce: number;
+    gravity: number;
+    cameraDistance: number;
+    cameraPitchMin: number;
+    cameraPitchMax: number;
+    cameraSmoothing: number;
+    lockOnRadius: number;
+}
+export declare const DEFAULT_THIRD_PERSON_CONFIG: ThirdPersonTemplateConfig;
+export interface RacingTemplate3DConfig {
+    maxSpeed: number;
+    acceleration: number;
+    braking: number;
+    turnSpeed: number;
+    driftFactor: number;
+    gravity: number;
+    cameraFollowDistance: number;
+    cameraHeight: number;
+}
+export declare const DEFAULT_RACING_3D_CONFIG: RacingTemplate3DConfig;
+export interface FlightSimConfig {
+    maxThrust: number;
+    liftCoefficient: number;
+    dragCoefficient: number;
+    rollSpeed: number;
+    pitchSpeed: number;
+    yawSpeed: number;
+    gravity: number;
+    stallAngle: number;
+}
+export declare const DEFAULT_FLIGHT_SIM_CONFIG: FlightSimConfig;
+export interface HorrorTemplateConfig {
+    walkSpeed: number;
+    sprintSpeed: number;
+    staminaMax: number;
+    staminaDrain: number;
+    staminaRegen: number;
+    flashlightRange: number;
+    flashlightAngle: number;
+    sanityMax: number;
+    sanityDecayRate: number;
+    ambientLightIntensity: number;
+}
+export declare const DEFAULT_HORROR_CONFIG: HorrorTemplateConfig;

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

@@ -0,0 +1,2 @@
+export * from './Runtime3D';
+export * from './SceneEditor3D';

package/dist/types/scene/SceneManager.d.ts

@@ -0,0 +1,59 @@
+import type { EntityId, SceneData } from '../core/types';
+import { EventBus } from '../core/EventBus';
+import { World, type ComponentMap } from '../ecs/World';
+export type TransitionType = 'none' | 'fade' | 'slide-left' | 'slide-right' | 'slide-up' | 'slide-down';
+export interface SceneTransition {
+    type: TransitionType;
+    duration: number;
+}
+export interface SceneConfig {
+    id: string;
+    name: string;
+    /** Factory that populates the world. */
+    setup: (world: World) => void | Promise<void>;
+    settings?: Record<string, unknown>;
+}
+export interface PrefabDef {
+    name: string;
+    tags: string[];
+    components: {
+        type: keyof ComponentMap;
+        overrides?: Record<string, unknown>;
+    }[];
+    children?: PrefabDef[];
+}
+export declare class SceneManager {
+    readonly events: EventBus;
+    private scenes;
+    private prefabs;
+    private _currentId;
+    private _loading;
+    private _transition;
+    get currentSceneId(): string | null;
+    get isLoading(): boolean;
+    get transition(): {
+        progress: number;
+        phase: 'out' | 'in';
+    } | null;
+    register(config: SceneConfig): void;
+    unregister(id: string): void;
+    has(id: string): boolean;
+    get registeredScenes(): string[];
+    loadScene(id: string, world: World, transition?: SceneTransition): Promise<void>;
+    /** Reload current scene. */
+    reloadScene(world: World): Promise<void>;
+    updateTransition(dt: number): void;
+    registerPrefab(name: string, prefab: PrefabDef): void;
+    /** Instantiate a prefab into the world. Returns the root entity ID. */
+    instantiate(world: World, prefabName: string, overrides?: {
+        position?: {
+            x: number;
+            y: number;
+        };
+        name?: string;
+    }): EntityId;
+    private instantiatePrefab;
+    serializeScene(world: World, id: string, name: string): SceneData;
+    /** Deserialize a scene into a world. */
+    deserializeScene(world: World, data: SceneData): void;
+}

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

@@ -0,0 +1,2 @@
+export { SceneManager } from './SceneManager';
+export type { SceneConfig, SceneTransition, TransitionType, PrefabDef } from './SceneManager';

package/dist/types/scripting/NodeGraph.d.ts

@@ -0,0 +1,84 @@
+import type { EntityId, Vec2 } from '../core/types';
+import { EventBus } from '../core/EventBus';
+export type PortDataType = 'flow' | 'boolean' | 'number' | 'string' | 'vec2' | 'color' | 'entity' | 'any';
+export type PortDirection = 'input' | 'output';
+export interface PortDef {
+    id: string;
+    name: string;
+    direction: PortDirection;
+    dataType: PortDataType;
+    defaultValue?: unknown;
+    /** Whether multiple connections are allowed (outputs only). */
+    multi?: boolean;
+}
+export type NodeCategory = 'flow' | 'math' | 'logic' | 'entity' | 'input' | 'physics' | 'audio' | 'ui' | 'game' | 'variable' | 'custom';
+export interface NodeDef {
+    type: string;
+    name: string;
+    category: NodeCategory;
+    description: string;
+    color?: string;
+    ports: PortDef[];
+    /** Execute the node given input values, return output values. */
+    execute: (inputs: Record<string, unknown>, context: NodeExecutionContext) => Record<string, unknown> | void;
+}
+export interface NodeExecutionContext {
+    entityId: EntityId | null;
+    dt: number;
+    world: unknown;
+    events: EventBus;
+    variables: Record<string, unknown>;
+    services: Record<string, unknown>;
+    /** Trigger an output flow port. */
+    triggerFlow: (portId: string) => void;
+}
+export interface NodeInstance {
+    id: string;
+    type: string;
+    position: Vec2;
+    /** Override default values for input ports. */
+    inputValues: Record<string, unknown>;
+    /** Cached output values after execution. */
+    outputValues: Record<string, unknown>;
+    comment?: string;
+}
+export interface Connection {
+    id: string;
+    fromNode: string;
+    fromPort: string;
+    toNode: string;
+    toPort: string;
+}
+export interface ScriptGraph {
+    id: string;
+    name: string;
+    nodes: NodeInstance[];
+    connections: Connection[];
+    variables: GraphVariable[];
+    /** Graph-level inputs (parameters) for subgraph use. */
+    parameters: PortDef[];
+}
+export interface GraphVariable {
+    name: string;
+    type: PortDataType;
+    value: unknown;
+    scope: 'local' | 'global';
+}
+export declare class NodeLibrary {
+    private defs;
+    register(def: NodeDef): void;
+    get(type: string): NodeDef | undefined;
+    getAll(): NodeDef[];
+    getByCategory(category: NodeCategory): NodeDef[];
+    search(query: string): NodeDef[];
+}
+export declare class GraphExecutor {
+    readonly events: EventBus;
+    private library;
+    constructor(library: NodeLibrary);
+    /** Execute a graph starting from an entry node (e.g. "on_start", "on_update"). */
+    execute(graph: ScriptGraph, entryType: string, context: NodeExecutionContext): void;
+    private executeNode;
+}
+export declare function registerBuiltInNodes(library: NodeLibrary): void;
+export declare function createDefaultNodeLibrary(): NodeLibrary;

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

@@ -0,0 +1,2 @@
+export { NodeLibrary, GraphExecutor, registerBuiltInNodes, createDefaultNodeLibrary, } from './NodeGraph';
+export type { PortDataType, PortDirection, PortDef, NodeCategory, NodeDef, NodeExecutionContext, NodeInstance, Connection, ScriptGraph, GraphVariable, } from './NodeGraph';

package/dist/types/social/Social.d.ts

@@ -0,0 +1,245 @@
+export interface UserProfile {
+    id: string;
+    displayName: string;
+    avatarUrl: string;
+    bio: string;
+    joinedAt: number;
+    badges: Badge[];
+    stats: UserStats;
+    socialLinks: SocialLink[];
+    privacy: PrivacySettings;
+}
+export interface Badge {
+    id: string;
+    name: string;
+    icon: string;
+    description: string;
+    earnedAt: number;
+}
+export interface UserStats {
+    gamesPublished: number;
+    gamesPlayed: number;
+    totalPlayTimeMs: number;
+    assetsShared: number;
+    ratingsGiven: number;
+    followersCount: number;
+    followingCount: number;
+    jamParticipations: number;
+}
+export interface SocialLink {
+    platform: 'github' | 'twitter' | 'youtube' | 'discord' | 'website' | 'itch';
+    url: string;
+}
+export interface PrivacySettings {
+    profilePublic: boolean;
+    showActivity: boolean;
+    allowMessages: boolean;
+    showOnlineStatus: boolean;
+}
+export type AssetCategory = 'sprites' | 'tilesets' | 'animations' | 'audio-sfx' | 'audio-music' | 'fonts' | 'ui-themes' | 'templates' | 'scripts' | 'shaders' | 'models-3d' | 'particles' | 'complete-projects';
+export type AssetLicense = 'free' | 'cc0' | 'cc-by' | 'cc-by-sa' | 'cc-by-nc' | 'commercial' | 'custom';
+export interface MarketplaceAsset {
+    id: string;
+    name: string;
+    description: string;
+    authorId: string;
+    category: AssetCategory;
+    tags: string[];
+    license: AssetLicense;
+    version: string;
+    price: number;
+    currency: string;
+    thumbnailUrl: string;
+    previewUrls: string[];
+    downloadCount: number;
+    rating: number;
+    ratingCount: number;
+    fileSize: number;
+    createdAt: number;
+    updatedAt: number;
+    compatibility: string[];
+}
+export interface MarketplaceQuery {
+    search?: string;
+    category?: AssetCategory;
+    tags?: string[];
+    license?: AssetLicense;
+    priceMin?: number;
+    priceMax?: number;
+    sortBy: 'relevance' | 'newest' | 'popular' | 'rating' | 'price-asc' | 'price-desc';
+    page: number;
+    pageSize: number;
+}
+export interface MarketplaceResult {
+    assets: MarketplaceAsset[];
+    total: number;
+    page: number;
+    pageSize: number;
+}
+export declare function createMarketplaceQuery(partial?: Partial<MarketplaceQuery>): MarketplaceQuery;
+export type GameVisibility = 'public' | 'unlisted' | 'private' | 'draft';
+export type ContentRating = 'everyone' | 'teen' | 'mature';
+export interface PublishedGame {
+    id: string;
+    title: string;
+    slug: string;
+    authorId: string;
+    description: string;
+    shortDescription: string;
+    thumbnailUrl: string;
+    coverImageUrl: string;
+    screenshotUrls: string[];
+    visibility: GameVisibility;
+    contentRating: ContentRating;
+    genre: string[];
+    tags: string[];
+    version: string;
+    engineVersion: string;
+    playCount: number;
+    likeCount: number;
+    commentCount: number;
+    rating: number;
+    ratingCount: number;
+    createdAt: number;
+    updatedAt: number;
+    publishedAt: number;
+    controls: ControlSchemeInfo;
+    features: GameFeature[];
+    minPlayers: number;
+    maxPlayers: number;
+    embeddable: boolean;
+    remixable: boolean;
+    sourceGameId?: string;
+}
+export type GameFeature = 'multiplayer' | 'mobile' | 'controller' | 'achievements' | 'leaderboards' | 'cloud-save' | 'vr' | 'ar';
+export interface ControlSchemeInfo {
+    keyboard: boolean;
+    mouse: boolean;
+    touch: boolean;
+    gamepad: boolean;
+    vr: boolean;
+}
+export interface PublishConfig {
+    title: string;
+    description: string;
+    visibility: GameVisibility;
+    contentRating: ContentRating;
+    genre: string[];
+    tags: string[];
+    controls: ControlSchemeInfo;
+    remixable: boolean;
+    minPlayers: number;
+    maxPlayers: number;
+}
+export interface Comment {
+    id: string;
+    authorId: string;
+    targetId: string;
+    targetType: 'game' | 'asset';
+    text: string;
+    createdAt: number;
+    updatedAt: number;
+    likes: number;
+    parentId?: string;
+    isEdited: boolean;
+    isPinned: boolean;
+}
+export interface Rating {
+    authorId: string;
+    targetId: string;
+    targetType: 'game' | 'asset';
+    score: number;
+    review?: string;
+    createdAt: number;
+}
+export interface RatingAggregate {
+    targetId: string;
+    average: number;
+    count: number;
+    distribution: [number, number, number, number, number];
+}
+export declare function computeRatingAggregate(ratings: Rating[]): RatingAggregate;
+export type JamPhase = 'upcoming' | 'submission' | 'voting' | 'results' | 'archived';
+export interface GameJam {
+    id: string;
+    title: string;
+    description: string;
+    theme?: string;
+    hostId: string;
+    startDate: number;
+    endDate: number;
+    votingEndDate: number;
+    phase: JamPhase;
+    rules: string;
+    prizes: JamPrize[];
+    categories: JamCategory[];
+    participants: number;
+    submissions: number;
+    maxTeamSize: number;
+    allowLateSubmission: boolean;
+    featured: boolean;
+}
+export interface JamPrize {
+    place: number;
+    description: string;
+    value?: string;
+}
+export interface JamCategory {
+    name: string;
+    description: string;
+    weight: number;
+}
+export interface JamSubmission {
+    id: string;
+    jamId: string;
+    gameId: string;
+    teamName: string;
+    teamMembers: string[];
+    submittedAt: number;
+    description: string;
+    scores: JamScore[];
+    rank?: number;
+    finalScore?: number;
+}
+export interface JamScore {
+    category: string;
+    score: number;
+    voterId: string;
+}
+export declare function computeJamPhase(jam: GameJam, now: number): JamPhase;
+export declare function computeJamResults(submissions: JamSubmission[], categories: JamCategory[]): JamSubmission[];
+export interface FeaturedCollection {
+    id: string;
+    title: string;
+    description: string;
+    gameIds: string[];
+    curatedBy: string;
+    createdAt: number;
+    displayOrder: number;
+}
+export interface DiscoveryFeed {
+    featured: FeaturedCollection[];
+    trending: string[];
+    newReleases: string[];
+    topRated: string[];
+    staffPicks: string[];
+    forYou: string[];
+}
+export interface GameRecommendation {
+    gameId: string;
+    score: number;
+    reason: 'similar-genre' | 'same-author' | 'played-similar' | 'trending' | 'friends-playing';
+}
+/** Simple content-based recommendation by genre/tag overlap. */
+export declare function recommendGames(userPlayedGames: PublishedGame[], allGames: PublishedGame[], limit?: number): GameRecommendation[];
+export type NotificationType = 'comment' | 'rating' | 'follow' | 'jam-start' | 'jam-result' | 'game-feature' | 'asset-review' | 'system' | 'achievement';
+export interface UserNotification {
+    id: string;
+    userId: string;
+    type: NotificationType;
+    title: string;
+    message: string;
+    link?: string;
+    read: boolean;
+    createdAt: number;
+}

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

@@ -0,0 +1 @@
+export * from './Social';