jygame 0.1.0

package/input/Input.js

@@ -0,0 +1,173 @@
+const _pressed = {};
+const _justPressed = {};
+const _justReleased = {};
+
+const KEY_MAP = {
+  ArrowUp: "UP",
+  ArrowDown: "DOWN",
+  ArrowLeft: "LEFT",
+  ArrowRight: "RIGHT",
+  w: "UP",
+  W: "UP",
+  s: "DOWN",
+  S: "DOWN",
+  a: "LEFT",
+  A: "LEFT",
+  d: "RIGHT",
+  D: "RIGHT",
+  " ": "SPACE",
+  Escape: "ESCAPE",
+  Enter: "ENTER",
+};
+
+let _swipeListeners = [];
+let _tapListeners = [];
+let _trackingTouch = false;
+let _touchStartX = 0;
+let _touchStartY = 0;
+let _touchStartTime = 0;
+const MIN_SWIPE = 30;
+const TAP_TIMEOUT = 300;
+
+function handleKeyDown(e) {
+  const mapped = KEY_MAP[e.key];
+  if (mapped) {
+    if (!_pressed[mapped]) _justPressed[mapped] = true;
+    _pressed[mapped] = true;
+    if (["UP", "DOWN", "LEFT", "RIGHT", "SPACE"].includes(mapped)) {
+      e.preventDefault();
+    }
+  }
+}
+
+function handleKeyUp(e) {
+  const mapped = KEY_MAP[e.key];
+  if (mapped) {
+    if (_pressed[mapped]) _justReleased[mapped] = true;
+    _pressed[mapped] = false;
+  }
+}
+
+function handleTouchStart(e) {
+  _trackingTouch = true;
+  const t = e.touches[0];
+  _touchStartX = t.clientX;
+  _touchStartY = t.clientY;
+  _touchStartTime = Date.now();
+  e.preventDefault();
+}
+
+function handleTouchMove(e) {
+  if (!_trackingTouch) return;
+  e.preventDefault();
+}
+
+function handleTouchEnd(e) {
+  if (!_trackingTouch) return;
+  _trackingTouch = false;
+
+  const t = e.changedTouches[0];
+  const deltaX = t.clientX - _touchStartX;
+  const deltaY = t.clientY - _touchStartY;
+  const absDx = Math.abs(deltaX);
+  const absDy = Math.abs(deltaY);
+  const elapsed = Date.now() - _touchStartTime;
+
+  if (absDx < MIN_SWIPE && absDy < MIN_SWIPE && elapsed < TAP_TIMEOUT) {
+    for (const cb of _tapListeners) {
+      cb({ x: t.clientX, y: t.clientY });
+    }
+    return;
+  }
+
+  if (absDx < MIN_SWIPE && absDy < MIN_SWIPE) return;
+
+  let dir;
+  if (absDx > absDy) {
+    dir = deltaX > 0 ? "RIGHT" : "LEFT";
+  } else {
+    dir = deltaY > 0 ? "DOWN" : "UP";
+  }
+
+  for (const cb of _swipeListeners) {
+    cb(dir);
+  }
+}
+
+export const Input = {
+  buffer: [],
+
+  init(target) {
+    const el = target || document;
+    el.addEventListener("keydown", handleKeyDown);
+    el.addEventListener("keyup", handleKeyUp);
+    el.addEventListener("touchstart", handleTouchStart, { passive: false });
+    el.addEventListener("touchmove", handleTouchMove, { passive: false });
+    el.addEventListener("touchend", handleTouchEnd, { passive: false });
+  },
+
+  destroy(target) {
+    const el = target || document;
+    el.removeEventListener("keydown", handleKeyDown);
+    el.removeEventListener("keyup", handleKeyUp);
+    el.removeEventListener("touchstart", handleTouchStart);
+    el.removeEventListener("touchmove", handleTouchMove);
+    el.removeEventListener("touchend", handleTouchEnd);
+    _swipeListeners = [];
+    _tapListeners = [];
+    this.buffer = [];
+  },
+
+  updateFrame() {
+    for (const key in _justPressed) delete _justPressed[key];
+    for (const key in _justReleased) delete _justReleased[key];
+  },
+
+  clearJustPressed() {
+    for (const key in _justPressed) delete _justPressed[key];
+  },
+
+  isDown(key) {
+    return !!_pressed[key];
+  },
+
+  justPressed(key) {
+    return !!_justPressed[key];
+  },
+
+  justReleased(key) {
+    return !!_justReleased[key];
+  },
+
+  consumeBuffer() {
+    if (this.buffer.length === 0) return null;
+    return this.buffer.shift();
+  },
+
+  peekBuffer() {
+    if (this.buffer.length === 0) return null;
+    return this.buffer[0];
+  },
+
+  onSwipe(cb) {
+    _swipeListeners.push(cb);
+    return () => {
+      _swipeListeners = _swipeListeners.filter(l => l !== cb);
+    };
+  },
+
+  onTap(cb) {
+    _tapListeners.push(cb);
+    return () => {
+      _tapListeners = _tapListeners.filter(l => l !== cb);
+    };
+  },
+
+  removeSwipe(cb) {
+    _swipeListeners = _swipeListeners.filter(l => l !== cb);
+  },
+
+  removeTap(cb) {
+    _tapListeners = _tapListeners.filter(l => l !== cb);
+  },
+};

