@dryanovski/gamefoo 0.0.1 → 0.2.1

package/dist/core/animate.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Frame-based sprite animation controller.
+ *
+ * `Animate` steps through a sequence of spritesheet cells at a given
+ * frame rate. It tracks elapsed time internally and advances the
+ * current frame index each time the interval elapses.
+ *
+ * > **Note:** The {@link Animate.draw} method is currently a stub —
+ * > it resolves the correct frame but does not yet perform the actual
+ * > `drawImage` call.  Use {@link SpriteRender} for production
+ * > sprite rendering.
+ *
+ * @category Core
+ * @since 0.1.0
+ *
+ * @example Creating a walk animation
+ * ```ts
+ * const walkFrames = [
+ *   { col: 0, row: 0 },
+ *   { col: 1, row: 0 },
+ *   { col: 2, row: 0 },
+ *   { col: 3, row: 0 },
+ * ];
+ *
+ * const anim = new Animate("walk", walkFrames, 32, 32, 12);
+ * ```
+ *
+ * @example Updating in a game loop
+ * ```ts
+ * function update(delta: number) {
+ *   anim.update(delta);
+ *   anim.draw(ctx, entity.x, entity.y);
+ * }
+ * ```
+ *
+ * @see {@link SpriteRender} — behaviour-based alternative for entity rendering
+ * @see {@link Sprite}       — spritesheet metadata container
+ */
+export default class Animate {
+    /** Identifier for this animation (e.g. `"walk"`, `"idle"`). */
+    private key;
+    /** Ordered list of spritesheet cells that make up the animation. */
+    private frames;
+    /** Width of a single frame in pixels. */
+    private frameW;
+    /** Height of a single frame in pixels. */
+    private frameH;
+    /**
+     * Index into {@link Animate.frames} of the frame currently being
+     * displayed.
+     *
+     * @defaultValue `0`
+     */
+    private currentFrame;
+    /**
+     * Milliseconds accumulated since the last frame advance.
+     *
+     * @defaultValue `0`
+     */
+    private elapsed;
+    /** Computed time between frames in milliseconds (`1000 / fps`). */
+    private interval;
+    /** Playback speed in frames per second. */
+    private fps;
+    /**
+     * Creates a new animation sequence.
+     *
+     * @param key    - A unique name for this animation (used as a look-up key).
+     * @param frames - An ordered array of `{ col, row }` cells from the
+     *   spritesheet.
+     * @param frameW - Width of each frame in pixels.
+     * @param frameH - Height of each frame in pixels.
+     * @param fps    - Playback speed in frames per second.
+     *
+     * @example
+     * ```ts
+     * const idle = new Animate(
+     *   "idle",
+     *   [{ col: 0, row: 1 }, { col: 1, row: 1 }],
+     *   64, 64,
+     *   8,
+     * );
+     * ```
+     */
+    constructor(key: string, frames: {
+        col: number;
+        row: number;
+    }[], frameW: number, frameH: number, fps: number);
+    /**
+     * Advances the animation clock and moves to the next frame when the
+     * interval has elapsed.
+     *
+     * @param delta - Time elapsed since the last call, **in milliseconds**.
+     *
+     * @example
+     * ```ts
+     * // Inside a requestAnimationFrame loop:
+     * anim.update(deltaMs);
+     * ```
+     */
+    update(delta: number): void;
+    /**
+     * Draws the current animation frame to the canvas.
+     *
+     * @remarks
+     * This method is currently a **stub**. It resolves the correct
+     * `{ col, row }` cell but does not perform the actual
+     * `ctx.drawImage()` call. Wire it to {@link Asset} or use
+     * {@link SpriteRender} for full rendering.
+     *
+     * @param _ctx   - The canvas 2-D rendering context.
+     * @param _destX - Destination X coordinate on the canvas.
+     * @param _destY - Destination Y coordinate on the canvas.
+     */
+    draw(_ctx: CanvasRenderingContext2D, _destX: number, _destY: number): void;
+    /**
+     * Resets the animation to its first frame.
+     *
+     * Call this when switching animations or restarting a sequence.
+     *
+     * @example
+     * ```ts
+     * anim.reset();
+     * anim.update(0); // ensures frame 0 is active
+     * ```
+     */
+    reset(): void;
+}
+//# sourceMappingURL=animate.d.ts.map

