@nice2dev/game-engine 1.1.5 → 1.1.6

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

@@ -0,0 +1,157 @@
+import { EventEmitter } from 'events';
+export type ProjectileId = string;
+export type ProjectileType = string;
+export type EntityId = string;
+export interface Vector2 {
+    x: number;
+    y: number;
+}
+export type MovementPattern = LinearMovement | HomingMovement | ArcMovement | SineMovement | SpiralMovement | BoomerangMovement;
+export interface LinearMovement {
+    type: 'linear';
+    speed: number;
+    acceleration?: number;
+    maxSpeed?: number;
+}
+export interface HomingMovement {
+    type: 'homing';
+    speed: number;
+    turnRate: number;
+    targetId?: EntityId;
+    targetPosition?: Vector2;
+    delay?: number;
+}
+export interface ArcMovement {
+    type: 'arc';
+    speed: number;
+    gravity: number;
+    height?: number;
+}
+export interface SineMovement {
+    type: 'sine';
+    speed: number;
+    amplitude: number;
+    frequency: number;
+}
+export interface SpiralMovement {
+    type: 'spiral';
+    speed: number;
+    radius: number;
+    expansionRate: number;
+}
+export interface BoomerangMovement {
+    type: 'boomerang';
+    speed: number;
+    returnDistance: number;
+    returnSpeed?: number;
+}
+export interface ProjectileDefinition {
+    type: ProjectileType;
+    movement: MovementPattern;
+    damage: number;
+    lifetime: number;
+    size: number;
+    penetration?: number;
+    bounceCount?: number;
+    bounceSpeedLoss?: number;
+    splitOnHit?: ProjectileType;
+    splitCount?: number;
+    explosionRadius?: number;
+    tags?: string[];
+    trailConfig?: TrailConfig;
+}
+export interface TrailConfig {
+    enabled: boolean;
+    length: number;
+    width: number;
+    color: string;
+    fadeOut: boolean;
+}
+export interface ProjectileInstance {
+    id: ProjectileId;
+    type: ProjectileType;
+    ownerId: EntityId;
+    position: Vector2;
+    velocity: Vector2;
+    direction: number;
+    spawnTime: number;
+    state: ProjectileState;
+    penetrationsLeft: number;
+    bouncesLeft: number;
+    distanceTraveled: number;
+    hitEntities: Set<EntityId>;
+    trailPoints: Vector2[];
+    homingTarget?: EntityId | Vector2;
+    returning?: boolean;
+    sinePhase?: number;
+    spiralAngle?: number;
+}
+export type ProjectileState = 'active' | 'exploding' | 'destroyed';
+export interface CollisionResult {
+    entityId: EntityId;
+    position: Vector2;
+    normal?: Vector2;
+}
+export type ProjectileEventType = 'projectile-spawned' | 'projectile-hit' | 'projectile-bounced' | 'projectile-penetrated' | 'projectile-exploded' | 'projectile-destroyed' | 'projectile-split';
+export interface ProjectileEvent {
+    type: ProjectileEventType;
+    projectileId: ProjectileId;
+    projectileType?: ProjectileType;
+    position?: Vector2;
+    targetId?: EntityId;
+    damage?: number;
+}
+export interface ProjectileConfig {
+    maxProjectiles?: number;
+    defaultLifetime?: number;
+    trailMaxLength?: number;
+    usePooling?: boolean;
+}
+export declare const DEFAULT_PROJECTILE_CONFIG: ProjectileConfig;
+export declare class NiceProjectile extends EventEmitter {
+    private definitions;
+    private projectiles;
+    private pool;
+    private nextId;
+    private config;
+    private collisionChecker?;
+    constructor(config?: Partial<ProjectileConfig>);
+    register(definition: ProjectileDefinition): void;
+    unregister(type: ProjectileType): boolean;
+    getDefinition(type: ProjectileType): ProjectileDefinition | undefined;
+    setCollisionChecker(checker: (projectile: ProjectileInstance, definition: ProjectileDefinition) => CollisionResult[]): void;
+    spawn(type: ProjectileType, ownerId: EntityId, position: Vector2, direction: number, options?: Partial<{
+        targetId: EntityId;
+        targetPosition: Vector2;
+        speedMultiplier: number;
+        damageMultiplier: number;
+    }>): ProjectileId | null;
+    private getSpeed;
+    private createInstance;
+    private getFromPool;
+    private returnToPool;
+    update(deltaTime: number): void;
+    private updateMovement;
+    private updateLinear;
+    private updateHoming;
+    private updateArc;
+    private updateSine;
+    private updateSpiral;
+    private updateBoomerang;
+    private updateTrail;
+    private handleCollision;
+    private bounce;
+    private split;
+    private explode;
+    destroy(id: ProjectileId): boolean;
+    destroyAll(): void;
+    destroyByOwner(ownerId: EntityId): void;
+    getProjectile(id: ProjectileId): ProjectileInstance | undefined;
+    getProjectilesByType(type: ProjectileType): ProjectileInstance[];
+    getProjectilesByOwner(ownerId: EntityId): ProjectileInstance[];
+    getAllProjectiles(): ProjectileInstance[];
+    getCount(): number;
+}
+export declare function createProjectileSystem(config?: Partial<ProjectileConfig>): NiceProjectile;
+export declare function defineProjectile(type: ProjectileType, movement: MovementPattern, damage: number, lifetime: number, options?: Partial<Omit<ProjectileDefinition, 'type' | 'movement' | 'damage' | 'lifetime'>>): ProjectileDefinition;
+export default NiceProjectile;

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

