@dryanovski/gamefoo 0.0.1 → 0.2.1

package/dist/index.js

@@ -1,610 +1,29 @@
-// core/behaviour.ts
-class Behaviour {
-  owner;
-  priority = 1;
-  enabled = true;
-  get key() {
-    return this.type.toLowerCase();
-  }
-  constructor(owner) {
-    this.owner = owner;
-  }
-}
-// core/behaviours/collidable.ts
-class Collidable extends Behaviour {
-  type = "collidable";
-  shape;
-  layer = 0;
-  tags = new Set;
-  collidesWith = new Set;
-  solid = false;
-  fixed = false;
-  onCollision;
-  world;
-  constructor(owner, world, options) {
-    super(owner);
-    this.world = world;
-    const size = owner.getSize();
-    this.shape = options.shape;
-    this.shape = options.shape ?? {
-      type: "aabb",
-      width: size.width,
-      height: size.height
-    };
-    this.layer = options.layer ?? 0;
-    this.tags = options.tags ?? new Set;
-    this.solid = options.solid ?? false;
-    this.fixed = options.fixed ?? false;
-    this.collidesWith = options.collidesWith ?? new Set;
-    this.onCollision = options.onCollision || (() => {});
-  }
-  update(_deltaTime) {}
-  onAttach() {
-    this.world.register(this);
-  }
-  onDetach() {
-    this.world.unregister(this);
-  }
-  getOwner() {
-    return this.owner;
-  }
-  getWorldBounds() {
-    const pos = this.owner.getPosition();
-    const offset = "offset" in this.shape && this.shape.offset ? this.shape.offset : { x: 0, y: 0 };
-    if (this.shape.type === "aabb") {
-      return {
-        x: pos.x + offset.x,
-        y: pos.y + offset.y,
-        width: this.shape.width,
-        height: this.shape.height
-      };
-    }
-    const r = this.shape.radius;
-    return {
-      x: pos.x + offset.x - r,
-      y: pos.y + offset.y - r,
-      width: r * 2,
-      height: r * 2
-    };
-  }
-}
-// core/behaviours/control.ts
-class Control extends Behaviour {
-  type = "control";
-  input;
-  speed = 500;
-  constructor(owner, input) {
-    super(owner);
-    this.input = input;
-  }
-  update(deltaTime) {
-    let dx = 0;
-    let dy = 0;
-    if (this.input.isKeyDown("a") || this.input.isKeyDown("arrowleft"))
-      dx -= 1;
-    if (this.input.isKeyDown("d") || this.input.isKeyDown("arrowright"))
-      dx += 1;
-    if (this.input.isKeyDown("w") || this.input.isKeyDown("arrowup"))
-      dy -= 1;
-    if (this.input.isKeyDown("s") || this.input.isKeyDown("arrowdown"))
-      dy += 1;
-    const len = Math.sqrt(dx * dx + dy * dy);
-    if (len > 0) {
-      this.owner.x += dx / len * this.speed * deltaTime;
-      this.owner.y += dy / len * this.speed * deltaTime;
-    }
-  }
-}
-// core/behaviours/healtkit.ts
-class HealthKit extends Behaviour {
-  type = "healthkit";
-  health;
-  maxHP;
-  constructor(owner, health, maxHP) {
-    super(owner);
-    this.health = health;
-    this.maxHP = maxHP || health;
-  }
-  update(_deltaTime) {}
-  takeDamage(amount) {
-    this.health = Math.max(0, this.health - amount);
-  }
-  heal(amount) {
-    this.health = Math.min(this.maxHP, this.health + amount);
-  }
-  getHealth() {
-    return this.health;
-  }
-  getMaxHealth() {
-    return this.maxHP;
-  }
-  setMaxHealth(value) {
-    this.maxHP = value;
-    if (this.health > this.maxHP) {
-      this.health = this.maxHP;
-    }
-  }
-  isDead() {
-    return this.health <= 0;
-  }
-  getHealthPercent() {
-    return this.maxHP > 0 ? this.health / this.maxHP : 0;
-  }
-}
-// core/camera.ts
-class Camera {
-  x = 0;
-  y = 0;
-  width;
-  height;
-  constructor(width, height) {
-    this.width = width;
-    this.height = height;
-  }
-  follow(target) {
-    this.x = target.x;
-    this.y = target.y;
-  }
-  moveTo(target) {
-    this.x = target.x;
-    this.y = target.y;
-  }
-  getPosition() {
-    return { x: this.x, y: this.y };
-  }
-  getViewRect() {
-    return {
-      x: this.x - this.width / 2,
-      y: this.y - this.height / 2,
-      width: this.width,
-      height: this.height
-    };
-  }
-  resize(width, height) {
-    this.width = width;
-    this.height = height;
-  }
-}
-// core/game_object_register.ts
-class GameObjectRegister {
-  objects = new Map;
-  register(object) {
-    this.objects.set(object.id, object);
-  }
-  get(id) {
-    return this.objects.get(id);
-  }
-  has(id) {
-    return this.objects.has(id);
-  }
-  getAll(_filter) {
-    return Array.from(this.objects.values()).filter(_filter);
-  }
-  updateAll(deltaTime) {
-    this.getAll(() => true).forEach((obj) => {
-      obj.update(deltaTime);
-    });
-  }
-  renderAll(ctx) {
-    this.getAll(() => true).forEach((obj) => {
-      obj.render(ctx);
-    });
-  }
-}
-
-// core/world.ts
-class World {
-  colliders = new Set;
-  register(collider) {
-    this.colliders.add(collider);
-  }
-  unregister(collider) {
-    this.colliders.delete(collider);
-  }
-  detect() {
-    const list = Array.from(this.colliders);
-    const len = list.length;
-    for (let i = 0;i < len; i++) {
-      const obj = list[i];
-      if (!obj?.enabled)
-        continue;
-      for (let j = i + 1;j < len; j++) {
-        const other = list[j];
-        if (!other?.enabled)
-          continue;
-        if (obj.layer !== other.layer)
-          continue;
-        const objWantOther = this.tagsOverlap(obj.collidesWith, other.tags);
-        const otherWantObj = this.tagsOverlap(other.collidesWith, obj.tags);
-        const boundsObj = obj.getWorldBounds();
-        const boundsOther = other.getWorldBounds();
-        if (!this.intersects(obj, boundsObj, other, boundsOther))
-          continue;
-        if (obj.solid && other.solid) {
-          this.resolveOverlap(obj, boundsObj, other, boundsOther);
-        }
-        if (objWantOther && obj.onCollision) {
-          obj.onCollision({
-            self: obj.getOwner(),
-            other: other.getOwner(),
-            selfTags: obj.tags,
-            otherTags: other.tags
-          });
-        }
-        if (otherWantObj && other.onCollision) {
-          other.onCollision({
-            self: other.getOwner(),
-            other: obj.getOwner(),
-            selfTags: other.tags,
-            otherTags: obj.tags
-          });
-        }
-      }
-    }
-  }
-  tagsOverlap(wants, has) {
-    for (const tag of wants) {
-      if (has.has(tag))
-        return true;
-    }
-    return false;
-  }
-  intersects(a, boundsA, b, boundsB) {
-    const shapeA = a.shape;
-    const shapeB = b.shape;
-    if (shapeA.type === "aabb" && shapeB.type === "aabb") {
-      return this.aabbVSAabb(boundsA, boundsB);
-    }
-    if (shapeA.type === "circle" && shapeB.type === "circle") {
-      return this.circleVSCircle(a, boundsA, b, boundsB);
-    }
-    const [circle, circleBounds, rect] = shapeA.type === "circle" ? [a, boundsA, boundsB] : [b, boundsB, boundsA];
-    return this.circleVSAAabb(circle, circleBounds, rect);
-  }
-  aabbVSAabb(a, b) {
-    return a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
-  }
-  circleVSCircle(a, boundsA, b, boundsB) {
-    if (a.shape.type !== "circle" || b.shape.type !== "circle")
-      return false;
-    const cx1 = boundsA.x + a.shape.radius;
-    const cy1 = boundsA.y + a.shape.radius;
-    const cx2 = boundsB.x + b.shape.radius;
-    const cy2 = boundsB.y + b.shape.radius;
-    const dx = cx2 - cx1;
-    const dy = cy2 - cy1;
-    const distSq = dx * dx + dy * dy;
-    const radSum = a.shape.radius + b.shape.radius;
-    return distSq <= radSum * radSum;
-  }
-  circleVSAAabb(circle, circleBounds, rect) {
-    if (circle.shape.type !== "circle")
-      return false;
-    const cx = circleBounds.x + circle.shape.radius;
-    const cy = circleBounds.y + circle.shape.radius;
-    const closestX = Math.max(rect.x, Math.min(cx, rect.x + rect.width));
-    const closestY = Math.max(rect.y, Math.min(cy, rect.y + rect.height));
-    const dx = cx - closestX;
-    const dy = cy - closestY;
-    return dx * dx + dy * dy <= circle.shape.radius * circle.shape.radius;
-  }
-  resolveOverlap(a, boundsA, b, boundsB) {
-    const overlapX = Math.min(boundsA.x + boundsA.width - boundsB.x, boundsB.x + boundsB.width - boundsA.x);
-    const overlapY = Math.min(boundsA.y + boundsA.height - boundsB.y, boundsB.y + boundsB.height - boundsA.y);
-    let pushX = 0;
-    let pushY = 0;
-    if (overlapX < overlapY) {
-      pushX = boundsA.x < boundsB.x ? -overlapX : overlapX;
-    } else {
-      pushY = boundsA.y < boundsB.y ? -overlapY : overlapY;
-    }
-    const ownerA = a.getOwner();
-    const ownerB = b.getOwner();
-    if (a.fixed && b.fixed) {
-      return;
-    }
-    if (a.fixed) {
-      ownerB.x -= pushX;
-      ownerB.y -= pushY;
-    } else if (b.fixed) {
-      ownerA.x += pushX;
-      ownerA.y += pushY;
-    } else {
-      ownerA.x += pushX / 2;
-      ownerA.y += pushY / 2;
-      ownerB.x -= pushX / 2;
-      ownerB.y -= pushY / 2;
-    }
-  }
-}
-
-// core/engine.ts
-class Engine {
-  canvas;
-  ctx;
-  lastTime = 0;
-  width;
-  height;
-  _initialized = false;
-  running = false;
-  cnf = {
-    backgroundColor: "#000000"
-  };
-  _player;
-  engine;
-  constructor(canvasId, width, height, config) {
-    this.canvas = document.getElementById(canvasId);
-    this.height = height;
-    this.width = width;
-    this.canvas.width = width;
-    this.canvas.height = height;
-    const context = this.canvas.getContext("2d");
-    if (!context) {
-      throw new Error("Failed to get 2D context");
-    }
-    this.ctx = context;
-    this.cnf = { ...this.cnf, ...config };
-    this.engine = {
-      camera: new Camera(this.width, this.height),
-      objects: new GameObjectRegister,
-      collisions: new World
-    };
-  }
-  set player(player) {
-    this._player = player;
-  }
-  get player() {
-    return this._player;
-  }
-  get collisions() {
-    return this.engine.collisions;
-  }
-  attachObjects(objects) {
-    this.engine.objects.register(objects);
-  }
-  handleResize() {
-    if (!this.canvas)
-      return;
-    const container = this.canvas.parentElement;
-    if (!container)
-      return;
-    const containerWidth = container.clientWidth;
-    const containerHeight = container.clientHeight;
-    const scaleX = containerWidth / this.width;
-    const scaleY = containerHeight / this.height;
-    const scale = Math.min(scaleX, scaleY);
-    const offsetX = (containerWidth - this.width * scale) / 2;
-    const offsetY = (containerHeight - this.height * scale) / 2;
-    this.canvas.style.transform = `translate(${offsetX}px, ${offsetY}px) scale(${scale})`;
-  }
-  resize(width, height) {
-    this.canvas.width = width;
-    this.canvas.height = height;
-  }
-  loop(timestamp) {
-    if (!this.running) {
-      return;
-    }
-    if (this.lastTime === 0) {
-      this.lastTime = timestamp;
-    }
-    const deltaTime = (timestamp - this.lastTime) / 1000;
-    this.lastTime = timestamp;
-    this.update(deltaTime);
-    this.render();
-    requestAnimationFrame((timestamp2) => this.loop(timestamp2));
-  }
-  async setup(setupFn) {
-    if (this._initialized) {
-      console.warn("Engine is already initialized.");
-      return;
-    }
-    if (typeof setupFn !== "function") {
-      throw new Error("Setup function must be provided and must be a function.");
-    }
-    this.lastTime = 0;
-    setupFn();
-    this._initialized = true;
-    this.running = true;
-    requestAnimationFrame((timestamp) => this.loop(timestamp));
-  }
-  update(deltaTime) {
-    if (this.player) {
-      this.player.update(deltaTime);
-    }
-    if (this.engine.objects) {
-      this.engine.objects.updateAll(deltaTime);
-    }
-    this.engine.collisions.detect();
-    if (this.engine.camera && this.player) {
-      this.engine.camera.follow(this.player.getPosition());
-    }
-  }
-  render() {
-    this.ctx.clearRect(0, 0, this.width, this.height);
-    this.ctx.fillStyle = this.cnf.backgroundColor || "#000000";
-    this.ctx.fillRect(0, 0, this.width, this.height);
-    if (this.player) {
-      this.player.render(this.ctx);
-    }
-    if (this.engine.objects) {
-      this.engine.objects.renderAll(this.ctx);
-    }
-  }
-  pause() {
-    this.running = false;
-  }
-  clear() {
-    this.running = false;
-    this.ctx.clearRect(0, 0, this.width, this.height);
-  }
-  destroy() {}
-}
-// core/input.ts
-class Input {
-  keys = new Set;
-  mouseButtons = new Set;
-  mousePosition = { x: 0, y: 0 };
-  constructor() {
-    window.addEventListener("keydown", (e) => {
-      this.keys.add(e.key.toLowerCase());
-    });
-    window.addEventListener("keyup", (e) => {
-      this.keys.delete(e.key.toLowerCase());
-    });
-    window.addEventListener("mousedown", (e) => {
-      this.mouseButtons.add(e.button);
-    });
-    window.addEventListener("mouseup", (e) => {
-      this.mouseButtons.delete(e.button);
-    });
-    window.addEventListener("mousemove", (e) => {
-      this.mousePosition = { x: e.clientX, y: e.clientY };
-    });
-  }
-  isKeyDown(key) {
-    return this.keys.has(key.toLowerCase());
-  }
-  getPressedKeys() {
-    return new Set(this.keys);
-  }
-  isMouseButtonDown(button) {
-    return this.mouseButtons.has(button);
-  }
-  getMousePosition() {
-    return { ...this.mousePosition };
-  }
-  reset() {
-    this.keys.clear();
-    this.mouseButtons.clear();
-  }
-}
-// entities/entity.ts
-class Entity {
-  id = "";
-  position = { x: 0, y: 0 };
-  size = { width: 0, height: 0 };
-  behaviorMap = new Map;
-  _sortedBehaviors = null;
-  get x() {
-    return this.position.x;
-  }
-  set x(value) {
-    this.position.x = value;
-  }
-  get y() {
-    return this.position.y;
-  }
-  set y(value) {
-    this.position.y = value;
-  }
-  constructor(id, x, y, width, height) {
-    this.id = id;
-    this.position = { x, y };
-    this.size = { width, height };
-  }
-  getPosition() {
-    return { ...this.position };
-  }
-  getSize() {
-    return { ...this.size };
-  }
-  getBehaviour(key) {
-    return this.behaviorMap.get(key.toLowerCase());
-  }
-  getBehavioursByType(type) {
-    return this.behaviors.filter((b) => b instanceof type);
-  }
-  hasBehaviour(key) {
-    return this.behaviorMap.has(key.toLowerCase());
-  }
-  attachBehaviour(behavior) {
-    this.behaviorMap.set(behavior.key, behavior);
-    this._sortedBehaviors = null;
-    if (behavior.onAttach) {
-      behavior.onAttach();
-    }
-    return behavior;
-  }
-  detachBehaviour(key) {
-    const behavior = this.behaviorMap.get(key.toLowerCase());
-    if (!behavior)
-      return;
-    if (behavior.onDetach) {
-      behavior.onDetach();
-    }
-    this.behaviorMap.delete(key.toLowerCase());
-    this._sortedBehaviors = null;
-  }
-  get behaviors() {
-    if (!this._sortedBehaviors) {
-      this._sortedBehaviors = Array.from(this.behaviorMap.values()).sort((a, b) => a.priority - b.priority);
-    }
-    return this._sortedBehaviors;
-  }
-  updateBehaviours(deltaTime) {
-    for (const behavior of this.behaviors) {
-      if (behavior.enabled) {
-        behavior.update(deltaTime);
-      }
-    }
-  }
-  renderBehaviours(ctx) {
-    for (const behavior of this.behaviors) {
-      if (behavior.enabled && behavior.render) {
-        behavior.render(ctx);
-      }
-    }
-  }
-}
-
-// entities/dynamic_entity.ts
-class DynamicEntity extends Entity {
-  velocity = { x: 0, y: 0 };
-  speed = 0;
-  setVelocity(velocity) {
-    this.velocity = velocity;
-  }
-  getVelocity() {
-    return { ...this.velocity };
-  }
-  setSpeed(speed) {
-    this.speed = speed;
-  }
-  getSpeed() {
-    return this.speed;
-  }
-}
-// entities/player.ts
-class Player extends DynamicEntity {
-  get control() {
-    return this.getBehaviour("control");
-  }
-  get healthkit() {
-    return this.getBehaviour("healthkit");
-  }
-  update(deltaTime) {
-    this.updateBehaviours(deltaTime);
-  }
-  render(ctx) {
-    ctx.fillStyle = "blue";
-    ctx.fillRect(this.x, this.y, this.size.width, this.size.height);
-    this.renderBehaviours(ctx);
-  }
-}
 export {
-  World,
-  Player,
-  Input,
+  log,
+  default11 as World,
+  default16 as Text,
+  default3 as SpriteRender,
+  default10 as Sprite,
+  default15 as Player,
+  PerlinNoise,
+  ObjectSystem,
+  MonitorSystem,
+  default12 as Monitor,
+  default9 as Input,
   HealthKit,
-  GameObjectRegister,
-  Entity,
-  Engine,
-  DynamicEntity,
+  default8 as GameObjectRegister,
+  default7 as FontBitmapPrebuild,
+  default6 as FontBitmap,
+  default14 as Entity,
+  default5 as Engine,
+  default13 as DynamicEntity,
   Control,
+  CollisionSystem,
   Collidable,
-  Camera,
-  Behaviour
+  CameraSystem,
+  default4 as Camera,
+  Behaviour,
+  default2 as Asset
 };
 
-//# debugId=AC6FB9916B04E31F64756E2164756E21
+//# debugId=B36FB65262DD014964756E2164756E21