kiwiengine 0.0.1-alpha → 0.5.2

package/src/asset/audio.ts

@@ -1,176 +1,220 @@
-import { audioLoader } from './loaders/audio';
+import { isMobile } from '../utils/device'
+import { audioLoader } from './loaders/audio'
 
-const audioContext = new (window.AudioContext || (window as any).webkitAudioContext)();
-window.addEventListener('mousedown', () => audioContext.resume());
-window.addEventListener('touchend', () => audioContext.resume());
+export const audioContext = new (window.AudioContext || (window as any).webkitAudioContext)()
+window.addEventListener('mousedown', () => audioContext.resume())
+window.addEventListener('touchend', () => audioContext.resume())
 
 async function getAvailableContext(): Promise<AudioContext> {
-  if (audioContext.state === 'suspended') await audioContext.resume();
-  return audioContext;
+  if (audioContext.state === 'suspended') await audioContext.resume()
+  return audioContext
 }
 
-const isMobile = /Android|iPhone|iPad|iPod/i.test(navigator.userAgent);
-let isPageVisible = !document.hidden;
-window.addEventListener('visibilitychange', () => isPageVisible = !document.hidden);
+let isPageVisible = !document.hidden
+window.addEventListener('visibilitychange', () => isPageVisible = !document.hidden)
+
+type BasicStorage = Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>
+
+type SafeStorage = BasicStorage & {
+  persistent: boolean
+}
+
+function createSafeStorage(): SafeStorage {
+  const memory = (() => {
+    const m = new Map<string, string>()
+    const api: SafeStorage = {
+      persistent: false,
+      getItem: (k) => (m.has(k) ? m.get(k)! : null),
+      setItem: (k, v) => { m.set(k, String(v)) },
+      removeItem: (k) => { m.delete(k) },
+    }
+    return api
+  })()
+
+  if (typeof window === 'undefined') return memory
+
+  try {
+    const ls = window.localStorage
+    const probeKey = '__safe_ls_probe__' + Math.random().toString(36).slice(2)
+    ls.setItem(probeKey, '1')
+    ls.removeItem(probeKey)
+
+    const safe: SafeStorage = {
+      persistent: true,
+      getItem: (k) => ls.getItem(k),
+      setItem: (k, v) => ls.setItem(k, v),
+      removeItem: (k) => ls.removeItem(k),
+    }
+    return safe
+  } catch {
+    return memory
+  }
+}
+
+const safeStorage = createSafeStorage()
 
 class Audio {
-  src: string;
-  #volume: number;
-  #loop: boolean;
+  src: string
+  #volume: number
+  #loop: boolean
 
-  #audioBuffer?: AudioBuffer;
-  #audioContext?: AudioContext;
-  #gainNode?: GainNode;
-  #source?: AudioBufferSourceNode;
+  #audioBuffer?: AudioBuffer
+  #audioContext?: AudioContext
+  #gainNode?: GainNode
+  #source?: AudioBufferSourceNode
 
-  #isPlaying = false;
-  #isPaused = false;
-  #startTime = 0;
-  #pauseTime = 0;
-  #offset = 0;
+  #isPlaying = false
+  #isPaused = false
+  #startTime = 0
+  #pauseTime = 0
+  #offset = 0
 
   constructor(src: string, volume: number, loop: boolean) {
-    this.src = src;
-    this.#volume = volume;
-    this.#loop = loop;
-    this.play();
+    this.src = src
+    this.#volume = volume
+    this.#loop = loop
+    this.play()
   }
 
-  get volume() { return this.#volume; }
+  get volume() { return this.#volume }
   set volume(volume: number) {
-    this.#volume = volume;
-    if (this.#gainNode) this.#gainNode.gain.value = Math.max(0, Math.min(1, volume));
+    this.#volume = volume
+    if (this.#gainNode) this.#gainNode.gain.value = Math.max(0, Math.min(1, volume))
   }
 
   async play() {
-    if (isMobile && !isPageVisible) return;
+    if (isMobile && !isPageVisible) return
 
     if (!this.#audioBuffer) {
-      if (!audioLoader.checkLoaded(this.src)) {
-        console.info(`Audio not preloaded. Loading now: ${this.src}`);
+      if (audioLoader.checkCached(this.src)) {
+        this.#audioBuffer = audioLoader.getCached(this.src)
+      } else {
+        console.info(`Audio not preloaded. Loading now: ${this.src}`)
+        this.#audioBuffer = await audioLoader.load(this.src)
       }
-      this.#audioBuffer = await audioLoader.load(this.src);
     }
-    if (!this.#audioBuffer) return;
+    if (!this.#audioBuffer) return
 
-    if (this.#isPlaying) this.stop();
-    if (!this.#isPaused) this.#offset = 0;
-    this.#isPlaying = true;
-    this.#isPaused = false;
-    if (!this.#audioContext) this.#audioContext = await getAvailableContext();
-    if (!this.#isPlaying) return;
+    if (this.#isPlaying) this.stop()
+    if (!this.#isPaused) this.#offset = 0
+    this.#isPlaying = true
+    this.#isPaused = false
+    if (!this.#audioContext) this.#audioContext = await getAvailableContext()
+    if (!this.#isPlaying) return
 
     if (!this.#gainNode) {
-      this.#gainNode = this.#audioContext.createGain();
-      this.#gainNode.gain.value = this.#volume;
-      this.#gainNode.connect(this.#audioContext.destination);
+      this.#gainNode = this.#audioContext.createGain()
+      this.#gainNode.gain.value = this.#volume
+      this.#gainNode.connect(this.#audioContext.destination)
     }
 
-    this.#source = this.#audioContext.createBufferSource();
-    this.#source.buffer = this.#audioBuffer;
-    this.#source.loop = this.#loop;
-    this.#source.connect(this.#gainNode);
-    this.#source.start(0, this.#offset);
-    this.#startTime = this.#audioContext.currentTime;
-    this.#source.onended = () => { if (!this.#isPaused && !this.#loop) this.stop(); };
+    this.#source = this.#audioContext.createBufferSource()
+    this.#source.buffer = this.#audioBuffer
+    this.#source.loop = this.#loop
+    this.#source.connect(this.#gainNode)
+    this.#source.start(0, this.#offset)
+    this.#startTime = this.#audioContext.currentTime
+    this.#source.onended = () => { if (!this.#isPaused && !this.#loop) this.stop() }
   }
 
   #clear(): void {
     if (this.#source) {
-      this.#source.stop();
-      this.#source.disconnect();
-      this.#source = undefined;
+      this.#source.stop()
+      this.#source.disconnect()
+      this.#source = undefined
     }
   }
 
   pause() {
     if (this.#isPlaying && !this.#isPaused) {
       if (this.#audioContext) {
-        this.#pauseTime = this.#audioContext.currentTime;
-        this.#offset += this.#pauseTime - this.#startTime;
+        this.#pauseTime = this.#audioContext.currentTime
+        this.#offset += this.#pauseTime - this.#startTime
       }
-      this.#isPaused = true;
-      this.#isPlaying = false;
-      this.#clear();
+      this.#isPaused = true
+      this.#isPlaying = false
+      this.#clear()
     }
   }
 
   stop() {
-    this.#isPlaying = false;
-    this.#isPaused = false;
-    this.#offset = 0;
-    this.#clear();
+    this.#isPlaying = false
+    this.#isPaused = false
+    this.#offset = 0
+    this.#clear()
   }
 }
 
 class MusicPlayer {
-  #volume = 0.7;
-  #currentAudio?: Audio;
+  #volume = 0.7
+  #currentAudio?: Audio
 
   constructor() {
-    const stored = parseFloat(localStorage.getItem('musicVolume') || '');
-    this.#volume = Number.isNaN(stored) ? this.#volume : stored;
+    const stored = parseFloat(safeStorage.getItem('musicVolume') || '')
+    this.#volume = Number.isNaN(stored) ? this.#volume : stored
 
     if (isMobile) {
       document.addEventListener('visibilitychange', () => {
-        if (document.hidden) this.pause();
+        if (document.hidden) this.pause()
         else {
-          isPageVisible = true;
-          this.#currentAudio?.play();
+          isPageVisible = true
+          this.#currentAudio?.play()
         }
-      });
+      })
     }
   }
 
   get volume() {
-    return this.#volume;
+    return this.#volume
   }
 
   set volume(volume: number) {
-    this.#volume = volume;
-    localStorage.setItem('musicVolume', volume.toString());
-    if (this.#currentAudio) this.#currentAudio.volume = volume;
+    this.#volume = volume
+    safeStorage.setItem('musicVolume', volume.toString())
+    if (this.#currentAudio) this.#currentAudio.volume = volume
   }
 
   play(src: string) {
-    if (this.#currentAudio?.src === src) return;
-    this.#currentAudio?.stop();
-    this.#currentAudio = new Audio(src, this.#volume, true);
+    if (this.#currentAudio?.src === src) return
+    this.#currentAudio?.stop()
+    this.#currentAudio = new Audio(src, this.#volume, true)
   }
 
   pause() {
-    this.#currentAudio?.pause();
+    this.#currentAudio?.pause()
   }
 
   stop() {
-    this.#currentAudio?.stop();
-    this.#currentAudio = undefined;
+    this.#currentAudio?.stop()
+    this.#currentAudio = undefined
   }
 }
 
 class SfxPlayer {
-  #volume = 1;
+  #volume = 1
 
   constructor() {
-    const stored = parseFloat(localStorage.getItem('sfxVolume') || '');
-    this.#volume = Number.isNaN(stored) ? this.#volume : stored;
+    const stored = parseFloat(safeStorage.getItem('sfxVolume') || '')
+    this.#volume = Number.isNaN(stored) ? this.#volume : stored
   }
 
   get volume() {
-    return this.#volume;
+    return this.#volume
   }
 
   set volume(volume: number) {
-    this.#volume = volume;
-    localStorage.setItem('sfxVolume', volume.toString());
+    this.#volume = volume
+    safeStorage.setItem('sfxVolume', volume.toString())
   }
 
   play(src: string) {
-    new Audio(src, this.#volume, false);
+    new Audio(src, this.#volume, false)
   }
-}
 
-const musicPlayer = new MusicPlayer();
-const sfxPlayer = new SfxPlayer();
+  playRandom(...srcs: string[]) {
+    this.play(srcs[Math.floor(Math.random() * srcs.length)])
+  }
+}
 
-export { audioContext, musicPlayer, sfxPlayer };
+export const musicPlayer = new MusicPlayer()
+export const sfxPlayer = new SfxPlayer()

package/src/asset/loaders/audio.ts

@@ -1,39 +1,39 @@
-import { audioContext } from '../audio';
-import { Loader } from './loader';
+import { audioContext } from '../audio'
+import { Loader } from './loader'
 
 class AudioLoader extends Loader<AudioBuffer> {
-  protected override async _load(src: string) {
+  protected override async doLoad(src: string) {
     const loadingPromise = (async () => {
-      const response = await fetch(src);
+      const response = await fetch(src)
       if (!response.ok) {
-        console.error(`Failed to load audio data: ${src}`);
-        return;
+        console.error(`Failed to load audio data: ${src}`)
+        return
       }
 
-      const arrayBuffer = await response.arrayBuffer();
+      const arrayBuffer = await response.arrayBuffer()
 
       try {
-        const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
+        const audioBuffer = await audioContext.decodeAudioData(arrayBuffer)
 
-        this.loadingPromises.delete(src);
+        this.loadingPromises.delete(src)
 
         if (this.hasActiveRef(src)) {
-          if (this.loadedAssets.has(src)) {
-            console.error(`Audio buffer already exists: ${src}`);
+          if (this.cachedAssets.has(src)) {
+            console.error(`Audio buffer already exists: ${src}`)
           } else {
-            this.loadedAssets.set(src, audioBuffer);
-            return audioBuffer;
+            this.cachedAssets.set(src, audioBuffer)
+            return audioBuffer
           }
         }
       } catch (error) {
-        console.error(`Failed to decode audio data: ${src}`, error);
-        this.loadingPromises.delete(src);
+        console.error(`Failed to decode audio data: ${src}`, error)
+        this.loadingPromises.delete(src)
       }
-    })();
+    })()
 
-    this.loadingPromises.set(src, loadingPromise);
-    return await loadingPromise;
+    this.loadingPromises.set(src, loadingPromise)
+    return await loadingPromise
   }
 }
 
-export const audioLoader = new AudioLoader();
+export const audioLoader = new AudioLoader()

package/src/asset/loaders/binary.ts

@@ -1,32 +1,32 @@
-import { Loader } from './loader';
+import { Loader } from './loader'
 
 class BinaryLoader extends Loader<Uint8Array> {
-  protected override async _load(src: string) {
+  protected override async doLoad(src: string) {
     const loadingPromise = (async () => {
-      const response = await fetch(src);
+      const response = await fetch(src)
       if (!response.ok) {
-        console.error(`Failed to load binary data: ${src}`);
-        return;
+        console.error(`Failed to load binary data: ${src}`)
+        return
       }
 
-      const arrayBuffer = await response.arrayBuffer();
-      const data = new Uint8Array(arrayBuffer);
+      const arrayBuffer = await response.arrayBuffer()
+      const data = new Uint8Array(arrayBuffer)
 
-      this.loadingPromises.delete(src);
+      this.loadingPromises.delete(src)
 
       if (this.hasActiveRef(src)) {
-        if (this.loadedAssets.has(src)) {
-          console.error(`Binary data already exists: ${src}`);
+        if (this.cachedAssets.has(src)) {
+          console.error(`Binary data already exists: ${src}`)
         } else {
-          this.loadedAssets.set(src, data);
-          return data;
+          this.cachedAssets.set(src, data)
+          return data
         }
       }
-    })();
+    })()
 
-    this.loadingPromises.set(src, loadingPromise);
-    return await loadingPromise;
+    this.loadingPromises.set(src, loadingPromise)
+    return await loadingPromise
   }
 }
 
-export const binaryLoader = new BinaryLoader();
+export const binaryLoader = new BinaryLoader()

package/src/asset/loaders/bitmap-font.ts

@@ -0,0 +1,85 @@
+import { BitmapFont, Char } from '../../types/bitmap-font'
+import { Loader } from './loader'
+import { textureLoader } from './texture'
+
+class BitmapFontLoader extends Loader<BitmapFont> {
+  #fntToSrc = new Map<string, string>()
+
+  protected override async doLoad(fnt: string, src: string) {
+    this.#fntToSrc.set(fnt, src)
+
+    const loadingPromise = (async () => {
+      const texture = await textureLoader.load(src)
+      if (!texture) {
+        console.error(`Failed to load texture: ${src}`)
+        return
+      }
+
+      const response = await fetch(fnt)
+      if (!response.ok) {
+        console.error(`Failed to load font xml: ${fnt}`)
+        return
+      }
+
+      try {
+        const text = await response.text()
+
+        const parser = new DOMParser()
+        const xmlDoc = parser.parseFromString(text, 'application/xml')
+
+        const infoEl = xmlDoc.getElementsByTagName('info')[0]
+        const commonEl = xmlDoc.getElementsByTagName('common')[0]
+        const charEls = xmlDoc.getElementsByTagName('char')
+
+        const size = parseInt(infoEl.getAttribute('size') || '16', 10)
+        const lineHeight = parseInt(commonEl.getAttribute('lineHeight') || '32', 10)
+
+        const chars: Record<number, Char> = {}
+
+        for (let i = 0; i < charEls.length; i++) {
+          const charEl = charEls[i]
+
+          const id = parseInt(charEl.getAttribute('id')!, 10)
+          const x = parseInt(charEl.getAttribute('x')!, 10)
+          const y = parseInt(charEl.getAttribute('y')!, 10)
+          const width = parseInt(charEl.getAttribute('width')!, 10)
+          const height = parseInt(charEl.getAttribute('height')!, 10)
+          const xoffset = parseInt(charEl.getAttribute('xoffset')!, 10)
+          const yoffset = parseInt(charEl.getAttribute('yoffset')!, 10)
+          const xadvance = parseInt(charEl.getAttribute('xadvance')!, 10)
+
+          chars[id] = { x, y, width, height, xoffset, yoffset, xadvance }
+        }
+
+        this.loadingPromises.delete(fnt)
+
+        const bitmapFont = { src, chars, texture, size, lineHeight }
+        if (this.hasActiveRef(fnt)) {
+          if (this.cachedAssets.has(fnt)) {
+            textureLoader.release(src)
+            console.error(`Bitmap font already exists: ${fnt}`)
+          } else {
+            this.cachedAssets.set(fnt, bitmapFont)
+            return bitmapFont
+          }
+        } else {
+          textureLoader.release(src)
+        }
+
+      } catch (error) {
+        console.error(`Failed to decode font xml: ${fnt}`, error)
+        this.loadingPromises.delete(fnt)
+      }
+    })()
+
+    this.loadingPromises.set(fnt, loadingPromise)
+    return await loadingPromise
+  }
+
+  protected override cleanup(fnt: string) {
+    const src = this.#fntToSrc.get(fnt)
+    if (src) textureLoader.release(src)
+  }
+}
+
+export const bitmapFontLoader = new BitmapFontLoader()

package/src/asset/loaders/font.ts

@@ -1,27 +1,27 @@
-import { Loader } from './loader';
+import { Loader } from './loader'
 
 class FontFamilyLoader extends Loader<boolean> {
-  protected override async _load(fontName: string) {
+  protected override async doLoad(fontName: string) {
     const loadingPromise = (async () => {
       if ('fonts' in document) {
         try {
-          await document.fonts.load(`1em ${fontName}`);
-          await document.fonts.ready;
-          this.loadingPromises.delete(fontName);
-          return true;
+          await document.fonts.load(`1em ${fontName}`)
+          await document.fonts.ready
+          this.loadingPromises.delete(fontName)
+          return true
         } catch (error) {
-          console.error(`Failed to load font: ${fontName}`, error);
-          this.loadingPromises.delete(fontName);
+          console.error(`Failed to load font: ${fontName}`, error)
+          this.loadingPromises.delete(fontName)
         }
       } else {
-        console.warn(`This browser does not support the Font Loading API`);
-        this.loadingPromises.delete(fontName);
+        console.warn(`This browser does not support the Font Loading API`)
+        this.loadingPromises.delete(fontName)
       }
-    })();
+    })()
 
-    this.loadingPromises.set(fontName, loadingPromise);
-    return await loadingPromise;
+    this.loadingPromises.set(fontName, loadingPromise)
+    return await loadingPromise
   }
 }
 
-export const fontFamilyLoader = new FontFamilyLoader();
+export const fontFamilyLoader = new FontFamilyLoader()

package/src/asset/loaders/loader.ts

@@ -1,39 +1,43 @@
-abstract class Loader<T> {
-  protected loadedAssets: Map<string, T> = new Map();
-  protected loadingPromises: Map<string, Promise<T | undefined>> = new Map();
+export abstract class Loader<T> {
+  protected cachedAssets = new Map<string, T>()
+  protected loadingPromises = new Map<string, Promise<T | undefined>>()
 
-  #refCount: Map<string, number> = new Map();
-  #incRefCount(id: string) { this.#refCount.set(id, (this.#refCount.get(id) || 0) + 1); }
+  #refCount = new Map<string, number>()
+  #incRefCount(id: string) { this.#refCount.set(id, (this.#refCount.get(id) || 0) + 1) }
 
-  protected hasActiveRef(id: string) { return this.#refCount.get(id)! > 0; }
-  protected abstract _load(id: string, ...args: any[]): Promise<T | undefined>;
-  protected _dispose(id: string, asset: T): void { /* override to clean up */ }
+  protected hasActiveRef(id: string) { return this.#refCount.get(id)! > 0 }
+  protected abstract doLoad(id: string, ...args: any[]): Promise<T | undefined>
+  protected cleanup(id: string, asset: T): void { /* override to clean up */ }
 
-  checkLoaded(id: string) {
-    return this.loadedAssets.has(id);
+  checkCached(id: string) {
+    return this.cachedAssets.has(id)
+  }
+
+  getCached(id: string) {
+    if (!this.checkCached(id)) throw new Error(`Asset not found: ${id}`)
+    this.#incRefCount(id)
+    return this.cachedAssets.get(id)
   }
 
   async load(id: string, ...args: any[]) {
-    this.#incRefCount(id);
-    if (this.checkLoaded(id)) return this.loadedAssets.get(id);
-    if (this.loadingPromises.has(id)) return await this.loadingPromises.get(id);
-    return await this._load(id, ...args);
+    this.#incRefCount(id)
+    if (this.checkCached(id)) return this.cachedAssets.get(id)
+    if (this.loadingPromises.has(id)) return await this.loadingPromises.get(id)
+    return await this.doLoad(id, ...args)
   }
 
   release(id: string) {
-    const refCount = this.#refCount.get(id);
-    if (refCount === undefined) throw new Error(`Asset not found: ${id}`);
+    const refCount = this.#refCount.get(id)
+    if (refCount === undefined) throw new Error(`Asset not found: ${id}`)
     if (refCount === 1) {
-      this.#refCount.delete(id);
-      const asset = this.loadedAssets.get(id);
+      this.#refCount.delete(id)
+      const asset = this.cachedAssets.get(id)
       if (asset) {
-        this._dispose(id, asset);
-        this.loadedAssets.delete(id);
+        this.cleanup(id, asset)
+        this.cachedAssets.delete(id)
       }
     } else {
-      this.#refCount.set(id, refCount - 1);
+      this.#refCount.set(id, refCount - 1)
     }
   }
 }
-
-export { Loader };