blacktrigram 0.7.2

package/lib/audio/AudioManager.d.ts

@@ -0,0 +1,162 @@
+import { LoadOptions } from "./AudioAssetLoader";
+import { AudioFPSImpact, AudioMemoryStats, AudioPerformanceStats, MemoryWarning } from "./AudioMonitor";
+import { PoolStatistics } from "./AudioPool";
+import { AudioAsset, AudioConfig, IAudioManager, MusicTrackId, SoundEffectId } from "./types";
+export declare class AudioManager implements IAudioManager {
+    private _masterVolume;
+    private _musicVolume;
+    private _sfxVolume;
+    private _muted;
+    private _currentMusicTrack;
+    private _fallbackMode;
+    private currentMusic;
+    private soundCache;
+    private _isInitialized;
+    private loadingMusic;
+    private assetLoader;
+    private audioPool;
+    private monitor;
+    private audioCache;
+    private frequentSounds;
+    constructor(config?: Partial<AudioConfig>);
+    /**
+     * Helper method to release pooled audio back to the pool after playback
+     * @param id - Asset ID
+     * @param audio - Audio element to release
+     */
+    private releasePooledAudio;
+    get isInitialized(): boolean;
+    get fallbackMode(): boolean;
+    get currentMusicTrack(): string | null;
+    get masterVolume(): number;
+    get sfxVolume(): number;
+    get musicVolume(): number;
+    get muted(): boolean;
+    initialize(config?: AudioConfig): Promise<void>;
+    loadAsset(asset: AudioAsset, options?: LoadOptions): Promise<void>;
+    /**
+     * Estimate audio asset size in bytes
+     * 바이트 단위의 오디오 자산 크기 추정
+     *
+     * @returns Estimated size in bytes
+     */
+    private estimateAudioSize;
+    playSoundEffect(id: SoundEffectId): Promise<void>;
+    playSFX(id: SoundEffectId, volume?: number): Promise<void>;
+    playMusic(id: MusicTrackId, volume?: number): Promise<void>;
+    /**
+     * Wait for a music asset to finish loading
+     * 음악 자산 로드가 완료될 때까지 대기
+     * @param id - Music track ID
+     * @param maxWaitMs - Maximum time to wait in milliseconds
+     */
+    private waitForMusicLoad;
+    stopMusic(): void;
+    stopAll(): void;
+    setVolume(type: "master" | "sfx" | "music" | "voice", volume: number): void;
+    mute(): void;
+    unmute(): void;
+    fadeOut(duration?: number): Promise<void>;
+    fadeIn(trackId: MusicTrackId, duration?: number): Promise<void>;
+    crossfade(fromTrackId: MusicTrackId, toTrackId: MusicTrackId, duration?: number): Promise<void>;
+    getLoadedAssets(): ReadonlyMap<string, HTMLAudioElement>;
+    playVoice(id: string): Promise<void>;
+    playKoreanTechniqueSound(techniqueId: string, archetype: string): Promise<void>;
+    playTrigramStanceSound(stance: string): Promise<void>;
+    playVitalPointHitSound(severity: string): Promise<void>;
+    playDojiangAmbience(): Promise<void>;
+    getMasterVolume(): number;
+    getMusicVolume(): number;
+    getSfxVolume(): number;
+    get initialized(): boolean;
+    /**
+     * Batch load multiple assets with progress tracking
+     * @param assets - Array of audio assets to load
+     * @param options - Optional load configuration (timeout, retries, etc.)
+     * @param onProgress - Optional callback for progress updates with loaded and total counts
+     * @returns Promise that resolves when all assets are processed
+     */
+    batchLoadAssets(assets: readonly AudioAsset[], options?: LoadOptions, onProgress?: (loaded: number, total: number) => void): Promise<void>;
+    /**
+     * Unload an asset to free memory
+     * @param assetId - ID of the asset to unload
+     * @returns true if asset was unloaded, false if asset was not found
+     */
+    unloadAsset(assetId: string): boolean;
+    /**
+     * Get cache statistics including LRU cache metrics
+     * LRU 캐시 메트릭을 포함한 캐시 통계 가져오기
+     *
+     * @returns Cache statistics
+     */
+    getCacheStats(): {
+        readonly lruCache: {
+            readonly totalSize: number;
+            readonly assetCount: number;
+            readonly criticalCount: number;
+            readonly utilizationPercent: number;
+            readonly evictionCount: number;
+            readonly hitCount: number;
+            readonly missCount: number;
+            readonly hitRate: number;
+        };
+        readonly soundCache: number;
+        readonly poolStats: Map<string, PoolStatistics>;
+    };
+    /**
+     * Get memory statistics including total loaded MB, asset count, and warnings
+     * @returns Memory statistics object
+     */
+    getMemoryStats(): AudioMemoryStats;
+    /**
+     * Get performance statistics including load times and playback latency
+     * @returns Performance statistics object
+     */
+    getPerformanceStats(): AudioPerformanceStats;
+    /**
+     * Get FPS impact analysis showing baseline vs current FPS and detected drops
+     * @returns FPS impact analysis object
+     */
+    getFPSImpact(): AudioFPSImpact;
+    /**
+     * Update FPS measurement for monitoring
+     * @param fps - Current frames per second measurement
+     */
+    updateFPS(fps: number): void;
+    /**
+     * Get comprehensive monitoring report including memory, performance, FPS, and warnings
+     * @returns Comprehensive monitoring report object
+     */
+    getMonitoringReport(): {
+        readonly memory: AudioMemoryStats;
+        readonly performance: AudioPerformanceStats;
+        readonly fps: AudioFPSImpact;
+        readonly warnings: readonly MemoryWarning[];
+    };
+    /**
+     * Get all memory warnings
+     * @returns Array of memory warnings
+     */
+    getMemoryWarnings(): readonly MemoryWarning[];
+    /**
+     * Clear memory warnings
+     */
+    clearMemoryWarnings(): void;
+    /**
+     * Get pool statistics for a specific asset or all pools
+     * @param assetId - Optional asset ID to get specific pool stats
+     * @returns Pool statistics for the specified asset or all pools
+     */
+    getPoolStatistics(assetId?: string): PoolStatistics | Map<string, PoolStatistics> | undefined;
+    /**
+     * Get loader statistics including cached assets and loading state
+     * @returns Loader statistics object
+     */
+    getLoaderStatistics(): {
+        readonly cached: number;
+        readonly loading: number;
+        readonly totalAttempts: number;
+    };
+}
+export default AudioManager;
+//# sourceMappingURL=AudioManager.d.ts.map

