add: audio, input, scene, game loop, assets loader

Author: Nightre

src/assets.ts

@@ -0,0 +1,192 @@
+import { AudioPlayer } from "./audio";
+import { Game } from "./game";
+import { IAsset as IAsset, IAssets } from "./interface";
+
+/**
+ * AssetsLoader class for loading game assets (JSON, audio, images).
+ * Supports asynchronous loading with progress tracking and error handling.
+ */
+class AssetsLoader {
+    private assets: IAssets;
+    private totalAsset: number = 0;
+    private loadedAssets: number = 0;
+    private onProgress: ((progress: number, loaded: number, total: number) => void) | null = null;
+    private onComplete: ((assets: IAssets) => void) | null = null;
+    private onError: ((error: { name: string; url: string; error: any }) => void) | null = null;
+    private game: Game
+    /**
+     * Creates an instance of AssetsLoader.
+     * Initializes the asset storage and counters.
+     */
+    constructor(game: Game) {
+        this.game = game
+        this.assets = {
+            json: {},
+            audio: {},
+            images: {}
+        };
+    }
+
+    /**
+     * Sets the callback for loading progress updates.
+     * @param callback - Function called with progress (0.0 to 1.0), loaded count, and total count.
+     */
+    setProgressCallback(callback: (progress: number, loaded: number, total: number) => void): void {
+        this.onProgress = callback;
+    }
+
+    /**
+     * Sets the callback for when all assets are loaded.
+     * @param callback - Function called with the loaded assets.
+     */
+    setCompleteCallback(callback: (assets: IAssets) => void): void {
+        this.onComplete = callback;
+    }
+
+    /**
+     * Sets the callback for handling loading errors.
+     * @param callback - Function called with error details (name, url, error).
+     */
+    setErrorCallback(callback: (error: { name: string; url: string; error: any }) => void): void {
+        this.onError = callback;
+    }
+
+    /**
+     * Loads a JSON file asynchronously.
+     * @param name - The unique identifier for the JSON asset.
+     * @param url - The URL of the JSON file.
+     */
+    loadJson(name: string, url: string): void {
+        this.totalAsset++;
+        fetch(url)
+            .then(response => response.json())
+            .then(data => {
+                this.assets.json[name] = data;
+                this.assetLoaded();
+            })
+            .catch(error => this.handleError(name, url, error));
+    }
+
+    /**
+     * Loads an audio file asynchronously.
+     * @param name - The unique identifier for the audio asset.
+     * @param url - The URL of the audio file.
+     */
+    loadAudio(name: string, url: string): void {
+        this.totalAsset++;
+        const audio = new Audio();
+        audio.src = url;
+        audio.oncanplaythrough = () => {
+            this.assets.audio[name] = new AudioPlayer(audio, this.game.audio.audioContext);
+            this.assetLoaded();
+            audio.oncanplaythrough = null; // Clear event
+        };
+        audio.onerror = () => this.handleError(name, url, 'Audio load error');
+    }
+
+    /**
+     * Loads an image file asynchronously.
+     * @param name - The unique identifier for the image asset.
+     * @param url - The URL of the image file.
+     */
+    loadImage(name: string, url: string): void {
+        this.totalAsset++;
+        const img = new Image();
+        img.src = url;
+        img.onload = () => {
+            this.assets.images[name] = this.game.render.texture.textureFromSource(img);
+            this.assetLoaded();
+        };
+        img.onerror = () => this.handleError(name, url, 'Image load error');
+    }
+
+    /**
+     * Loads multiple assets from a list.
+     * @param assetList - Array of assets to load.
+     */
+    loadAssets(assetList: IAsset[]): void {
+        assetList.forEach(asset => {
+            switch (asset.type) {
+                case 'json':
+                    this.loadJson(asset.name, asset.url);
+                    break;
+                case 'audio':
+                    this.loadAudio(asset.name, asset.url);
+                    break;
+                case 'image':
+                    this.loadImage(asset.name, asset.url);
+                    break;
+                default:
+                    console.warn(`Unknown asset type: ${asset.type}`);
+            }
+        });
+    }
+
+    /**
+     * Handles the completion of an asset load.
+     * Updates progress and triggers completion callback if all assets are loaded.
+     */
+    private assetLoaded(): void {
+        this.loadedAssets++;
+        if (this.onProgress) {
+            const progress = this.loadedAssets / this.totalAsset;
+            this.onProgress(progress, this.loadedAssets, this.totalAsset);
+        }
+        if (this.loadedAssets === this.totalAsset && this.onComplete) {
+            this.onComplete(this.assets);
+        }
+    }
+
+    /**
+     * Handles errors during asset loading.
+     * @param name - The name of the asset.
+     * @param url - The URL of the asset.
+     * @param error - The error object or message.
+     */
+    private handleError(name: string, url: string, error: any): void {
+        if (this.onError) {
+            this.onError({ name, url, error });
+        } else {
+            console.error(`Failed to load asset ${name} from ${url}:`, error);
+        }
+    }
+
+    /**
+     * Retrieves a loaded asset by type and name.
+     * @param type - The type of asset ('json', 'audio', or 'images').
+     * @param name - The name of the asset.
+     * @returns The loaded asset or undefined if not found.
+     */
+    get<T extends keyof IAssets>(type: T, name: string): IAssets[T][string] | undefined {
+        return this.assets[type]?.[name];
+    }
+
+    /**
+     * Retrieves a loaded JSON asset by name.
+     * @param name - The name of the JSON asset.
+     * @returns The loaded JSON data or undefined if not found.
+     */
+    getJSON(name: string): any | undefined {
+        return this.assets.json[name];
+    }
+
+    /**
+     * Retrieves a loaded audio asset by name.
+     * @param name - The name of the audio asset.
+     * @returns The loaded AudioPlayer instance or undefined if not found.
+     */
+    getAudio(name: string): AudioPlayer | undefined {
+        return this.assets.audio[name];
+    }
+
+    /**
+     * Retrieves a loaded texture (image) asset by name.
+     * @param name - The name of the texture asset.
+     * @returns The loaded texture or undefined if not found.
+     */
+    getTexture(name: string): any | undefined {
+        return this.assets.images[name];
+    }
+}
+
+export default AssetsLoader;

