@nice2dev/game-engine 1.1.5 → 1.1.7

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

@@ -0,0 +1,502 @@
+/**
+ * NiceVoice - Voice Chat & Communication System
+ *
+ * Comprehensive voice communication system for multiplayer games
+ * with spatial audio, push-to-talk, and voice activity detection.
+ *
+ * Features:
+ * - Voice chat channels
+ * - Push-to-talk & voice activity
+ * - Spatial 3D audio
+ * - Proximity voice chat
+ * - Channel management
+ * - Mute controls
+ * - Voice processing
+ * - Echo cancellation
+ * - Noise suppression
+ * - Volume normalization
+ * - Voice indicators
+ * - Recording support
+ *
+ * @packageDocumentation
+ */
+import { EventEmitter } from 'events';
+/** Unique participant ID */
+export type ParticipantId = string;
+/** Unique channel ID */
+export type ChannelId = string;
+/** Voice activation mode */
+export type VoiceActivationMode = 'push_to_talk' | 'voice_activity' | 'always_on' | 'off';
+/** Channel type */
+export type ChannelType = 'global' | 'team' | 'party' | 'proximity' | 'private' | 'spectator';
+/** Voice quality preset */
+export type VoiceQuality = 'low' | 'medium' | 'high' | 'ultra';
+/** Connection state */
+export type VoiceConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'failed';
+/** Participant info */
+export interface VoiceParticipant {
+    id: ParticipantId;
+    name: string;
+    isSpeaking: boolean;
+    isMuted: boolean;
+    isDeafened: boolean;
+    volume: number;
+    position?: Vector3;
+    channelId?: ChannelId;
+    priority: number;
+    lastSpeakTime?: number;
+    quality?: VoiceQuality;
+}
+/** 3D Vector */
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+/** Voice channel */
+export interface VoiceChannel {
+    id: ChannelId;
+    name: string;
+    type: ChannelType;
+    participants: ParticipantId[];
+    maxParticipants?: number;
+    password?: string;
+    isLocked: boolean;
+    isMuted: boolean;
+    volume: number;
+    spatialEnabled: boolean;
+    proximityRange?: number;
+    createdAt: number;
+    metadata?: Record<string, unknown>;
+}
+/** Audio settings */
+export interface AudioSettings {
+    inputDevice?: string;
+    outputDevice?: string;
+    inputVolume: number;
+    outputVolume: number;
+    echoCancellation: boolean;
+    noiseSuppression: boolean;
+    autoGainControl: boolean;
+    sampleRate: number;
+    channels: number;
+    bitrate: number;
+}
+/** Voice activity settings */
+export interface VoiceActivitySettings {
+    enabled: boolean;
+    threshold: number;
+    holdTime: number;
+    releaseTime: number;
+    sensitivity: number;
+}
+/** Push-to-talk settings */
+export interface PushToTalkSettings {
+    key: string;
+    toggle: boolean;
+    delay: number;
+    sound: boolean;
+}
+/** Spatial audio settings */
+export interface SpatialAudioSettings {
+    enabled: boolean;
+    maxDistance: number;
+    refDistance: number;
+    rolloffFactor: number;
+    coneInnerAngle: number;
+    coneOuterAngle: number;
+    coneOuterGain: number;
+    distanceModel: 'linear' | 'inverse' | 'exponential';
+}
+/** Voice effect */
+export interface VoiceEffect {
+    id: string;
+    name: string;
+    type: 'pitch' | 'reverb' | 'echo' | 'distortion' | 'robot' | 'custom';
+    enabled: boolean;
+    parameters: Record<string, number>;
+}
+/** Voice indicator */
+export interface VoiceIndicator {
+    participantId: ParticipantId;
+    level: number;
+    isSpeaking: boolean;
+    direction?: number;
+    distance?: number;
+}
+/** Recording info */
+export interface VoiceRecording {
+    id: string;
+    channelId?: ChannelId;
+    participants: ParticipantId[];
+    startTime: number;
+    endTime?: number;
+    duration: number;
+    size: number;
+    format: string;
+    blob?: Blob;
+}
+/** Device info */
+export interface AudioDevice {
+    id: string;
+    label: string;
+    kind: 'audioinput' | 'audiooutput';
+    isDefault: boolean;
+}
+/** Voice statistics */
+export interface VoiceStatistics {
+    packetsLost: number;
+    packetsSent: number;
+    packetsReceived: number;
+    jitter: number;
+    latency: number;
+    bitrate: number;
+    codec: string;
+    speakingTime: number;
+    mutedTime: number;
+}
+/** Voice event types */
+export type VoiceEventType = 'connected' | 'disconnected' | 'connection_failed' | 'channel_joined' | 'channel_left' | 'channel_created' | 'channel_deleted' | 'participant_joined' | 'participant_left' | 'participant_speaking' | 'participant_stopped_speaking' | 'participant_muted' | 'participant_unmuted' | 'local_muted' | 'local_unmuted' | 'local_deafened' | 'local_undeafened' | 'ptt_activated' | 'ptt_deactivated' | 'device_changed' | 'recording_started' | 'recording_stopped' | 'voice_level';
+/** Voice event data */
+export interface VoiceEvent {
+    type: VoiceEventType;
+    timestamp: number;
+    participantId?: ParticipantId;
+    channelId?: ChannelId;
+    data?: unknown;
+}
+/** Voice event callback */
+export type VoiceEventCallback = (event: VoiceEvent) => void;
+/** Voice system configuration */
+export interface VoiceConfig {
+    activationMode: VoiceActivationMode;
+    quality: VoiceQuality;
+    audio: AudioSettings;
+    voiceActivity: VoiceActivitySettings;
+    pushToTalk: PushToTalkSettings;
+    spatial: SpatialAudioSettings;
+    autoJoinTeamChannel: boolean;
+    showSpeakingIndicators: boolean;
+    playJoinLeaveSound: boolean;
+    allowRecording: boolean;
+    maxRecordingDuration: number;
+    prioritySpeaker: boolean;
+    duckingEnabled: boolean;
+    duckingLevel: number;
+}
+/** Default audio settings */
+export declare const DEFAULT_AUDIO_SETTINGS: AudioSettings;
+/** Default voice activity settings */
+export declare const DEFAULT_VOICE_ACTIVITY: VoiceActivitySettings;
+/** Default PTT settings */
+export declare const DEFAULT_PTT_SETTINGS: PushToTalkSettings;
+/** Default spatial settings */
+export declare const DEFAULT_SPATIAL_SETTINGS: SpatialAudioSettings;
+/** Default configuration */
+export declare const DEFAULT_VOICE_CONFIG: VoiceConfig;
+/**
+ * Voice chat and communication system
+ */
+export declare class NiceVoice extends EventEmitter {
+    private config;
+    private channels;
+    private participants;
+    private devices;
+    private effects;
+    private recordings;
+    private localParticipantId?;
+    private currentChannelId?;
+    private connectionState;
+    private audioContext?;
+    private localStream?;
+    private analyser?;
+    private gainNode?;
+    private mediaRecorder?;
+    private isPttActive;
+    private isMuted;
+    private isDeafened;
+    private isRecording;
+    private voiceActivityTimer?;
+    private levelUpdateInterval?;
+    private remoteParticipants;
+    private statistics;
+    private listenerPosition;
+    private listenerOrientation;
+    constructor(config?: Partial<VoiceConfig>);
+    /**
+     * Emit voice event
+     */
+    private emitEvent;
+    /**
+     * Setup keyboard listeners
+     */
+    private setupKeyboardListeners;
+    /**
+     * Initialize default effects
+     */
+    private initializeDefaultEffects;
+    /**
+     * Load settings
+     */
+    private loadSettings;
+    /**
+     * Save settings
+     */
+    private saveSettings;
+    /**
+     * Initialize voice system
+     */
+    initialize(): Promise<boolean>;
+    /**
+     * Connect to voice server
+     */
+    connect(participantId: ParticipantId, participantName: string): Promise<boolean>;
+    /**
+     * Disconnect from voice
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Create channel
+     */
+    createChannel(name: string, type: ChannelType, options?: Partial<VoiceChannel>): VoiceChannel;
+    /**
+     * Delete channel
+     */
+    deleteChannel(channelId: ChannelId): boolean;
+    /**
+     * Join channel
+     */
+    joinChannel(channelId: ChannelId, password?: string): Promise<boolean>;
+    /**
+     * Leave channel
+     */
+    leaveChannel(): Promise<void>;
+    /**
+     * Remove participant from channel
+     */
+    private removeFromChannel;
+    /**
+     * Get channel
+     */
+    getChannel(channelId: ChannelId): VoiceChannel | undefined;
+    /**
+     * Get all channels
+     */
+    getAllChannels(type?: ChannelType): VoiceChannel[];
+    /**
+     * Get current channel
+     */
+    getCurrentChannel(): VoiceChannel | undefined;
+    /**
+     * Add remote participant
+     */
+    addParticipant(participant: VoiceParticipant): void;
+    /**
+     * Remove participant
+     */
+    removeParticipant(participantId: ParticipantId): void;
+    /**
+     * Get participant
+     */
+    getParticipant(participantId: ParticipantId): VoiceParticipant | undefined;
+    /**
+     * Get local participant
+     */
+    getLocalParticipant(): VoiceParticipant | undefined;
+    /**
+     * Get all participants
+     */
+    getAllParticipants(channelId?: ChannelId): VoiceParticipant[];
+    /**
+     * Get speaking participants
+     */
+    getSpeakingParticipants(): VoiceParticipant[];
+    /**
+     * Set local muted
+     */
+    setLocalMuted(muted: boolean): void;
+    /**
+     * Toggle mute
+     */
+    toggleMute(): void;
+    /**
+     * Is muted
+     */
+    isMutedStatus(): boolean;
+    /**
+     * Set local deafened
+     */
+    setLocalDeafened(deafened: boolean): void;
+    /**
+     * Toggle deafen
+     */
+    toggleDeafen(): void;
+    /**
+     * Mute participant
+     */
+    muteParticipant(participantId: ParticipantId, muted: boolean): void;
+    /**
+     * Set participant volume
+     */
+    setParticipantVolume(participantId: ParticipantId, volume: number): void;
+    /**
+     * Activate PTT
+     */
+    activatePtt(): void;
+    /**
+     * Deactivate PTT
+     */
+    deactivatePtt(): void;
+    /**
+     * Toggle PTT
+     */
+    togglePtt(): void;
+    /**
+     * Start voice activity detection
+     */
+    private startVoiceActivityDetection;
+    /**
+     * Stop voice activity detection
+     */
+    private stopVoiceActivityDetection;
+    /**
+     * Get input level
+     */
+    getInputLevel(): number;
+    /**
+     * Update speaking state
+     */
+    private updateSpeakingState;
+    /**
+     * Update listener position
+     */
+    updateListenerPosition(position: Vector3, orientation?: {
+        forward: Vector3;
+        up: Vector3;
+    }): void;
+    /**
+     * Update participant position
+     */
+    updateParticipantPosition(participantId: ParticipantId, position: Vector3): void;
+    /**
+     * Update proximity voice
+     */
+    private updateProximityVoice;
+    /**
+     * Calculate distance
+     */
+    private calculateDistance;
+    /**
+     * Get voice indicators
+     */
+    getVoiceIndicators(): VoiceIndicator[];
+    /**
+     * Enable effect
+     */
+    enableEffect(effectId: string): void;
+    /**
+     * Disable effect
+     */
+    disableEffect(effectId: string): void;
+    /**
+     * Set effect parameter
+     */
+    setEffectParameter(effectId: string, parameter: string, value: number): void;
+    /**
+     * Get effects
+     */
+    getEffects(): VoiceEffect[];
+    /**
+     * Apply effects (placeholder for actual implementation)
+     */
+    private applyEffects;
+    /**
+     * Start recording
+     */
+    startRecording(channelId?: ChannelId): Promise<string | undefined>;
+    /**
+     * Stop recording
+     */
+    stopRecording(): void;
+    /**
+     * Get recording
+     */
+    getRecording(recordingId: string): VoiceRecording | undefined;
+    /**
+     * Get all recordings
+     */
+    getAllRecordings(): VoiceRecording[];
+    /**
+     * Delete recording
+     */
+    deleteRecording(recordingId: string): boolean;
+    /**
+     * Refresh devices
+     */
+    refreshDevices(): Promise<AudioDevice[]>;
+    /**
+     * Get devices
+     */
+    getDevices(kind?: 'audioinput' | 'audiooutput'): AudioDevice[];
+    /**
+     * Set input device
+     */
+    setInputDevice(deviceId: string): Promise<boolean>;
+    /**
+     * Set output device (if supported)
+     */
+    setOutputDevice(deviceId: string): Promise<boolean>;
+    /**
+     * Set activation mode
+     */
+    setActivationMode(mode: VoiceActivationMode): void;
+    /**
+     * Set input volume
+     */
+    setInputVolume(volume: number): void;
+    /**
+     * Set output volume
+     */
+    setOutputVolume(volume: number): void;
+    /**
+     * Get config
+     */
+    getConfig(): VoiceConfig;
+    /**
+     * Update config
+     */
+    updateConfig(config: Partial<VoiceConfig>): void;
+    /**
+     * Get statistics
+     */
+    getStatistics(): VoiceStatistics;
+    /**
+     * Get connection state
+     */
+    getConnectionState(): VoiceConnectionState;
+    /**
+     * Play sound
+     */
+    private playSound;
+    /**
+     * Delay helper
+     */
+    private delay;
+    /**
+     * Load from storage
+     */
+    private loadFromStorage;
+    /**
+     * Save to storage
+     */
+    private saveToStorage;
+    /**
+     * Destroy voice system
+     */
+    destroy(): Promise<void>;
+}
+/**
+ * Create voice system instance
+ */
+export declare function createVoiceSystem(config?: Partial<VoiceConfig>): NiceVoice;
+export default NiceVoice;

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

