@nice2dev/game-engine 0.1.0 → 1.0.2

package/dist/types/quest/QuestSystem.d.ts

@@ -0,0 +1,287 @@
+import type { EntityId } from '../core/types';
+import { EventBus } from '../core/EventBus';
+import React from 'react';
+/** Quest categories */
+export type QuestType = 'main' | 'side' | 'daily' | 'weekly' | 'achievement' | 'tutorial' | 'hidden';
+/** Quest status */
+export type QuestStatus = 'locked' | 'available' | 'active' | 'completed' | 'failed' | 'expired';
+/** Objective types */
+export type ObjectiveType = 'collect' | 'kill' | 'interact' | 'reach' | 'escort' | 'defend' | 'survive' | 'craft' | 'talk' | 'discover' | 'score' | 'custom';
+/** Reward types */
+export type RewardType = 'experience' | 'currency' | 'item' | 'skill' | 'reputation' | 'unlock' | 'achievement' | 'custom';
+/** Difficulty levels */
+export type QuestDifficulty = 'trivial' | 'easy' | 'normal' | 'hard' | 'legendary';
+export interface QuestObjective {
+    id: string;
+    type: ObjectiveType;
+    description: string;
+    /** Current progress */
+    current: number;
+    /** Target value to complete */
+    target: number;
+    /** Whether this objective is optional */
+    optional?: boolean;
+    /** Whether this objective is hidden until progress is made */
+    hidden?: boolean;
+    /** Order for sequential objectives */
+    order?: number;
+    /** Custom data for objective tracking */
+    trackingData?: {
+        itemId?: string;
+        enemyType?: string;
+        entityId?: EntityId;
+        locationId?: string;
+        npcId?: string;
+        [key: string]: unknown;
+    };
+    /** Completion status */
+    completed: boolean;
+}
+export interface QuestReward {
+    id: string;
+    type: RewardType;
+    /** Display name */
+    name: string;
+    /** Icon URL or icon key */
+    icon?: string;
+    /** Reward amount (for currency, experience) */
+    amount?: number;
+    /** Item ID (for item rewards) */
+    itemId?: string;
+    /** Quantity of items */
+    quantity?: number;
+    /** Skill ID (for skill unlocks) */
+    skillId?: string;
+    /** Reputation faction and amount */
+    reputation?: {
+        factionId: string;
+        amount: number;
+    };
+    /** What gets unlocked */
+    unlockId?: string;
+    /** Custom reward data */
+    customData?: Record<string, unknown>;
+}
+export interface QuestPrerequisite {
+    type: 'quest' | 'level' | 'item' | 'reputation' | 'skill' | 'time' | 'custom';
+    /** Quest ID that must be completed */
+    questId?: string;
+    /** Minimum level required */
+    level?: number;
+    /** Item that must be possessed */
+    itemId?: string;
+    /** Minimum reputation with faction */
+    reputation?: {
+        factionId: string;
+        amount: number;
+    };
+    /** Skill that must be unlocked */
+    skillId?: string;
+    /** Time window (for daily/weekly quests) */
+    timeWindow?: {
+        start: number;
+        end: number;
+    };
+    /** Custom condition key */
+    customKey?: string;
+}
+export interface Quest {
+    id: string;
+    /** Display name */
+    name: string;
+    /** Short description shown in quest list */
+    summary: string;
+    /** Full description with story/context */
+    description: string;
+    /** Quest category */
+    type: QuestType;
+    /** Difficulty rating */
+    difficulty: QuestDifficulty;
+    /** Quest icon */
+    icon?: string;
+    /** Quest giver NPC ID */
+    giverNpcId?: string;
+    /** Quest turn-in NPC ID */
+    turnInNpcId?: string;
+    /** Location hint */
+    locationHint?: string;
+    /** Level recommendation */
+    recommendedLevel?: number;
+    /** Objectives to complete */
+    objectives: QuestObjective[];
+    /** Rewards on completion */
+    rewards: QuestReward[];
+    /** Bonus rewards for optional objectives */
+    bonusRewards?: QuestReward[];
+    /** Prerequisites to unlock */
+    prerequisites: QuestPrerequisite[];
+    /** Quests that follow this one */
+    followUpQuests?: string[];
+    /** Tags for filtering */
+    tags?: string[];
+    /** Time limit in seconds (0 = no limit) */
+    timeLimit?: number;
+    /** Can quest be abandoned? */
+    canAbandon?: boolean;
+    /** Can quest be repeated? */
+    repeatable?: boolean;
+    /** Cooldown between repeats (ms) */
+    repeatCooldown?: number;
+    /** Custom quest data */
+    metadata?: Record<string, unknown>;
+}
+export interface QuestState {
+    questId: string;
+    status: QuestStatus;
+    objectives: QuestObjective[];
+    /** When quest was accepted */
+    startedAt?: number;
+    /** When quest was completed/failed */
+    endedAt?: number;
+    /** Time remaining (for timed quests) */
+    timeRemaining?: number;
+    /** Number of times completed (for repeatable) */
+    completionCount: number;
+    /** Last completion timestamp */
+    lastCompletedAt?: number;
+}
+export interface QuestJournal {
+    activeQuests: QuestState[];
+    completedQuests: QuestState[];
+    failedQuests: QuestState[];
+    trackedQuestId?: string;
+}
+export type QuestEventType = 'quest:unlocked' | 'quest:accepted' | 'quest:objective-progress' | 'quest:objective-completed' | 'quest:completed' | 'quest:failed' | 'quest:abandoned' | 'quest:reward-claimed' | 'quest:tracked';
+export interface QuestEvent {
+    type: QuestEventType;
+    questId: string;
+    objectiveId?: string;
+    data?: unknown;
+    timestamp: number;
+}
+export declare class QuestManager {
+    private quests;
+    private journal;
+    private events;
+    private playerLevel;
+    private playerItems;
+    private playerSkills;
+    private reputation;
+    private customConditions;
+    constructor(events?: EventBus);
+    registerQuest(quest: Quest): void;
+    registerQuests(quests: Quest[]): void;
+    unregisterQuest(questId: string): void;
+    getQuest(questId: string): Quest | undefined;
+    getAllQuests(): Quest[];
+    setPlayerLevel(level: number): void;
+    addPlayerItem(itemId: string): void;
+    removePlayerItem(itemId: string): void;
+    addPlayerSkill(skillId: string): void;
+    setReputation(factionId: string, amount: number): void;
+    addReputation(factionId: string, amount: number): void;
+    registerCustomCondition(key: string, condition: () => boolean): void;
+    getQuestState(questId: string): QuestState | undefined;
+    getQuestStatus(questId: string): QuestStatus;
+    getActiveQuests(): QuestState[];
+    getCompletedQuests(): QuestState[];
+    getAvailableQuests(): Quest[];
+    getJournal(): QuestJournal;
+    canUnlockQuest(questId: string): boolean;
+    private checkPrerequisite;
+    acceptQuest(questId: string): boolean;
+    abandonQuest(questId: string): boolean;
+    updateObjectiveProgress(questId: string, objectiveId: string, amount: number): boolean;
+    setObjectiveProgress(questId: string, objectiveId: string, value: number): boolean;
+    completeObjective(questId: string, objectiveId: string): boolean;
+    private checkQuestCompletion;
+    completeQuest(questId: string): boolean;
+    failQuest(questId: string): boolean;
+    private checkQuestUnlocks;
+    private checkFollowUpQuests;
+    getQuestRewards(questId: string): {
+        main: QuestReward[];
+        bonus: QuestReward[];
+    } | null;
+    claimRewards(questId: string): QuestReward[] | null;
+    trackQuest(questId: string): void;
+    untrackQuest(): void;
+    getTrackedQuest(): QuestState | undefined;
+    update(deltaMs: number): void;
+    saveState(): QuestJournal;
+    loadState(journal: QuestJournal): void;
+    private emitEvent;
+    subscribe(eventType: QuestEventType, handler: (event: QuestEvent) => void): () => void;
+}
+export declare class QuestBuilder {
+    private quest;
+    private objectiveCounter;
+    private rewardCounter;
+    constructor(id: string, name: string);
+    summary(summary: string): this;
+    description(description: string): this;
+    type(type: QuestType): this;
+    difficulty(difficulty: QuestDifficulty): this;
+    icon(icon: string): this;
+    giver(npcId: string): this;
+    turnIn(npcId: string): this;
+    location(hint: string): this;
+    level(level: number): this;
+    timeLimit(seconds: number): this;
+    cannotAbandon(): this;
+    repeatable(cooldownMs?: number): this;
+    tags(tags: string[]): this;
+    followUp(questIds: string[]): this;
+    requireQuest(questId: string): this;
+    requireLevel(level: number): this;
+    requireItem(itemId: string): this;
+    requireReputation(factionId: string, amount: number): this;
+    requireSkill(skillId: string): this;
+    requireCustom(customKey: string): this;
+    private addObjective;
+    collect(itemId: string, amount: number, description: string, optional?: boolean): this;
+    kill(enemyType: string, amount: number, description: string, optional?: boolean): this;
+    interact(entityId: EntityId, description: string, optional?: boolean): this;
+    reach(locationId: string, description: string, optional?: boolean): this;
+    escort(npcId: string, locationId: string, description: string, optional?: boolean): this;
+    defend(seconds: number, description: string, optional?: boolean): this;
+    survive(seconds: number, description: string, optional?: boolean): this;
+    craft(itemId: string, amount: number, description: string, optional?: boolean): this;
+    talk(npcId: string, description: string, optional?: boolean): this;
+    discover(locationId: string, description: string, optional?: boolean): this;
+    score(threshold: number, description: string, optional?: boolean): this;
+    customObjective(type: string, target: number, description: string, data?: Record<string, unknown>, optional?: boolean): this;
+    private generateRewardId;
+    rewardXP(amount: number, name?: string): this;
+    rewardCurrency(amount: number, currencyName?: string): this;
+    rewardItem(itemId: string, name: string, quantity?: number, icon?: string): this;
+    rewardSkill(skillId: string, name: string, icon?: string): this;
+    rewardReputation(factionId: string, amount: number, factionName: string): this;
+    rewardUnlock(unlockId: string, name: string, icon?: string): this;
+    rewardAchievement(achievementId: string, name: string, icon?: string): this;
+    bonusXP(amount: number, name?: string): this;
+    bonusItem(itemId: string, name: string, quantity?: number, icon?: string): this;
+    build(): Quest;
+}
+export interface QuestListProps {
+    quests: QuestState[];
+    questDefinitions: Map<string, Quest>;
+    trackedId?: string;
+    onSelect?: (questId: string) => void;
+    onTrack?: (questId: string) => void;
+    filter?: QuestType[];
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare const QuestList: React.FC<QuestListProps>;
+export interface QuestTrackerProps {
+    state: QuestState;
+    quest: Quest;
+    showOptional?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare const QuestTracker: React.FC<QuestTrackerProps>;
+export declare function createEmptyQuest(id: string, name: string): Quest;
+export declare const DIFFICULTY_COLORS: Record<QuestDifficulty, string>;
+export declare const DIFFICULTY_XP_MULTIPLIERS: Record<QuestDifficulty, number>;

package/dist/types/rendering/WebGPURenderPipeline.d.ts

@@ -0,0 +1,255 @@
+export type GPUTextureFormatType = 'bgra8unorm' | 'rgba8unorm' | 'rgba16float' | 'rgba32float' | 'depth24plus' | 'depth32float' | 'depth24plus-stencil8';
+export type GPUBlendModeType = 'opaque' | 'alpha-blend' | 'additive' | 'multiply' | 'premultiplied';
+export type ToneMappingMode = 'none' | 'reinhard' | 'aces' | 'filmic' | 'uncharted2';
+export type MaterialType = 'pbr' | 'unlit' | 'sprite' | 'particle' | 'custom';
+export type RenderPassType = 'depth-prepass' | 'shadow' | 'color' | 'transparent' | 'post-process' | 'ui-overlay';
+export type LightCategory = 'directional' | 'point' | 'spot' | 'area';
+export type PostEffectType = 'bloom' | 'fxaa' | 'taa' | 'ssao' | 'motion-blur' | 'chromatic-aberration' | 'vignette' | 'color-grading' | 'dof' | 'film-grain';
+export interface VertexAttribute {
+    name: string;
+    format: string;
+    offset: number;
+    shaderLocation: number;
+}
+export interface VertexBufferLayout {
+    arrayStride: number;
+    stepMode: 'vertex' | 'instance';
+    attributes: VertexAttribute[];
+}
+/** Standard vertex layout: position(3) + normal(3) + uv(2) + tangent(4) */
+export declare const STANDARD_VERTEX_LAYOUT: VertexBufferLayout;
+/** Instance data layout: model matrix (4x4) + color (4) */
+export declare const INSTANCE_LAYOUT: VertexBufferLayout;
+export interface GPUTextureRef {
+    id: string;
+    uri?: string;
+    width: number;
+    height: number;
+    format: GPUTextureFormatType;
+    mipLevels: number;
+}
+export interface PBRMaterial {
+    type: 'pbr';
+    albedo: [number, number, number, number];
+    albedoTexture?: GPUTextureRef;
+    metallic: number;
+    roughness: number;
+    metallicRoughnessTexture?: GPUTextureRef;
+    normalTexture?: GPUTextureRef;
+    normalScale: number;
+    occlusionTexture?: GPUTextureRef;
+    occlusionStrength: number;
+    emissive: [number, number, number];
+    emissiveTexture?: GPUTextureRef;
+    emissiveIntensity: number;
+    alphaMode: 'opaque' | 'mask' | 'blend';
+    alphaCutoff: number;
+    doubleSided: boolean;
+}
+export interface UnlitMaterial {
+    type: 'unlit';
+    color: [number, number, number, number];
+    texture?: GPUTextureRef;
+    alphaMode: 'opaque' | 'mask' | 'blend';
+    alphaCutoff: number;
+}
+export interface SpriteMaterial {
+    type: 'sprite';
+    texture: GPUTextureRef;
+    tint: [number, number, number, number];
+    uvRect: [number, number, number, number];
+    pixelPerfect: boolean;
+}
+export interface CustomMaterial {
+    type: 'custom';
+    shaderCode: string;
+    uniforms: Record<string, number | number[] | GPUTextureRef>;
+    blendMode: GPUBlendModeType;
+}
+export type RenderMaterial = PBRMaterial | UnlitMaterial | SpriteMaterial | CustomMaterial;
+export declare const DEFAULT_PBR: PBRMaterial;
+export interface GPULight {
+    category: LightCategory;
+    color: [number, number, number];
+    intensity: number;
+    /** World-space position (point/spot/area) */
+    position?: [number, number, number];
+    /** Direction (directional/spot) */
+    direction?: [number, number, number];
+    /** Range for point/spot (0 = infinite) */
+    range?: number;
+    /** Inner/outer cone angle in radians (spot only) */
+    innerConeAngle?: number;
+    outerConeAngle?: number;
+    /** Cast shadows */
+    castShadow: boolean;
+    shadowMapSize?: number;
+    shadowBias?: number;
+}
+export interface RenderBatch {
+    id: string;
+    vertexData: Float32Array;
+    indexData: Uint32Array;
+    instanceCount: number;
+    instanceData?: Float32Array;
+    material: RenderMaterial;
+    layer: number;
+    castShadow: boolean;
+    receiveShadow: boolean;
+}
+export interface ClusteredLightConfig {
+    tileCountX: number;
+    tileCountY: number;
+    sliceCount: number;
+    maxLightsPerCluster: number;
+}
+export interface ShadowConfig {
+    enabled: boolean;
+    mapSize: number;
+    cascadeCount: number;
+    cascadeSplitLambda: number;
+    bias: number;
+    normalBias: number;
+    pcfRadius: number;
+}
+export interface PostProcessConfig {
+    enabled: boolean;
+    effects: PostEffectSettings[];
+    hdrEnabled: boolean;
+    toneMapping: ToneMappingMode;
+    exposure: number;
+    gamma: number;
+}
+export interface PostEffectSettings {
+    type: PostEffectType;
+    enabled: boolean;
+    intensity: number;
+    params: Record<string, number>;
+}
+export interface WebGPURenderConfig {
+    canvasFormat: GPUTextureFormatType;
+    sampleCount: number;
+    maxLights: number;
+    clusteredLighting: ClusteredLightConfig;
+    shadows: ShadowConfig;
+    postProcess: PostProcessConfig;
+    maxInstances: number;
+    depthPrepassEnabled: boolean;
+    frustumCulling: boolean;
+    occlusionCulling: boolean;
+    sortTransparents: boolean;
+}
+export declare const DEFAULT_RENDER_CONFIG: WebGPURenderConfig;
+export interface GPUResourceHandle {
+    id: string;
+    type: 'buffer' | 'texture' | 'sampler' | 'pipeline' | 'bind-group';
+}
+export interface GPUStats {
+    drawCalls: number;
+    triangles: number;
+    instances: number;
+    textureMegabytes: number;
+    bufferMegabytes: number;
+    pipelineSwitches: number;
+    frameTimeMs: number;
+    gpuTimeMs: number;
+}
+/** Track GPU resource allocations */
+export declare class GPUResourceTracker {
+    private resources;
+    private totalBytes;
+    register(id: string, type: string, sizeBytes: number, label?: string): void;
+    release(id: string): void;
+    getStats(): {
+        count: number;
+        totalMB: number;
+        byType: Record<string, number>;
+    };
+    clear(): void;
+}
+export interface RenderPassDescriptor {
+    type: RenderPassType;
+    label: string;
+    enabled: boolean;
+    order: number;
+}
+/** Collects batches, sorts, and generates draw calls per pass */
+export declare class RenderPipelineManager {
+    private config;
+    private passes;
+    private batches;
+    private lights;
+    private stats;
+    private resourceTracker;
+    constructor(config?: Partial<WebGPURenderConfig>);
+    private initDefaultPasses;
+    getConfig(): Readonly<WebGPURenderConfig>;
+    updateConfig(patch: Partial<WebGPURenderConfig>): void;
+    submitBatch(batch: RenderBatch): void;
+    submitLight(light: GPULight): void;
+    clearFrame(): void;
+    /** Sort and organize batches for rendering */
+    preparePasses(): Map<RenderPassType, RenderBatch[]>;
+    private isOpaque;
+    /** Generate draw statistics */
+    computeStats(): GPUStats;
+    getLights(): readonly GPULight[];
+    getPasses(): readonly RenderPassDescriptor[];
+    getResourceTracker(): GPUResourceTracker;
+}
+export interface WebGPURendererState {
+    initialized: boolean;
+    supported: boolean;
+    adapterInfo: string;
+    deviceLimits: Record<string, number>;
+}
+/** High-level WebGPU renderer that manages device, pipelines, and frame submission */
+export declare class WebGPURenderer {
+    private pipeline;
+    private state;
+    private frameCallback;
+    constructor(config?: Partial<WebGPURenderConfig>);
+    /** Check WebGPU support */
+    isSupported(): boolean;
+    /** Initialize the WebGPU device */
+    initialize(): Promise<boolean>;
+    /** Submit a renderable batch */
+    submit(batch: RenderBatch): void;
+    /** Submit a light */
+    addLight(light: GPULight): void;
+    /** Execute full render frame */
+    renderFrame(): GPUStats;
+    /** Register frame callback */
+    onFrame(cb: (stats: GPUStats) => void): void;
+    getState(): Readonly<WebGPURendererState>;
+    getPipeline(): RenderPipelineManager;
+    /** Get available shader sources for debug/customization */
+    getShaderSources(): Record<string, string>;
+    destroy(): void;
+}
+export interface PostProcessPass {
+    type: PostEffectType;
+    enabled: boolean;
+    intensity: number;
+    params: Record<string, number>;
+}
+export declare const BLOOM_DEFAULTS: PostProcessPass;
+export declare const FXAA_DEFAULTS: PostProcessPass;
+export declare const SSAO_DEFAULTS: PostProcessPass;
+export declare const DOF_DEFAULTS: PostProcessPass;
+export declare const COLOR_GRADING_DEFAULTS: PostProcessPass;
+/** Manage ordered post-process stack */
+export declare class PostProcessStack {
+    private passes;
+    add(pass: PostProcessPass): void;
+    remove(type: PostEffectType): void;
+    setEnabled(type: PostEffectType, enabled: boolean): void;
+    setIntensity(type: PostEffectType, intensity: number): void;
+    getActive(): PostProcessPass[];
+    getAll(): readonly PostProcessPass[];
+    reorder(order: PostEffectType[]): void;
+    clear(): void;
+}
+export type QualityPreset = 'low' | 'medium' | 'high' | 'ultra';
+export declare const QUALITY_PRESET_CONFIGS: Record<QualityPreset, Partial<WebGPURenderConfig>>;
+export declare function applyQualityPreset(preset: QualityPreset): WebGPURenderConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nice2dev/game-engine",
-  "version": "0.1.0",
+  "version": "1.0.2",
   "description": "Nice2Dev Game Engine — No-code game engine and editor for React",
   "author": "NiceToDev <contact@nicetodev.com>",
   "license": "MIT",
@@ -59,11 +59,17 @@
     "nicetodev"
   ],
   "peerDependencies": {
+    "@nice2dev/icons-gaming": "*",
     "@nice2dev/ui": "^1.0.0",
     "@nice2dev/ui-graphics": "^1.0.0",
     "react": ">=17.0.0",
     "react-dom": ">=17.0.0"
   },
+  "peerDependenciesMeta": {
+    "@nice2dev/icons-gaming": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@microsoft/signalr": "^10.0.0",
     "@rollup/plugin-commonjs": "^28.0.0",