src/audio.ts

@@ -0,0 +1,93 @@
+import { ISound } from "./interface";
+
+/**
+ * Audio class for managing individual audio elements.
+ * Encapsulates an HTMLAudioElement and its Web Audio API nodes.
+ */
+export class AudioPlayer {
+    public element: HTMLAudioElement;
+    public source: AudioNode | null;
+    public gainNode: GainNode;
+    private audioContext: AudioContext;
+
+    /**
+     * Creates an instance of Audio.
+     * @param audioElement - The HTMLAudioElement to manage.
+     * @param audioContext - The Web Audio API context.
+     */
+    constructor(audioElement: HTMLAudioElement, audioContext: AudioContext) {
+        this.element = audioElement;
+        this.audioContext = audioContext;
+        this.source = null;
+        this.gainNode = this.audioContext.createGain();
+    }
+
+    /**
+     * Plays the audio with optional looping.
+     * @param loop - Whether the audio should loop (default: false).
+     */
+    async play(loop: boolean = false): Promise<void> {
+        try {
+            this.element.loop = loop;
+            this.source = this.audioContext.createMediaElementSource(this.element);
+            this.source.connect(this.gainNode);
+            this.gainNode.connect(this.audioContext.destination);
+            await this.element.play();
+        } catch (error) {
+            console.error(`Error playing audio:`, error);
+        }
+    }
+
+    /**
+     * Pauses the audio.
+     */
+    pause(): void {
+        this.element.pause();
+    }
+
+    /**
+     * Stops the audio and resets playback position.
+     */
+    stop(): void {
+        this.element.pause();
+        this.element.currentTime = 0;
+        if (this.source) {
+            this.source.disconnect();
+            this.source = null;
+        }
+    }
+
+    /**
+     * Sets the volume for the audio.
+     * @param volume - Volume level (0.0 to 1.0).
+     */
+    setVolume(volume: number): void {
+        this.gainNode.gain.value = Math.max(0, Math.min(1, volume));
+    }
+
+    /**
+     * Cleans up resources associated with the audio.
+     */
+    destroy(): void {
+        this.stop();
+        this.gainNode.disconnect();
+    }
+}
+
+/**
+ * AudioManager class for managing game audio, including background music (BGM) and sound effects (SFX).
+ * Delegates audio-specific responsibilities to AudioPlayer instances.
+ */
+class AudioManager {
+  audioContext: AudioContext;
+
+  constructor() {
+    this.audioContext = new (window.AudioContext || (window as any).webkitAudioContext)();
+  }
+
+  destroy(): void {
+    this.audioContext.close();
+  }
+}
+
+export default AudioManager;