@@ -0,0 +1,162 @@
+import { EventEmitter } from 'events';
+export type WaterBodyId = string;
+export interface Vector2 {
+    x: number;
+    y: number;
+}
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export type WaterBodyType = 'lake' | 'river' | 'ocean' | 'pool' | 'waterfall';
+export interface WaterBodyConfig {
+    type: WaterBodyType;
+    bounds: {
+        minX: number;
+        minZ: number;
+        maxX: number;
+        maxZ: number;
+    };
+    surfaceLevel: number;
+    depth: number;
+    color: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    clarity: number;
+    reflectivity: number;
+    refractionIndex: number;
+    waveEnabled?: boolean;
+    waveAmplitude?: number;
+    waveFrequency?: number;
+    waveSpeed?: number;
+    waveDirections?: Vector2[];
+    flowDirection?: Vector2;
+    flowSpeed?: number;
+    foamEnabled?: boolean;
+    foamThreshold?: number;
+    foamIntensity?: number;
+}
+export interface WaterBody {
+    id: WaterBodyId;
+    config: WaterBodyConfig;
+    time: number;
+    active: boolean;
+    submergedEntities: Set<string>;
+}
+export interface WaveLayer {
+    direction: Vector2;
+    amplitude: number;
+    wavelength: number;
+    speed: number;
+    steepness: number;
+}
+export interface BuoyancyConfig {
+    mass: number;
+    volume: number;
+    drag: number;
+    angularDrag: number;
+    buoyancyPoints?: Vector3[];
+}
+export interface BuoyancyResult {
+    force: Vector3;
+    torque: Vector3;
+    submergedPercentage: number;
+}
+export type WaterEventType = 'entity-entered' | 'entity-exited' | 'splash' | 'ripple' | 'water-body-created' | 'water-body-destroyed';
+export interface WaterEvent {
+    type: WaterEventType;
+    waterBodyId: WaterBodyId;
+    entityId?: string;
+    position?: Vector3;
+    velocity?: Vector3;
+    intensity?: number;
+}
+export interface WaterSystemConfig {
+    gravity?: number;
+    waterDensity?: number;
+    defaultWaveCount?: number;
+    updateRate?: number;
+    maxRipples?: number;
+    maxSplashes?: number;
+}
+export declare const DEFAULT_WATER_CONFIG: WaterSystemConfig;
+export interface Ripple {
+    id: string;
+    waterBodyId: WaterBodyId;
+    position: Vector2;
+    startTime: number;
+    duration: number;
+    radius: number;
+    amplitude: number;
+    currentRadius: number;
+}
+export interface Splash {
+    id: string;
+    waterBodyId: WaterBodyId;
+    position: Vector3;
+    startTime: number;
+    duration: number;
+    intensity: number;
+    particleCount: number;
+    active: boolean;
+}
+export declare class NiceWater extends EventEmitter {
+    private waterBodies;
+    private waveLayers;
+    private ripples;
+    private splashes;
+    private nextId;
+    private time;
+    private config;
+    constructor(config?: Partial<WaterSystemConfig>);
+    create(bodyConfig: WaterBodyConfig): WaterBodyId;
+    private initializeWaves;
+    private generateWaveDirections;
+    destroy(waterBodyId: WaterBodyId): boolean;
+    get(waterBodyId: WaterBodyId): WaterBody | undefined;
+    update(deltaTime: number): void;
+    private updateRipples;
+    private updateSplashes;
+    getSurfaceHeight(waterBodyId: WaterBodyId, x: number, z: number): number;
+    private calculateWaveHeight;
+    private calculateRippleHeight;
+    getSurfaceNormal(waterBodyId: WaterBodyId, x: number, z: number): Vector3;
+    getFlowVelocity(waterBodyId: WaterBodyId, _x: number, _z: number): Vector2;
+    getDepth(waterBodyId: WaterBodyId, x: number, y: number, z: number): number;
+    isSubmerged(waterBodyId: WaterBodyId, position: Vector3): boolean;
+    isInBounds(waterBodyId: WaterBodyId, x: number, z: number): boolean;
+    findWaterBodyAt(x: number, y: number, z: number): WaterBodyId | null;
+    calculateBuoyancy(waterBodyId: WaterBodyId, position: Vector3, buoyancyConfig: BuoyancyConfig): BuoyancyResult;
+    entityEnter(waterBodyId: WaterBodyId, entityId: string, position: Vector3, velocity?: Vector3): void;
+    entityExit(waterBodyId: WaterBodyId, entityId: string): void;
+    getSubmergedEntities(waterBodyId: WaterBodyId): string[];
+    createRipple(waterBodyId: WaterBodyId, x: number, z: number, options?: {
+        radius?: number;
+        amplitude?: number;
+        duration?: number;
+    }): string | null;
+    createSplash(waterBodyId: WaterBodyId, position: Vector3, intensity?: number): string | null;
+    getActiveRipples(waterBodyId?: WaterBodyId): Ripple[];
+    getActiveSplashes(waterBodyId?: WaterBodyId): Splash[];
+    getUnderwaterVisibility(waterBodyId: WaterBodyId, depth: number): number;
+    getUnderwaterColor(waterBodyId: WaterBodyId, depth: number): {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    getCausticsIntensity(waterBodyId: WaterBodyId, x: number, y: number, z: number): number;
+}
+export declare function createWaterSystem(config?: Partial<WaterSystemConfig>): NiceWater;
+export declare function createWaterBody(type: WaterBodyType, bounds: {
+    minX: number;
+    minZ: number;
+    maxX: number;
+    maxZ: number;
+}, options?: Partial<WaterBodyConfig>): WaterBodyConfig;
+export declare function createBuoyancyConfig(mass: number, volume: number, options?: Partial<BuoyancyConfig>): BuoyancyConfig;
+export default NiceWater;