@nice2dev/game-engine 1.3.13 → 1.3.15

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

@@ -1,157 +0,0 @@
-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

@@ -1,199 +0,0 @@
-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

@@ -1,160 +0,0 @@
-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;