@@ -0,0 +1,199 @@
+export type MatchId = string;
+export type PlayerId = string;
+export type TeamId = string;
+export type SeasonId = string;
+export type MatchType = 'duel' | 'arena' | 'battleground' | 'tournament' | 'custom';
+export type MatchStatus = 'pending' | 'starting' | 'active' | 'completed' | 'cancelled';
+export type MatchResult = 'victory' | 'defeat' | 'draw' | 'abandoned';
+export interface PvPPlayer {
+    id: PlayerId;
+    name: string;
+    level: number;
+    character?: string;
+    class?: string;
+    mmr: number;
+    rank: number;
+    seasonPoints: number;
+    wins: number;
+    losses: number;
+    draws: number;
+    winStreak: number;
+    bestWinStreak: number;
+    totalKills: number;
+    totalDeaths: number;
+    totalAssists: number;
+    totalDamage: number;
+    totalHealing: number;
+    isOnline: boolean;
+    inMatch: boolean;
+    lastMatchTime?: number;
+}
+export interface MatchPlayer {
+    playerId: PlayerId;
+    name: string;
+    teamId?: TeamId;
+    character?: string;
+    kills: number;
+    deaths: number;
+    assists: number;
+    damage: number;
+    healing: number;
+    score: number;
+    connected: boolean;
+    ready: boolean;
+}
+export interface Team {
+    id: TeamId;
+    name: string;
+    players: PlayerId[];
+    score: number;
+    color?: string;
+}
+export interface MatchConfig {
+    type: MatchType;
+    name: string;
+    description?: string;
+    minPlayers: number;
+    maxPlayers: number;
+    teamCount?: number;
+    playersPerTeam?: number;
+    scoreToWin?: number;
+    timeLimit?: number;
+    respawnEnabled: boolean;
+    respawnTime?: number;
+    maxDeaths?: number;
+    mapId?: string;
+    mapName?: string;
+    winReward?: {
+        type: string;
+        amount: number;
+    };
+    loseReward?: {
+        type: string;
+        amount: number;
+    };
+    isRanked: boolean;
+    minRank?: number;
+    maxRank?: number;
+}
+export interface Match {
+    id: MatchId;
+    config: MatchConfig;
+    status: MatchStatus;
+    players: Map<PlayerId, MatchPlayer>;
+    teams?: Team[];
+    createdAt: number;
+    startedAt?: number;
+    endedAt?: number;
+    currentScore: Record<string, number>;
+    timeRemaining?: number;
+    round?: number;
+    winnerId?: PlayerId | TeamId;
+    results?: Map<PlayerId, MatchResult>;
+    spectators: PlayerId[];
+}
+export interface QueueEntry {
+    playerId: PlayerId;
+    mmr: number;
+    queueType: MatchType;
+    joinedAt: number;
+    expandRange: number;
+}
+export interface MatchmakingConfig {
+    mmrRange: number;
+    mmrExpandRate: number;
+    maxWaitTime: number;
+    minMatchSize: Record<MatchType, number>;
+    maxMatchSize: Record<MatchType, number>;
+}
+export interface PvPSeason {
+    id: SeasonId;
+    name: string;
+    startDate: number;
+    endDate: number;
+    ranks: Array<{
+        tier: string;
+        division: number;
+        minPoints: number;
+        icon?: string;
+    }>;
+    seasonRewards: Array<{
+        minRank: number;
+        rewards: Array<{
+            type: string;
+            itemId: string;
+            quantity: number;
+        }>;
+    }>;
+}
+export type PvPEventType = 'queue-joined' | 'queue-left' | 'match-found' | 'match-started' | 'match-ended' | 'player-joined' | 'player-left' | 'player-killed' | 'player-respawned' | 'score-updated' | 'rank-changed' | 'season-ended';
+export interface PvPEvent {
+    type: PvPEventType;
+    timestamp: number;
+    matchId?: MatchId;
+    data?: unknown;
+}
+export type PvPEventCallback = (event: PvPEvent) => void;
+export interface PvPConfig {
+    matchmaking: MatchmakingConfig;
+    mmrK: number;
+    mmrDefault: number;
+    winStreakBonus: number;
+    maxWinStreakBonus: number;
+    afkTimeout: number;
+    storageKey: string;
+}
+export declare const DEFAULT_PVP_CONFIG: PvPConfig;
+export declare class NicePvP {
+    private config;
+    private players;
+    private matches;
+    private queue;
+    private matchConfigs;
+    private seasons;
+    private currentSeasonId;
+    private eventListeners;
+    private matchCounter;
+    constructor(config?: Partial<PvPConfig>);
+    private initializeQueues;
+    on(event: PvPEventType, callback: PvPEventCallback): () => void;
+    private emit;
+    registerPlayer(playerId: PlayerId, data?: Partial<PvPPlayer>): PvPPlayer;
+    getPlayer(playerId: PlayerId): PvPPlayer | undefined;
+    setPlayerOnline(playerId: PlayerId, online: boolean): void;
+    registerMatchConfig(config: MatchConfig): void;
+    joinQueue(playerId: PlayerId, matchType: MatchType): boolean;
+    leaveQueue(playerId: PlayerId): boolean;
+    processMatchmaking(): Match[];
+    private findMatchGroup;
+    createMatch(config: MatchConfig, playerIds: PlayerId[]): Match | null;
+    startMatch(matchId: MatchId): boolean;
+    recordKill(matchId: MatchId, killerId: PlayerId, victimId: PlayerId, damage: number, assistIds?: PlayerId[]): void;
+    private checkWinCondition;
+    endMatch(matchId: MatchId, winnerId?: PlayerId | TeamId): void;
+    private processMatchResults;
+    private updateMMR;
+    private updateRankings;
+    registerSeason(season: PvPSeason): void;
+    startSeason(seasonId: SeasonId): boolean;
+    endSeason(): PvPSeason | null;
+    getPlayerRank(playerId: PlayerId): {
+        tier: string;
+        division: number;
+    } | null;
+    spectate(matchId: MatchId, spectatorId: PlayerId): boolean;
+    stopSpectating(matchId: MatchId, spectatorId: PlayerId): void;
+    getMatch(matchId: MatchId): Match | undefined;
+    getActiveMatches(type?: MatchType): Match[];
+    getLeaderboard(limit?: number): PvPPlayer[];
+    getPlayerMatchHistory(playerId: PlayerId, limit?: number): Match[];
+    getQueueStatus(matchType: MatchType): {
+        inQueue: number;
+        estimatedWait: number;
+    };
+    private save;
+    private load;
+    reset(): void;
+    destroy(): void;
+}
+export declare function createPvPSystem(config?: Partial<PvPConfig>): NicePvP;

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