package/jygame.js

@@ -0,0 +1,14 @@
+export { Vec2 } from "./math/Vec2.js";
+export { Rect } from "./geometry/Rect.js";
+export { Clock } from "./time/Clock.js";
+export { Timer } from "./time/Timer.js";
+export { State } from "./state/State.js";
+export { Storage } from "./storage/Storage.js";
+export { Collision } from "./collision/Collision.js";
+export { Sprite } from "./display/Sprite.js";
+export { Group } from "./display/Group.js";
+export { Input } from "./input/Input.js";
+export { ImageLoader } from "./assets/ImageLoader.js";
+export { FontLoader } from "./assets/FontLoader.js";
+export { Scene } from "./core/Scene.js";
+export { Game } from "./core/Game.js";

package/math/Vec2.js

@@ -0,0 +1,90 @@
+export class Vec2 {
+  constructor(x = 0, y = 0) {
+    this.x = x;
+    this.y = y;
+  }
+
+  set(x, y) {
+    this.x = x;
+    this.y = y;
+    return this;
+  }
+
+  add(v) {
+    this.x += v.x;
+    this.y += v.y;
+    return this;
+  }
+
+  sub(v) {
+    this.x -= v.x;
+    this.y -= v.y;
+    return this;
+  }
+
+  scale(s) {
+    this.x *= s;
+    this.y *= s;
+    return this;
+  }
+
+  dot(v) {
+    return this.x * v.x + this.y * v.y;
+  }
+
+  magnitude() {
+    return Math.hypot(this.x, this.y);
+  }
+
+  normalize() {
+    const m = this.magnitude();
+    if (m === 0) return this;
+    this.x /= m;
+    this.y /= m;
+    return this;
+  }
+
+  angle() {
+    return Math.atan2(this.y, this.x);
+  }
+
+  setAngle(a) {
+    const m = this.magnitude();
+    this.x = Math.cos(a) * m;
+    this.y = Math.sin(a) * m;
+    return this;
+  }
+
+  rotate(a) {
+    const cos = Math.cos(a);
+    const sin = Math.sin(a);
+    const rx = this.x * cos - this.y * sin;
+    const ry = this.x * sin + this.y * cos;
+    this.x = rx;
+    this.y = ry;
+    return this;
+  }
+
+  perpendicular() {
+    const tx = this.x;
+    this.x = -this.y;
+    this.y = tx;
+    return this;
+  }
+
+  dist(v) {
+    return Math.hypot(this.x - v.x, this.y - v.y);
+  }
+
+  clone() {
+    return new Vec2(this.x, this.y);
+  }
+
+  static fromAngle(angle, length = 1) {
+    return new Vec2(Math.cos(angle) * length, Math.sin(angle) * length);
+  }
+
+  static lerp(a, b, t) {
+    return new Vec2(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t);
+  }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "jygame",
+  "version": "0.1.0",
+  "description": "A lightweight 2D game framework for the browser",
+  "type": "module",
+  "main": "./jygame.js",
+  "exports": {
+    ".": "./jygame.js"
+  },
+  "files": [
+    "jygame.js",
+    "math/",
+    "geometry/",
+    "time/",
+    "state/",
+    "storage/",
+    "collision/",
+    "display/",
+    "input/",
+    "assets/",
+    "core/"
+  ],
+  "keywords": [
+    "game",
+    "game-development",
+    "2d",
+    "canvas",
+    "framework"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Bouzidi-Youssef/Jygame.git"
+  },
+  "homepage": "https://github.com/Bouzidi-Youssef/Jygame#readme",
+  "bugs": {
+    "url": "https://github.com/Bouzidi-Youssef/Jygame/issues"
+  },
+  "license": "GPL-3.0-only",
+  "author": "Bouzidi Youssef",
+  "sideEffects": false
+}

