kiwiengine 0.0.1-alpha → 0.5.3

package/lib/types/types/bitmap-font.d.ts

@@ -0,0 +1,18 @@
+import { Texture } from 'pixi.js';
+export type Char = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    xoffset: number;
+    yoffset: number;
+    xadvance: number;
+};
+export type BitmapFont = {
+    src: string;
+    chars: Record<number, Char>;
+    texture: Texture;
+    size: number;
+    lineHeight: number;
+};
+//# sourceMappingURL=bitmap-font.d.ts.map

package/lib/types/types/bitmap-font.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitmap-font.d.ts","sourceRoot":"","sources":["../../../src/types/bitmap-font.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAEjC,MAAM,MAAM,IAAI,GAAG;IACjB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;IAC3B,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA"}

package/lib/types/types/sprite-atlas.d.ts

@@ -0,0 +1,13 @@
+export type AnimationAtlas = {
+    frames: Record<string, {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }>;
+    animations: Record<string, {
+        frames: string[];
+        loop?: boolean;
+    }>;
+};
+//# sourceMappingURL=sprite-atlas.d.ts.map

package/lib/types/types/sprite-atlas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sprite-atlas.d.ts","sourceRoot":"","sources":["../../../src/types/sprite-atlas.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IACtE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC,CAAA;CACjE,CAAA"}

package/lib/types/utils/device.d.ts

@@ -0,0 +1,2 @@
+export declare const isMobile: boolean;
+//# sourceMappingURL=device.d.ts.map

package/lib/types/utils/device.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device.d.ts","sourceRoot":"","sources":["../../../src/utils/device.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,SAAwD,CAAA"}

package/lib/utils/device.js

@@ -0,0 +1,2 @@
+export const isMobile = /Android|iPhone|iPad|iPod/i.test(navigator.userAgent);
+//# sourceMappingURL=device.js.map

package/lib/utils/device.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"device.js","sourceRoot":"","sources":["../../src/utils/device.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,QAAQ,GAAG,2BAA2B,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAA","sourcesContent":["export const isMobile = /Android|iPhone|iPad|iPod/i.test(navigator.userAgent)\n"]}

package/package.json

@@ -1,8 +1,15 @@
 {
   "name": "kiwiengine",
-  "version": "0.0.1-alpha",
+  "version": "0.5.3",
   "types": "./lib/types/index.d.ts",
   "main": "./lib/index.js",
+  "dependencies": {
+    "@esotericsoftware/spine-pixi-v8": "^4.2.88",
+    "@webtaku/event-emitter": "^0.0.2",
+    "matter-js": "^0.20.0",
+    "pixi.js": "^8.11.0",
+    "stats.js": "^0.17.0"
+  },
   "devDependencies": {
     "@types/jest": "^30.0.0",
     "@types/matter-js": "^0.19.8",
@@ -13,11 +20,5 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.8.3"
   },
-  "dependencies": {
-    "@esotericsoftware/spine-pixi-v8": "^4.2.88",
-    "matter-js": "^0.20.0",
-    "pixi.js": "^8.11.0",
-    "stats.js": "^0.17.0"
-  },
   "packageManager": "yarn@1.22.22"
 }

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,42 @@
-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();
-
       try {
-        const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
+        const arrayBuffer = await response.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;
+  override async load(src: string) {
+    return await super.load(src)
   }
 }
 
-export const audioLoader = new AudioLoader();
+export const audioLoader = new AudioLoader()

package/src/asset/loaders/binary.ts

@@ -1,32 +1,36 @@
-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()
 
-      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;
+          const data = new Uint8Array(arrayBuffer)
+          this.cachedAssets.set(src, data)
+          return data
         }
       }
-    })();
+    })()
 
-    this.loadingPromises.set(src, loadingPromise);
-    return await loadingPromise;
+    this.loadingPromises.set(src, loadingPromise)
+    return await loadingPromise
+  }
+
+  override async load(src: string) {
+    return await super.load(src)
   }
 }
 
-export const binaryLoader = new BinaryLoader();
+export const binaryLoader = new BinaryLoader()

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

@@ -0,0 +1,91 @@
+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()
+
+        this.loadingPromises.delete(fnt)
+
+        if (this.hasActiveRef(fnt)) {
+          if (this.cachedAssets.has(fnt)) {
+            textureLoader.release(src)
+            console.error(`Bitmap font already exists: ${fnt}`)
+          } else {
+
+            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 }
+            }
+
+            const bitmapFont = { src, chars, texture, size, lineHeight }
+
+            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)
+  }
+
+  override async load(fnt: string, src: string) {
+    return await super.load(fnt, src)
+  }
+}
+
+export const bitmapFontLoader = new BitmapFontLoader()

package/src/asset/loaders/font.ts

@@ -1,27 +1,31 @@
-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
+  }
+
+  override async load(fontName: string) {
+    return await super.load(fontName)
   }
 }
 
-export const fontFamilyLoader = new FontFamilyLoader();
+export const fontFamilyLoader = new FontFamilyLoader()