package/dist/core/animate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animate.d.ts","sourceRoot":"","sources":["../../src/core/animate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,CAAC,OAAO,OAAO,OAAO;IAC1B,+DAA+D;IAC/D,OAAO,CAAC,GAAG,CAAS;IAEpB,oEAAoE;IACpE,OAAO,CAAC,MAAM,CAAiC;IAE/C,yCAAyC;IACzC,OAAO,CAAC,MAAM,CAAS;IAEvB,0CAA0C;IAC1C,OAAO,CAAC,MAAM,CAAS;IAEvB;;;;;OAKG;IACH,OAAO,CAAC,YAAY,CAAa;IAEjC;;;;OAIG;IACH,OAAO,CAAC,OAAO,CAAK;IAEpB,mEAAmE;IACnE,OAAO,CAAC,QAAQ,CAAS;IAEzB,2CAA2C;IAC3C,OAAO,CAAC,GAAG,CAAS;IAEpB;;;;;;;;;;;;;;;;;;;OAmBG;gBACS,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAU5G;;;;;;;;;;;OAWG;IACI,MAAM,CAAC,KAAK,EAAE,MAAM;IAS3B;;;;;;;;;;;;OAYG;IACI,IAAI,CAAC,IAAI,EAAE,wBAAwB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAO1E;;;;;;;;;;OAUG;IACI,KAAK;CAIb"}

package/dist/core/asset.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Static image asset loader with an in-memory cache.
+ *
+ * `Asset` wraps the native `Image` constructor with a `Promise`-based
+ * API and caches loaded images by URL so repeated requests for the same
+ * source resolve instantly.
+ *
+ * @category Core
+ * @since 0.1.0
+ *
+ * @example Loading an image
+ * ```ts
+ * const image = await Asset.load("sprites/hero.png");
+ * ctx.drawImage(image, 0, 0);
+ * ```
+ *
+ * @example Pre-loading multiple assets
+ * ```ts
+ * await Promise.all([
+ *   Asset.load("sprites/hero.png"),
+ *   Asset.load("sprites/enemy.png"),
+ *   Asset.load("tiles/grass.png"),
+ * ]);
+ * ```
+ *
+ * @see {@link Sprite} — consumes loaded images for spritesheet slicing
+ */
+export default class Asset {
+    /**
+     * Internal cache mapping source URLs to their loaded
+     * `HTMLImageElement` instances.
+     */
+    private static cache;
+    /**
+     * Loads an image from the given URL.
+     *
+     * If the image has been loaded before, the cached `HTMLImageElement`
+     * is returned immediately (the `Promise` resolves synchronously on
+     * the microtask queue).
+     *
+     * @param src - URL or relative path of the image to load.
+     * @returns A `Promise` that resolves with the loaded
+     *   `HTMLImageElement`.
+     *
+     * @throws {Error} If the image fails to load (e.g. 404 or network
+     *   error). The error message includes the failing `src`.
+     *
+     * @example
+     * ```ts
+     * try {
+     *   const img = await Asset.load("missing.png");
+     * } catch (err) {
+     *   console.error(err); // "Failed to load image: missing.png"
+     * }
+     * ```
+     */
+    static load(src: string): Promise<HTMLImageElement>;
+}
+//# sourceMappingURL=asset.d.ts.map

package/dist/core/asset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asset.d.ts","sourceRoot":"","sources":["../../src/core/asset.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,OAAO,OAAO,KAAK;IACxB;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,KAAK,CAA4C;IAEhE;;;;;;;;;;;;;;;;;;;;;;OAsBG;WACU,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAkB1D"}

package/dist/core/behaviour.d.ts

@@ -1,14 +1,132 @@
 import type Entity from "../entities/entity";