package/lib/audio/AudioManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioManager.d.ts","sourceRoot":"","sources":["../../src/audio/AudioManager.ts"],"names":[],"mappings":"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"}

package/lib/audio/AudioManager.js

@@ -0,0 +1,508 @@
+import { AudioAssetLoader } from "./AudioAssetLoader.js";
+import { AudioCache } from "./AudioCache.js";
+import { AudioMonitor } from "./AudioMonitor.js";
+import { AudioElementPool } from "./AudioPool.js";
+//#region src/audio/AudioManager.ts
+var ESTIMATED_ASSET_SIZE_MB = .5;
+/**
+* Critical assets that should never be evicted from cache
+* 캐시에서 절대 제거되지 않아야 하는 중요한 자산
+*/
+var CRITICAL_AUDIO_ASSETS = [
+	"menu_hover",
+	"menu_select",
+	"menu_click",
+	"menu_navigate",
+	"menu_back",
+	"hit_impact",
+	"hit_light",
+	"hit_medium",
+	"hit_heavy",
+	"guard_block",
+	"attack_whoosh",
+	"attack_light",
+	"stance_change"
+];
+var AudioManager = class {
+	_masterVolume = 1;
+	_musicVolume = .7;
+	_sfxVolume = .8;
+	_muted = false;
+	_currentMusicTrack = null;
+	_fallbackMode = false;
+	currentMusic = null;
+	soundCache = /* @__PURE__ */ new Map();
+	_isInitialized = false;
+	loadingMusic = /* @__PURE__ */ new Set();
+	assetLoader;
+	audioPool;
+	monitor;
+	audioCache;
+	frequentSounds = new Set([
+		"hit_light",
+		"attack_light",
+		"stance_change"
+	]);
+	constructor(config) {
+		if (config) {
+			this._masterVolume = config.masterVolume ?? 1;
+			this._musicVolume = config.musicVolume ?? .7;
+			this._sfxVolume = config.sfxVolume ?? .8;
+		}
+		this.assetLoader = new AudioAssetLoader();
+		this.audioPool = new AudioElementPool();
+		this.monitor = new AudioMonitor();
+		this.audioCache = new AudioCache({
+			maxSizeBytes: 30 * 1024 * 1024,
+			criticalAssets: [...CRITICAL_AUDIO_ASSETS],
+			debug: typeof process !== "undefined" && process.env.NODE_ENV === "development"
+		});
+	}
+	/**
+	* Helper method to release pooled audio back to the pool after playback
+	* @param id - Asset ID
+	* @param audio - Audio element to release
+	*/
+	releasePooledAudio(id, audio) {
+		if (!audio.paused) audio.addEventListener("ended", () => {
+			this.audioPool.release(id, audio);
+		}, { once: true });
+		else this.audioPool.release(id, audio);
+	}
+	get isInitialized() {
+		return this._isInitialized;
+	}
+	get fallbackMode() {
+		return this._fallbackMode;
+	}
+	get currentMusicTrack() {
+		return this._currentMusicTrack;
+	}
+	get masterVolume() {
+		return this._masterVolume;
+	}
+	get sfxVolume() {
+		return this._sfxVolume;
+	}
+	get musicVolume() {
+		return this._musicVolume;
+	}
+	get muted() {
+		return this._muted;
+	}
+	async initialize(config) {
+		try {
+			new (globalThis.AudioContext || globalThis.webkitAudioContext)();
+			this._isInitialized = true;
+			this._fallbackMode = false;
+			if (config) {
+				this._masterVolume = config.masterVolume ?? this._masterVolume;
+				this._musicVolume = config.musicVolume ?? this._musicVolume;
+				this._sfxVolume = config.sfxVolume ?? this._sfxVolume;
+			}
+			if (config?.maxSimultaneousSounds) {
+				const estimatedMemoryMB = config.maxSimultaneousSounds * ESTIMATED_ASSET_SIZE_MB;
+				this.monitor.setMemoryThreshold(estimatedMemoryMB);
+			}
+		} catch (error) {
+			console.warn("AudioContext initialization failed, using fallback mode:", error);
+			this._isInitialized = true;
+			this._fallbackMode = true;
+		}
+	}
+	async loadAsset(asset, options) {
+		const startTime = performance.now();
+		try {
+			if (this.audioCache.get(asset.id)) {
+				if (this.soundCache.get(asset.id)) return;
+			}
+			const isTest = typeof process !== "undefined" && process.env.NODE_ENV === "test";
+			const loadOptions = {
+				timeout: isTest ? 100 : 1e4,
+				maxRetries: isTest ? 1 : 3,
+				retryDelay: isTest ? 10 : 1e3,
+				...options
+			};
+			const result = await this.assetLoader.loadAsset(asset, loadOptions);
+			if (result.success && result.audio) {
+				result.audio.volume = asset.volume ?? 1;
+				this.soundCache.set(asset.id, result.audio);
+				const estimatedSize = this.estimateAudioSize(asset);
+				this.audioCache.set(asset.id, asset, estimatedSize);
+				const loadTime = performance.now() - startTime;
+				this.monitor.recordLoad(asset.id, loadTime, estimatedSize / (1024 * 1024));
+				if (this.frequentSounds.has(asset.id)) this.audioPool.createPool(asset.id, asset.url, {
+					initialSize: 3,
+					maxSize: 10,
+					autoExpand: true
+				});
+			} else {
+				const error = result.error ?? /* @__PURE__ */ new Error("Unknown load error");
+				this.monitor.recordLoadFailure(asset.id, error);
+				if (result.audio) {
+					this.soundCache.set(asset.id, result.audio);
+					const estimatedSize = this.estimateAudioSize(asset);
+					this.audioCache.set(asset.id, asset, estimatedSize);
+				}
+			}
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			console.warn(`Failed to load audio asset ${asset.id}:`, err);
+			this.monitor.recordLoadFailure(asset.id, err);
+		}
+	}
+	/**
+	* Estimate audio asset size in bytes
+	* 바이트 단위의 오디오 자산 크기 추정
+	*
+	* @returns Estimated size in bytes
+	*/
+	estimateAudioSize(_asset) {
+		return ESTIMATED_ASSET_SIZE_MB * 1024 * 1024;
+	}
+	async playSoundEffect(id) {
+		if (this._muted) return;
+		const playbackStart = performance.now();
+		try {
+			this.audioCache.get(id);
+			if (this.frequentSounds.has(id) && this.audioPool.hasPool(id)) {
+				const audio = this.audioPool.acquire(id);
+				if (audio) {
+					audio.volume = this._sfxVolume * this._masterVolume;
+					await audio.play();
+					this.releasePooledAudio(id, audio);
+					const latency = performance.now() - playbackStart;
+					this.monitor.recordPlaybackLatency(latency);
+					return;
+				}
+			}
+			const audio = this.soundCache.get(id);
+			if (audio) {
+				audio.currentTime = 0;
+				audio.volume = this._sfxVolume * this._masterVolume;
+				await audio.play();
+				const latency = performance.now() - playbackStart;
+				this.monitor.recordPlaybackLatency(latency);
+			}
+		} catch (error) {
+			console.warn(`Failed to play sound effect ${id}:`, error);
+		}
+	}
+	async playSFX(id, volume) {
+		if (this._muted) return;
+		const playbackStart = performance.now();
+		try {
+			this.audioCache.get(id);
+			if (this.frequentSounds.has(id) && this.audioPool.hasPool(id)) {
+				const audio = this.audioPool.acquire(id);
+				if (audio) {
+					audio.volume = (volume ?? this._sfxVolume) * this._masterVolume;
+					await audio.play();
+					this.releasePooledAudio(id, audio);
+					const latency = performance.now() - playbackStart;
+					this.monitor.recordPlaybackLatency(latency);
+					return;
+				}
+			}
+			const audio = this.soundCache.get(id);
+			if (audio) {
+				audio.currentTime = 0;
+				audio.volume = (volume ?? this._sfxVolume) * this._masterVolume;
+				await audio.play();
+				const latency = performance.now() - playbackStart;
+				this.monitor.recordPlaybackLatency(latency);
+			}
+		} catch (error) {
+			console.warn(`Failed to play sound effect ${id}:`, error);
+		}
+	}
+	async playMusic(id, volume) {
+		if (this._muted) return;
+		this.stopMusic();
+		this.audioCache.get(id);
+		let audio = this.soundCache.get(id);
+		if (!audio) if (this.loadingMusic.has(id)) {
+			await this.waitForMusicLoad(id);
+			audio = this.soundCache.get(id);
+		} else {
+			this.loadingMusic.add(id);
+			try {
+				const { audioAssetRegistry } = await import("./AudioAssetRegistry.js");
+				const musicAsset = audioAssetRegistry.getMusic(id);
+				if (musicAsset) try {
+					await this.loadAsset(musicAsset);
+					audio = this.soundCache.get(id);
+				} catch (error) {
+					console.warn(`Failed to load music asset ${id} on-demand:`, error);
+					return;
+				}
+				else {
+					console.warn(`Music asset not found in registry: ${id}`);
+					return;
+				}
+			} finally {
+				this.loadingMusic.delete(id);
+			}
+		}
+		if (audio) try {
+			audio.currentTime = 0;
+			audio.volume = (volume ?? this._musicVolume) * this._masterVolume;
+			audio.loop = true;
+			this.currentMusic = audio;
+			this._currentMusicTrack = id;
+			await audio.play();
+		} catch (error) {
+			console.warn(`Failed to play music ${id}:`, error);
+		}
+	}
+	/**
+	* Wait for a music asset to finish loading
+	* 음악 자산 로드가 완료될 때까지 대기
+	* @param id - Music track ID
+	* @param maxWaitMs - Maximum time to wait in milliseconds
+	*/
+	async waitForMusicLoad(id, maxWaitMs = 5e3) {
+		const startTime = Date.now();
+		const checkInterval = 100;
+		while (this.loadingMusic.has(id)) {
+			if (Date.now() - startTime > maxWaitMs) {
+				console.warn(`[AudioManager] Timeout waiting for music "${id}" to load`);
+				return;
+			}
+			await new Promise((resolve) => setTimeout(resolve, checkInterval));
+		}
+	}
+	stopMusic() {
+		if (this.currentMusic) {
+			this.currentMusic.pause();
+			this.currentMusic.currentTime = 0;
+			this.currentMusic = null;
+			this._currentMusicTrack = null;
+		}
+	}
+	stopAll() {
+		this.stopMusic();
+		this.soundCache.forEach((audio) => {
+			if (!audio.paused) {
+				audio.pause();
+				audio.currentTime = 0;
+			}
+		});
+	}
+	setVolume(type, volume) {
+		const clampedVolume = Math.max(0, Math.min(1, volume));
+		switch (type) {
+			case "master":
+				this._masterVolume = clampedVolume;
+				break;
+			case "sfx":
+				this._sfxVolume = clampedVolume;
+				break;
+			case "music":
+				this._musicVolume = clampedVolume;
+				if (this.currentMusic) this.currentMusic.volume = this._musicVolume * this._masterVolume;
+				break;
+			case "voice": break;
+		}
+	}
+	mute() {
+		this._muted = true;
+		if (this.currentMusic) this.currentMusic.volume = 0;
+	}
+	unmute() {
+		this._muted = false;
+		if (this.currentMusic) this.currentMusic.volume = this._musicVolume * this._masterVolume;
+	}
+	async fadeOut(duration = 1e3) {
+		if (!this.currentMusic) return;
+		const musicElement = this.currentMusic;
+		return new Promise((resolve) => {
+			const fadeStep = musicElement.volume / (duration / 50);
+			const fadeInterval = setInterval(() => {
+				if (this.currentMusic && this.currentMusic.volume > 0) this.currentMusic.volume = Math.max(0, this.currentMusic.volume - fadeStep);
+				else {
+					clearInterval(fadeInterval);
+					this.stopMusic();
+					resolve();
+				}
+			}, 50);
+		});
+	}
+	async fadeIn(trackId, duration = 1e3) {
+		await this.playMusic(trackId, 0);
+		if (!this.currentMusic) return;
+		return new Promise((resolve) => {
+			const targetVolume = this._musicVolume * this._masterVolume;
+			const fadeStep = targetVolume / (duration / 50);
+			const fadeInterval = setInterval(() => {
+				if (this.currentMusic && this.currentMusic.volume < targetVolume) this.currentMusic.volume = Math.min(targetVolume, this.currentMusic.volume + fadeStep);
+				else {
+					clearInterval(fadeInterval);
+					resolve();
+				}
+			}, 50);
+		});
+	}
+	async crossfade(fromTrackId, toTrackId, duration = 1e3) {
+		await this.fadeOut(duration);
+		await this.fadeIn(toTrackId, duration);
+		console.log(`Crossfaded from ${fromTrackId} to ${toTrackId}`);
+	}
+	getLoadedAssets() {
+		return new Map(this.soundCache);
+	}
+	async playVoice(id) {
+		return this.playSoundEffect(id);
+	}
+	async playKoreanTechniqueSound(techniqueId, archetype) {
+		const soundId = `${archetype}_${techniqueId}`;
+		return this.playSoundEffect(soundId);
+	}
+	async playTrigramStanceSound(stance) {
+		const soundId = `stance_${stance}`;
+		return this.playSoundEffect(soundId);
+	}
+	async playVitalPointHitSound(severity) {
+		const soundId = `vital_point_${severity}`;
+		return this.playSoundEffect(soundId);
+	}
+	async playDojiangAmbience() {
+		return this.playMusic("dojang_ambience");
+	}
+	getMasterVolume() {
+		return this._masterVolume;
+	}
+	getMusicVolume() {
+		return this._musicVolume;
+	}
+	getSfxVolume() {
+		return this._sfxVolume;
+	}
+	get initialized() {
+		return this._isInitialized;
+	}
+	/**
+	* Batch load multiple assets with progress tracking
+	* @param assets - Array of audio assets to load
+	* @param options - Optional load configuration (timeout, retries, etc.)
+	* @param onProgress - Optional callback for progress updates with loaded and total counts
+	* @returns Promise that resolves when all assets are processed
+	*/
+	async batchLoadAssets(assets, options, onProgress) {
+		const results = await this.assetLoader.batchLoad(assets, options, (progress) => {
+			onProgress?.(progress.loaded, progress.total);
+		});
+		for (let i = 0; i < results.length; i++) {
+			const result = results[i];
+			const asset = assets[i];
+			if (result.success && result.audio) {
+				result.audio.volume = asset.volume ?? 1;
+				this.soundCache.set(asset.id, result.audio);
+				if (this.frequentSounds.has(asset.id)) this.audioPool.createPool(asset.id, asset.url, {
+					initialSize: 3,
+					maxSize: 10,
+					autoExpand: true
+				});
+			}
+		}
+	}
+	/**
+	* Unload an asset to free memory
+	* @param assetId - ID of the asset to unload
+	* @returns true if asset was unloaded, false if asset was not found
+	*/
+	unloadAsset(assetId) {
+		const audio = this.soundCache.get(assetId);
+		if (audio) {
+			audio.pause();
+			audio.src = "";
+			this.soundCache.delete(assetId);
+		}
+		const removedFromCache = this.audioCache.remove(assetId);
+		const unloaded = this.assetLoader.unloadAsset(assetId);
+		if (this.audioPool.hasPool(assetId)) this.audioPool.removePool(assetId);
+		this.monitor.unregisterAsset(assetId);
+		return unloaded || audio !== void 0 || removedFromCache;
+	}
+	/**
+	* Get cache statistics including LRU cache metrics
+	* LRU 캐시 메트릭을 포함한 캐시 통계 가져오기
+	*
+	* @returns Cache statistics
+	*/
+	getCacheStats() {
+		return {
+			lruCache: this.audioCache.getStats(),
+			soundCache: this.soundCache.size,
+			poolStats: this.audioPool.getAllStatistics()
+		};
+	}
+	/**
+	* Get memory statistics including total loaded MB, asset count, and warnings
+	* @returns Memory statistics object
+	*/
+	getMemoryStats() {
+		return this.monitor.getMemoryStats();
+	}
+	/**
+	* Get performance statistics including load times and playback latency
+	* @returns Performance statistics object
+	*/
+	getPerformanceStats() {
+		return this.monitor.getPerformanceStats();
+	}
+	/**
+	* Get FPS impact analysis showing baseline vs current FPS and detected drops
+	* @returns FPS impact analysis object
+	*/
+	getFPSImpact() {
+		return this.monitor.getFPSImpact();
+	}
+	/**
+	* Update FPS measurement for monitoring
+	* @param fps - Current frames per second measurement
+	*/
+	updateFPS(fps) {
+		this.monitor.updateFPS(fps);
+	}
+	/**
+	* Get comprehensive monitoring report including memory, performance, FPS, and warnings
+	* @returns Comprehensive monitoring report object
+	*/
+	getMonitoringReport() {
+		return this.monitor.getReport();
+	}
+	/**
+	* Get all memory warnings
+	* @returns Array of memory warnings
+	*/
+	getMemoryWarnings() {
+		return this.monitor.getWarnings();
+	}
+	/**
+	* Clear memory warnings
+	*/
+	clearMemoryWarnings() {
+		this.monitor.clearWarnings();
+	}
+	/**
+	* Get pool statistics for a specific asset or all pools
+	* @param assetId - Optional asset ID to get specific pool stats
+	* @returns Pool statistics for the specified asset or all pools
+	*/
+	getPoolStatistics(assetId) {
+		if (assetId) return this.audioPool.getPoolStatistics(assetId);
+		return this.audioPool.getAllStatistics();
+	}
+	/**
+	* Get loader statistics including cached assets and loading state
+	* @returns Loader statistics object
+	*/
+	getLoaderStatistics() {
+		return this.assetLoader.getStatistics();
+	}
+};
+//#endregion
+export { AudioManager as default };
+
+//# sourceMappingURL=AudioManager.js.map