@@ -0,0 +1,160 @@
+import { EventEmitter } from 'events';
+export type QTEId = string;
+export type SequenceId = string;
+export type PromptId = string;
+export type InputType = 'button' | 'hold' | 'mash' | 'sequence' | 'analog' | 'directional' | 'rhythm';
+export type ButtonInput = 'action' | 'jump' | 'attack' | 'dodge' | 'interact' | 'primary' | 'secondary' | 'dpad_up' | 'dpad_down' | 'dpad_left' | 'dpad_right' | string;
+export type Direction = 'up' | 'down' | 'left' | 'right' | 'neutral';
+export interface QTEPrompt {
+    id: PromptId;
+    type: InputType;
+    button?: ButtonInput;
+    buttons?: ButtonInput[];
+    direction?: Direction;
+    analogThreshold?: number;
+    mashCount?: number;
+    holdDuration?: number;
+    timeWindow: number;
+    earlyWindow?: number;
+    perfectWindow?: number;
+    lateWindow?: number;
+    position?: {
+        x: number;
+        y: number;
+    };
+    visual?: QTEVisual;
+}
+export interface QTEVisual {
+    icon?: string;
+    text?: string;
+    animation?: string;
+    color?: string;
+    scale?: number;
+    showTimer?: boolean;
+}
+export interface QTESequence {
+    id: SequenceId;
+    name: string;
+    prompts: QTEPrompt[];
+    allowSkip?: boolean;
+    resetOnFail?: boolean;
+    maxFailures?: number;
+    timeBetweenPrompts?: number;
+    bonusTimePerSuccess?: number;
+    difficultyScaling?: boolean;
+}
+export interface QTEDefinition {
+    id: QTEId;
+    name: string;
+    type: 'single' | 'sequence' | 'parallel';
+    sequences?: SequenceId[];
+    prompt?: QTEPrompt;
+    globalTimeLimit?: number;
+    pauseGame?: boolean;
+    slowMotionFactor?: number;
+    onStart?: () => void;
+    onSuccess?: (result: QTEResult) => void;
+    onFailure?: (result: QTEResult) => void;
+    onComplete?: (result: QTEResult) => void;
+}
+export interface ActiveQTE {
+    id: QTEId;
+    definition: QTEDefinition;
+    state: QTEState;
+    currentSequenceIndex: number;
+    currentPromptIndex: number;
+    startTime: number;
+    timeRemaining: number;
+    successCount: number;
+    failureCount: number;
+    perfectCount: number;
+    mashProgress: number;
+    holdProgress: number;
+    analogValue: number;
+    inputBuffer: InputRecord[];
+    results: PromptResult[];
+}
+export type QTEState = 'pending' | 'active' | 'waiting_input' | 'succeeded' | 'failed' | 'completed' | 'cancelled';
+export interface InputRecord {
+    button: ButtonInput | Direction;
+    timestamp: number;
+    held: boolean;
+}
+export interface PromptResult {
+    promptId: PromptId;
+    success: boolean;
+    timing: 'early' | 'perfect' | 'late' | 'missed';
+    reactionTime: number;
+}
+export interface QTEResult {
+    qteId: QTEId;
+    success: boolean;
+    totalPrompts: number;
+    successfulPrompts: number;
+    perfectPrompts: number;
+    failedPrompts: number;
+    averageReactionTime: number;
+    totalTime: number;
+    promptResults: PromptResult[];
+}
+export type QTEEventType = 'qte-started' | 'qte-completed' | 'qte-cancelled' | 'prompt-shown' | 'prompt-success' | 'prompt-perfect' | 'prompt-failed' | 'prompt-timeout' | 'sequence-started' | 'sequence-completed' | 'mash-progress' | 'hold-progress' | 'time-warning';
+export interface QTEEvent {
+    type: QTEEventType;
+    qteId: QTEId;
+    promptId?: PromptId;
+    data?: Record<string, unknown>;
+}
+export interface QTESystemConfig {
+    defaultTimeWindow?: number;
+    perfectWindowRatio?: number;
+    inputBufferTime?: number;
+    visualFeedbackDuration?: number;
+    difficultyCurve?: number;
+    autoFailOnTimeout?: boolean;
+    allowInputQueue?: boolean;
+    hapticFeedback?: boolean;
+}
+export declare const DEFAULT_QTE_CONFIG: QTESystemConfig;
+export declare class NiceQTE extends EventEmitter {
+    private definitions;
+    private sequences;
+    private activeQTEs;
+    private currentInputs;
+    private inputBuffer;
+    private config;
+    private qteIdCounter;
+    private isPaused;
+    constructor(config?: Partial<QTESystemConfig>);
+    defineQTE(definition: QTEDefinition): void;
+    defineSequence(sequence: QTESequence): void;
+    getDefinition(id: QTEId): QTEDefinition | undefined;
+    getSequence(id: SequenceId): QTESequence | undefined;
+    startQTE(definitionId: QTEId): ActiveQTE | null;
+    startQuickQTE(prompt: QTEPrompt): ActiveQTE;
+    cancelQTE(qteId: QTEId): void;
+    private showNextPrompt;
+    private getCurrentPrompt;
+    buttonPressed(button: ButtonInput): void;
+    buttonReleased(button: ButtonInput): void;
+    directionInput(direction: Direction): void;
+    analogInput(x: number, y: number): void;
+    private checkInput;
+    private matchesSequence;
+    private promptSuccess;
+    private promptFailed;
+    private evaluateTiming;
+    private getCurrentSequence;
+    private advanceQTE;
+    private completeQTE;
+    private calculateAverageReactionTime;
+    update(deltaTime: number): void;
+    isQTEActive(): boolean;
+    getActiveQTE(qteId: QTEId): ActiveQTE | undefined;
+    getAllActiveQTEs(): ActiveQTE[];
+    isGamePaused(): boolean;
+    getSlowMotionFactor(): number;
+}
+export declare function createQTESystem(config?: Partial<QTESystemConfig>): NiceQTE;
+export declare function defineQTEPrompt(options: QTEPrompt): QTEPrompt;
+export declare function defineQTESequence(options: QTESequence): QTESequence;
+export default NiceQTE;