+/**
+ * Abstract base class for all entity behaviours in the GameFoo engine.
+ *
+ * A **behaviour** is a self-contained unit of logic (input handling,
+ * collision response, health tracking, rendering, etc.) that can be
+ * attached to any {@link Entity} at runtime via
+ * {@link Entity.attachBehaviour}.
+ *
+ * Subclasses **must** implement:
+ * - {@link Behaviour.type | type} — a unique string identifier (e.g. `"control"`, `"healthkit"`).
+ * - {@link Behaviour.update | update} — called once per frame with `deltaTime`.
+ *
+ * Subclasses **may** override:
+ * - {@link Behaviour.render | render} — draw debug visuals or overlays.
+ * - {@link Behaviour.onAttach | onAttach} — setup hook when added to an entity.
+ * - {@link Behaviour.onDetach | onDetach} — teardown hook when removed.
+ *
+ * @typeParam T - The entity type this behaviour operates on.
+ *   Defaults to {@link Entity}; narrow it to {@link DynamicEntity} or
+ *   {@link Player} when the behaviour needs velocity, speed, etc.
+ *
+ * @category Behaviours
+ * @since 0.1.0
+ *
+ * @example Creating a custom behaviour
+ * ```ts
+ * import { Behaviour, type Entity } from "gamefoo";
+ *
+ * class Gravity extends Behaviour<Entity> {
+ *   readonly type = "gravity";
+ *
+ *   update(deltaTime: number): void {
+ *     this.owner.y += 9.8 * 60 * deltaTime;
+ *   }
+ * }
+ * ```
+ *
+ * @example Attaching to an entity
+ * ```ts
+ * const entity = new Player("hero", 100, 100, 32, 32);
+ * entity.attachBehaviour(new Gravity(entity));
+ * ```
+ *
+ * @see {@link Entity.attachBehaviour}
+ * @see {@link Entity.detachBehaviour}
+ */
 export declare abstract class Behaviour<T extends Entity = Entity> {
+    /**
+     * Reference to the entity that owns this behaviour.
+     * Available to subclasses for reading and mutating entity state.
+     */
     protected owner: T;
+    /**
+     * Unique string identifier for this behaviour type.
+     *
+     * Used as the look-up key in {@link Entity.getBehaviour} and
+     * {@link Entity.hasBehaviour}. Must be a compile-time constant
+     * (`readonly`).
+     *
+     * @example
+     * ```ts
+     * class Gravity extends Behaviour {
+     *   readonly type = "gravity";
+     *   // ...
+     * }
+     * ```
+     */
     abstract readonly type: string;
+    /**
+     * Execution priority — lower numbers run first.
+     *
+     * When an entity has multiple behaviours, they are sorted by priority
+     * before each update/render pass.
+     *
+     * @defaultValue `1`
+     */
     priority: number;
+    /**
+     * Whether this behaviour is currently active.
+     *
+     * Disabled behaviours are skipped during both
+     * {@link Entity.updateBehaviours} and {@link Entity.renderBehaviours}.
+     *
+     * @defaultValue `true`
+     */
     enabled: boolean;
+    /**
+     * Derived look-up key, equal to {@link Behaviour.type} in lowercase.
+     *
+     * Used internally by the entity's behaviour map so that look-ups are
+     * case-insensitive.
+     */
     get key(): string;
+    /**
+     * Creates a new behaviour bound to the given entity.
+     *
+     * @param owner - The entity this behaviour will operate on.
+     */
     constructor(owner: T);
+    /**
+     * Called once per frame to advance this behaviour's logic.
+     *
+     * @param deltaTime - Seconds elapsed since the previous frame.
+     */
     abstract update(deltaTime: number): void;
+    /**
+     * Optional rendering hook invoked after the entity's own
+     * {@link Entity.render} call.
+     *
+     * Override this to draw debug shapes, health bars, status effects, etc.
+     *
+     * @param ctx - The canvas 2-D rendering context.
+     */
     render?(ctx: CanvasRenderingContext2D): void;
+    /**
+     * Lifecycle hook called immediately after the behaviour is attached
+     * to an entity via {@link Entity.attachBehaviour}.
+     *
+     * Use this for one-time setup such as registering with the
+     * collision {@link World}.
+     */
     onAttach?(): void;
+    /**
+     * Lifecycle hook called when the behaviour is removed from an entity
+     * via {@link Entity.detachBehaviour}.
+     *
+     * Use this to unregister from external systems or release resources.
+     */
     onDetach?(): void;
 }
 //# sourceMappingURL=behaviour.d.ts.map