package/state/State.js

@@ -0,0 +1,42 @@
+export class State {
+  constructor(initial = {}) {
+    this._state = { ...initial };
+    this._listeners = [];
+  }
+
+  get() {
+    return this._state;
+  }
+
+  set(partial) {
+    this._state = { ...this._state, ...partial };
+    this._notify();
+  }
+
+  replace(next) {
+    this._state = next;
+    this._notify();
+  }
+
+  reset(initial) {
+    this._state = { ...initial };
+    this._notify();
+  }
+
+  subscribe(fn) {
+    this._listeners.push(fn);
+    return () => {
+      this._listeners = this._listeners.filter(l => l !== fn);
+    };
+  }
+
+  unsubscribe(fn) {
+    this._listeners = this._listeners.filter(l => l !== fn);
+  }
+
+  _notify() {
+    for (const fn of this._listeners) {
+      fn(this._state);
+    }
+  }
+}

package/storage/Storage.js

@@ -0,0 +1,29 @@
+export const Storage = {
+  get(key, defaultValue = null) {
+    try {
+      const raw = localStorage.getItem(key);
+      if (raw === null) return defaultValue;
+      return JSON.parse(raw);
+    } catch {
+      return defaultValue;
+    }
+  },
+
+  set(key, value) {
+    try {
+      localStorage.setItem(key, JSON.stringify(value));
+    } catch {}
+  },
+
+  remove(key) {
+    try {
+      localStorage.removeItem(key);
+    } catch {}
+  },
+
+  clear() {
+    try {
+      localStorage.clear();
+    } catch {}
+  },
+};

package/time/Clock.js

@@ -0,0 +1,35 @@
+export class Clock {
+  constructor(fps = 60) {
+    this._fps = fps;
+    this._fixedDt = 1 / fps;
+    this._maxDelta = 0.2;
+    this._accumulator = 0;
+  }
+
+  get fps() {
+    return this._fps;
+  }
+
+  set fps(v) {
+    this._fps = v;
+    this._fixedDt = 1 / v;
+  }
+
+  get fixedDt() {
+    return this._fixedDt;
+  }
+
+  tick(realDt) {
+    this._accumulator += Math.min(realDt, this._maxDelta);
+    let count = 0;
+    while (this._accumulator >= this._fixedDt) {
+      this._accumulator -= this._fixedDt;
+      count++;
+    }
+    return count;
+  }
+
+  reset() {
+    this._accumulator = 0;
+  }
+}

package/time/Timer.js

@@ -0,0 +1,54 @@
+export class Timer {
+  constructor(duration, { loop = false, autoStart = true } = {}) {
+    this._duration = duration;
+    this._loop = loop;
+    this._elapsed = 0;
+    this._running = autoStart;
+  }
+
+  get done() {
+    return this._running && this._elapsed >= this._duration;
+  }
+
+  get progress() {
+    return Math.min(this._elapsed / this._duration, 1);
+  }
+
+  get remaining() {
+    return Math.max(this._duration - this._elapsed, 0);
+  }
+
+  get running() {
+    return this._running;
+  }
+
+  tick(dt) {
+    if (!this._running) return;
+
+    this._elapsed += dt;
+
+    if (this._elapsed >= this._duration) {
+      if (this._loop) {
+        this._elapsed -= this._duration;
+      } else {
+        this._elapsed = this._duration;
+        this._running = false;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  start() {
+    this._running = true;
+  }
+
+  stop() {
+    this._running = false;
+  }
+
+  reset() {
+    this._elapsed = 0;
+    this._running = true;
+  }
+}