package/dist/core/behaviour.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"behaviour.d.ts","sourceRoot":"","sources":["../../core/behaviour.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,oBAAoB,CAAC;AAE7C,8BAAsB,SAAS,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACvD,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC;IAEnB,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAExB,QAAQ,EAAE,MAAM,CAAK;IAErB,OAAO,EAAE,OAAO,CAAQ;IAE/B,IAAI,GAAG,IAAI,MAAM,CAEhB;gBAEW,KAAK,EAAE,CAAC;IAIpB,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAExC,MAAM,CAAC,CAAC,GAAG,EAAE,wBAAwB,GAAG,IAAI;IAC5C,QAAQ,CAAC,IAAI,IAAI;IACjB,QAAQ,CAAC,IAAI,IAAI;CAClB"}
+{"version":3,"file":"behaviour.d.ts","sourceRoot":"","sources":["../../src/core/behaviour.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,oBAAoB,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,8BAAsB,SAAS,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACvD;;;OAGG;IACH,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC;IAEnB;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAE/B;;;;;;;OAOG;IACI,QAAQ,EAAE,MAAM,CAAK;IAE5B;;;;;;;OAOG;IACI,OAAO,EAAE,OAAO,CAAQ;IAE/B;;;;;OAKG;IACH,IAAI,GAAG,IAAI,MAAM,CAEhB;IAED;;;;OAIG;gBACS,KAAK,EAAE,CAAC;IAIpB;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAExC;;;;;;;OAOG;IACH,MAAM,CAAC,CAAC,GAAG,EAAE,wBAAwB,GAAG,IAAI;IAE5C;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,IAAI;IAEjB;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,IAAI;CAClB"}

package/dist/core/behaviours/collidable.d.ts

@@ -1,32 +1,231 @@
-import type DynamicEntity from "../../entities/dynamic_entity";
 import type Entity from "../../entities/entity";
-import type { ColliderShape, CollisionInfo, WorldBounds } from "../../types";
+import type { ColliderShape, CollisionInfo, GameObject, WorldBounds } from "../../types";
 import { Behaviour } from "../behaviour";
 import type World from "../world";
+/**
+ * Options for constructing a {@link Collidable} behaviour.
+ *
+ * Every field except `shape` is optional and has a sensible default.
+ *
+ * @category Behaviours
+ * @since 0.1.0
+ *
+ * @example Minimal options
+ * ```ts
+ * const opts: CollidableOptions = {
+ *   shape: { type: "aabb", width: 32, height: 32 },
+ * };
+ * ```
+ *
+ * @example Full options
+ * ```ts
+ * const opts: CollidableOptions = {
+ *   shape: { type: "circle", radius: 16 },
+ *   layer: 0,
+ *   tags: new Set(["enemy"]),
+ *   solid: true,
+ *   fixed: false,
+ *   collidesWith: new Set(["player", "bullet"]),
+ *   onCollision: (info) => console.log("hit!", info.other.id),
+ * };
+ * ```
+ */
 type CollidableOptions = {
+    /**
+     * The geometric shape used for intersection tests.
+     *
+     * @see {@link ColliderShape}
+     */
     shape: ColliderShape;
+    /**
+     * Collision layer index. Only colliders on the **same** layer are
+     * tested against each other.
+     *
+     * @defaultValue `0`
+     */
     layer?: number;
+    /**
+     * Tags that identify *this* collider (e.g. `"player"`, `"bullet"`).
+     *
+     * @defaultValue empty `Set`
+     */
     tags?: Set<string>;
+    /**
+     * Tags this collider is **interested in**. The `onCollision` callback
+     * only fires when the other collider has at least one matching tag.
+     *
+     * @defaultValue empty `Set`
+     */
     collidesWith?: Set<string>;
+    /**
+     * Whether overlap resolution should be applied when this collider
+     * intersects another solid collider.
+     *
+     * @defaultValue `false`
+     */
     solid?: boolean;
+    /**
+     * If `true`, this collider is treated as immovable during overlap
+     * resolution — the other entity absorbs the full displacement.
+     *
+     * @defaultValue `false`
+     */
     fixed?: boolean;
+    /**
+     * Callback invoked when a collision with a tag-matched collider is
+     * detected.
+     *
+     * @param info - Details about the collision, including both entities
+     *   and their tag sets.
+     *
+     * @see {@link CollisionInfo}
+     */
     onCollision?: (info: CollisionInfo) => void;
 };
-export declare class Collidable extends Behaviour<DynamicEntity> {
+/**
+ * Collision behaviour that can be attached to any {@link Entity}.
+ *
+ * When attached, the `Collidable` automatically registers itself with
+ * the engine's {@link World} (via {@link Collidable.onAttach}) and
+ * unregisters on detach. Each frame the `World` queries the collider's
+ * shape, bounds, and tags to determine intersections.
+ *
+ * @category Behaviours
+ * @since 0.1.0
+ *
+ * @example Creating and attaching a box collider
+ * ```ts
+ * import { Collidable, Entity, type CollisionInfo } from "gamefoo";
+ *
+ * const entity = new Enemy("goblin", 100, 200, 30, 30);
+ *
+ * entity.attachBehaviour(
+ *   new Collidable(entity, engine.collisions, {
+ *     shape: { type: "aabb", width: 30, height: 30 },
+ *     layer: 0,
+ *     tags: new Set(["enemy"]),
+ *     solid: true,
+ *     collidesWith: new Set(["player"]),
+ *     onCollision: (info: CollisionInfo) => {
+ *       console.log(`${info.self.id} hit ${info.other.id}`);
+ *     },
+ *   }),
+ * );
+ * ```
+ *
+ * @example Circle collider for a projectile
+ * ```ts
+ * entity.attachBehaviour(
+ *   new Collidable(bullet, engine.collisions, {
+ *     shape: { type: "circle", radius: 4 },
+ *     tags: new Set(["bullet"]),
+ *     collidesWith: new Set(["enemy"]),
+ *   }),
+ * );
+ * ```
+ *
+ * @see {@link World}          — the collision detection system
+ * @see {@link ColliderShape}  — supported shape types
+ * @see {@link CollisionInfo}  — payload delivered to callbacks
+ * @see {@link Behaviour}      — abstract base class
+ */
+export declare class Collidable extends Behaviour<GameObject> {
+    /** @inheritDoc */
     readonly type = "collidable";
+    /**
+     * Geometric shape used for intersection tests.
+     *
+     * @see {@link ColliderShape}
+     */
     shape: ColliderShape;
+    /**
+     * Collision layer. Only colliders sharing the same layer value are
+     * tested.
+     *
+     * @defaultValue `0`
+     */
     layer: number;
+    /**
+     * Tags identifying this collider (e.g. `"player"`, `"enemy"`).
+     *
+     * @defaultValue empty `Set`
+     */
     tags: Set<string>;
+    /**
+     * Tags this collider wants to be notified about.
+     *
+     * @defaultValue empty `Set`
+     */
     collidesWith: Set<string>;
+    /**
+     * Whether this collider participates in overlap resolution.
+     *
+     * @defaultValue `false`
+     */
     solid: boolean;
+    /**
+     * Whether the owning entity is immovable during overlap resolution.
+     *
+     * @defaultValue `false`
+     */
     fixed: boolean;
+    /**
+     * User-supplied callback invoked when a tag-matched collision is
+     * detected.
+     */
     onCollision: (info: CollisionInfo) => void;
+    /** Reference to the {@link World} this collider is registered with. */
     private world;
-    constructor(owner: DynamicEntity, world: World, options: CollidableOptions);
+    /**
+     * Creates a new collidable behaviour.
+     *
+     * @param owner   - The game object entity that owns this collider.
+     * @param world   - The collision {@link World} to register with.
+     * @param options - Configuration for shape, tags, solidity, and
+     *   callbacks. See {@link CollidableOptions}.
+     */
+    constructor(owner: GameObject, world: World, options: CollidableOptions);
+    /**
+     * No-op — collision logic lives in {@link World.detect}.
+     *
+     * @param _deltaTime - Unused.
+     */
     update(_deltaTime: number): void;
+    /**
+     * Lifecycle hook: registers this collider with the {@link World}
+     * when the behaviour is attached to an entity.
+     *
+     * @see {@link Behaviour.onAttach}
+     */
     onAttach(): void;
+    /**
+     * Lifecycle hook: removes this collider from the {@link World}
+     * when the behaviour is detached.
+     *
+     * @see {@link Behaviour.onDetach}
+     */
     onDetach(): void;
+    /**
+     * Returns the {@link Entity} that owns this behaviour.
+     *
+     * Used by the {@link World} to read and mutate entity position
+     * during overlap resolution.
+     *
+     * @returns The owning entity.
+     */
     getOwner(): Entity;
+    /**
+     * Computes this collider's axis-aligned bounding rectangle in
+     * world-space, accounting for the shape's optional offset.
+     *
+     * @returns A {@link WorldBounds} rectangle.
+     *
+     * @example
+     * ```ts
+     * const bounds = collidable.getWorldBounds();
+     * // { x: 100, y: 200, width: 30, height: 30 }
+     * ```
+     */
     getWorldBounds(): WorldBounds;
 }
 export {};

package/dist/core/behaviours/collidable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collidable.d.ts","sourceRoot":"","sources":["../../../core/behaviours/collidable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,aAAa,MAAM,+BAA+B,CAAC;AAC/D,OAAO,KAAK,MAAM,MAAM,uBAAuB,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC7E,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,KAAK,MAAM,UAAU,CAAC;AAElC,KAAK,iBAAiB,GAAG;IACvB,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACnB,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC;CAC7C,CAAC;AAEF,qBAAa,UAAW,SAAQ,SAAS,CAAC,aAAa,CAAC;IACtD,QAAQ,CAAC,IAAI,gBAAgB;IAEtB,KAAK,EAAE,aAAa,CAAC;IAErB,KAAK,EAAE,MAAM,CAAK;IAElB,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,CAAa;IAE9B,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAa;IAEtC,KAAK,EAAE,OAAO,CAAS;IAEvB,KAAK,EAAE,OAAO,CAAS;IAEvB,WAAW,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC;IAElD,OAAO,CAAC,KAAK,CAAQ;gBAET,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,iBAAiB;IAqB1E,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAEvB,QAAQ,IAAI,IAAI;IAIhB,QAAQ,IAAI,IAAI;IAIzB,QAAQ,IAAI,MAAM;IAIlB,cAAc,IAAI,WAAW;CAqB9B"}
+{"version":3,"file":"collidable.d.ts","sourceRoot":"","sources":["../../../src/core/behaviours/collidable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,uBAAuB,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACzF,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,KAAK,MAAM,UAAU,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,KAAK,iBAAiB,GAAG;IACvB;;;;OAIG;IACH,KAAK,EAAE,aAAa,CAAC;IAErB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;OAIG;IACH,IAAI,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAEnB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE3B;;;;;OAKG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC;CAC7C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,qBAAa,UAAW,SAAQ,SAAS,CAAC,UAAU,CAAC;IACnD,kBAAkB;IAClB,QAAQ,CAAC,IAAI,gBAAgB;IAE7B;;;;OAIG;IACI,KAAK,EAAE,aAAa,CAAC;IAE5B;;;;;OAKG;IACI,KAAK,EAAE,MAAM,CAAK;IAEzB;;;;OAIG;IACI,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,CAAa;IAErC;;;;OAIG;IACI,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAa;IAE7C;;;;OAIG;IACI,KAAK,EAAE,OAAO,CAAS;IAE9B;;;;OAIG;IACI,KAAK,EAAE,OAAO,CAAS;IAE9B;;;OAGG;IACI,WAAW,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC;IAElD,uEAAuE;IACvE,OAAO,CAAC,KAAK,CAAQ;IAErB;;;;;;;OAOG;gBACS,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,iBAAiB;IAoBvE;;;;OAIG;IACH,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAEhC;;;;;OAKG;IACM,QAAQ,IAAI,IAAI;IAIzB;;;;;OAKG;IACM,QAAQ,IAAI,IAAI;IAIzB;;;;;;;OAOG;IACH,QAAQ,IAAI,MAAM;IAIlB;;;;;;;;;;;OAWG;IACH,cAAc,IAAI,WAAW;CAqB9B"}

package/dist/core/behaviours/control.d.ts

@@ -1,11 +1,59 @@
-import type DynamicEntity from "../../entities/dynamic_entity";
+import type Entity from "../../entities/entity";
 import { Behaviour } from "../behaviour";
 import type Input from "../input";
-export declare class Control extends Behaviour<DynamicEntity> {
+/**
+ * Keyboard-driven movement behaviour for a {@link Entity}.
+ *
+ * `Control` reads the current keyboard state from an {@link Input}
+ * instance every frame and translates WASD / arrow-key presses into
+ * entity position changes. Diagonal movement is normalised so the
+ * entity moves at a consistent speed in all directions.
+ *
+ * @category Behaviours
+ * @since 0.1.0
+ *
+ * @example Attaching to a player
+ * ```ts
+ * import { Control, Input, Player } from "gamefoo";
+ *
+ * const input  = new Input();
+ * const player = new Player("hero", 400, 300, 50, 50);
+ *
+ * player.attachBehaviour(new Control(player, input));
+ * ```
+ *
+ * @see {@link Input}     — the polling input manager consumed by this behaviour
+ * @see {@link Behaviour} — abstract base class
+ */
+export declare class Control extends Behaviour<Entity> {
+    /** @inheritDoc */
     readonly type = "control";
+    /** The input manager to poll each frame. */
     private input;
+    /**
+     * Movement speed in pixels per second.
+     *
+     * @defaultValue `500`
+     */
     private speed;
-    constructor(owner: DynamicEntity, input: Input);
+    /**
+     * Creates a new keyboard control behaviour.
+     *
+     * @param owner - The game object entity whose position will be updated.
+     * @param input - The {@link Input} instance to read key state from.
+     */
+    constructor(owner: Entity, input: Input);
+    /**
+     * Reads the current key state and moves the owner entity.
+     *
+     * Supported keys: `W` / `ArrowUp`, `S` / `ArrowDown`,
+     * `A` / `ArrowLeft`, `D` / `ArrowRight`.
+     *
+     * Diagonal input is normalised so the effective speed remains
+     * constant regardless of direction.
+     *
+     * @param deltaTime - Seconds elapsed since the previous frame.
+     */
     update(deltaTime: number): void;
 }
 //# sourceMappingURL=control.d.ts.map

package/dist/core/behaviours/control.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"control.d.ts","sourceRoot":"","sources":["../../../core/behaviours/control.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,aAAa,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,KAAK,MAAM,UAAU,CAAC;AAElC,qBAAa,OAAQ,SAAQ,SAAS,CAAC,aAAa,CAAC;IACnD,QAAQ,CAAC,IAAI,aAAa;IAE1B,OAAO,CAAC,KAAK,CAAQ;IAErB,OAAO,CAAC,KAAK,CAAe;gBAEhB,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,KAAK;IAK9C,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;CAgBhC"}
+{"version":3,"file":"control.d.ts","sourceRoot":"","sources":["../../../src/core/behaviours/control.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,KAAK,MAAM,UAAU,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,OAAQ,SAAQ,SAAS,CAAC,MAAM,CAAC;IAC5C,kBAAkB;IAClB,QAAQ,CAAC,IAAI,aAAa;IAE1B,4CAA4C;IAC5C,OAAO,CAAC,KAAK,CAAQ;IAErB;;;;OAIG;IACH,OAAO,CAAC,KAAK,CAAe;IAE5B;;;;;OAKG;gBACS,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK;IAKvC;;;;;;;;;;OAUG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;CAehC"}