@datamoc/mw_games 0.43.0 → 0.45.0

package/dist/roguelike/Targeting.d.ts

@@ -1,312 +0,0 @@
-import type { Level } from './Level.ts';
-import type { Step } from './Pathfinder.ts';
-import { Signal } from '../core/Signal.ts';
-/**
- * How a target resolves into the cells it actually affects.
- *
- * `single` is a dagger throw or a bolt from a wand - only the cell aimed at. `burst` is an
- * explosion or a cloud, centred on the target rather than the thrower. `line` is a beam or a
- * spear thrust - everything between thrower and target, not just where it lands. `cone` is a
- * breath or a spray - widening with distance along the aim direction, `width` counting how
- * many cells wide the far end is.
- */
-export type AreaShape = {
-    kind: 'single';
-} | {
-    kind: 'burst';
-    radius: number;
-} | {
-    kind: 'line';
-} | {
-    kind: 'cone';
-    width: number;
-};
-export interface TargetingOptions {
-    /** how far the aim can reach, in cells (Chebyshev distance - the usual roguelike ruler) */
-    range: number;
-    /** whether a wall in the way blocks the shot; on by default, since most things do not arc */
-    requireLineOfSight?: boolean;
-}
-/**
- * The straight-line ruler distance a roguelike uses: diagonals cost the same as a step.
- *
- * @example
- * ```ts
- * import { chebyshevDistance, traceLine, hasLineOfSight, canTarget, resolveArea, Level, WALL, FLOOR } from '@datamoc/mw_games/roguelike';
- *
- * const level = new Level(20, 20, [WALL, FLOOR], 1); // an open floor
- * const origin = { x: 2, y: 2 };
- * const target = { x: 8, y: 5 };
- *
- * chebyshevDistance(origin, target); // 6
- * traceLine(origin, target); // every cell the shot crosses
- * hasLineOfSight(level, origin, target); // true - nothing blocks it
- *
- * if (canTarget(level, origin, target, { range: 10 })) {
- *   const hit = resolveArea(origin, target, { kind: 'burst', radius: 2 });
- * }
- * ```
- */
-export declare function chebyshevDistance(a: Step, b: Step): number;
-/**
- * Every cell a straight line crosses from `from` to `to`, `from` included and `to` included.
- *
- * Bresenham's algorithm, not a shadowcast: this answers "what is on the way to this exact
- * point", which is what aiming needs. `FieldOfView` answers "what can be seen from here at
- * all", a different question with a different (and pricier) algorithm.
- */
-export declare function traceLine(from: Step, to: Step): Step[];
-export type BallisticaStop = 'opaque' | 'impassable' | 'outside' | 'none';
-export interface BallisticaOptions {
-    /** what ends the path; the stopping cell is included in `cells` */
-    stop?: BallisticaStop;
-}
-export interface BallisticaResult {
-    /** cells from origin through the target or first stopping cell */
-    cells: Step[];
-    /** the first cell that satisfied `stop`, or null when the path reached its target */
-    stop: Step | null;
-}
-/**
- * Traces a projectile-like path through a level and reports its first collision.
- *
- * Unlike `traceLine`, this understands the level topology and terrain. `opaque` is the
- * default for beams and sight, `impassable` is useful for movement and projectiles that can
- * cross transparent walls, and `outside` is useful when the requested target may be off-map.
- * The collision cell is included in `cells`, so a caller can apply an impact there before
- * deciding what the game should do with it.
- *
- * @example
- * ```ts
- * import { ballistica, Level, WALL, FLOOR } from '@datamoc/mw_games/roguelike';
- *
- * const level = new Level(10, 1, [WALL, FLOOR], 1);
- * const result = ballistica(level, { x: 0, y: 0 }, { x: 9, y: 0 }, { stop: 'opaque' });
- * console.log(result.cells, result.stop); // path and first blocking cell, if any
- * ```
- */
-export declare function ballistica(level: Level, from: Step, to: Step, options?: BallisticaOptions): BallisticaResult;
-/** true when nothing between `from` and `to` (both cells themselves excepted) blocks sight */
-export declare function hasLineOfSight(level: Level, from: Step, to: Step): boolean;
-/** whether `target` is a legal aim point from `origin`: in range, and in sight unless waived */
-export declare function canTarget(level: Level, origin: Step, target: Step, options: TargetingOptions): boolean;
-/** the cells a shape actually affects, once aimed at `target` from `origin` */
-export declare function resolveArea(origin: Step, target: Step, shape: AreaShape): Step[];
-/**
- * Resolves an area using the level's topology, including hex lines, cones and bursts.
- *
- * @example
- * ```ts
- * import { Level, FLOOR, resolveAreaOnLevel } from '@datamoc/mw_games/roguelike';
- * const level = new Level(8, 8, [{ passable: true, transparent: true }, FLOOR], 1, 'hex');
- * const cells = resolveAreaOnLevel(level, { x: 2, y: 2 }, { x: 4, y: 2 }, { kind: 'line' });
- * ```
- */
-export declare function resolveAreaOnLevel(level: Level, origin: Step, target: Step, shape: AreaShape): Step[];
-/**
- * A widening hex-grid cone, with `width` extra cells on each side at its far end.
- *
- * @example
- * ```ts
- * import { hexConeCells } from '@datamoc/mw_games/roguelike';
- * const cells = hexConeCells({ x: 2, y: 2 }, { x: 5, y: 2 }, 2);
- * ```
- */
-export declare function hexConeCells(origin: Step, target: Step, width: number): Step[];
-/**
- * Every cell in a widening spray from `origin` towards `target`: the aim snaps to the
- * nearest of the 8 directions, the length is the distance aimed, and step `i` of `length`
- * spans `round(i / length * width)` cells to each side of the centre line. A width of 0
- * is a single-file beam, the same cells `line` would trace along that snapped direction.
- *
- * @example
- * ```ts
- * import { coneCells, chainTargets, knockbackPath, Level, WALL, FLOOR } from '@datamoc/mw_games/roguelike';
- *
- * const breath = coneCells({ x: 5, y: 5 }, { x: 5, y: 0 }, 3); // a dragon's breath, aimed north
- *
- * const monsters = [{ x: 5, y: 4 }, { x: 5, y: 3 }, { x: 6, y: 2 }];
- * const arc = chainTargets(monsters, { x: 5, y: 5 }, 3, 2); // a lightning bolt hopping between them
- *
- * const level = new Level(20, 20, [WALL, FLOOR], 1);
- * const shovedTo = knockbackPath(level, { x: 5, y: 5 }, { x: 1, y: 0 }, 3); // shoved 3 cells east
- * ```
- */
-export declare function coneCells(origin: Step, target: Step, width: number): Step[];
-export interface ConeSectorOptions {
-    /** the full angle of the sector, in degrees; 0 is a single ray along the aim */
-    degrees: number;
-    /** how far a ray reaches, in cells */
-    range: number;
-    /**
-     * What ends a ray. The default `opaque` is what makes a wall stop the part of the cone
-     * behind it, which is the difference between a breath weapon and a laser through walls.
-     */
-    stop?: BallisticaStop;
-}
-/**
- * Every cell inside a circular sector: an arc of `degrees` centred on the aim, rays cast
- * across it every 0.5 degrees, each ray clamped to `range` and stopped by a wall. The union
- * of those rays is the sector, so a wall in the arc shadows everything behind it while the
- * rest of the cone still reaches.
- *
- * This is a different shape from `coneCells`, not a better one. A sector is aimed at an angle
- * and keeps it: a breath weapon, a searchlight, a blast of gas. `coneCells` snaps the aim to
- * one of the eight directions and widens a linear spray from it, which is what a wand fired
- * down a corridor wants. `coneSector` needs the level (that is what stops its rays), so it is
- * a plain function rather than one of `AreaShape`'s kinds, whose resolver must work without
- * one; a game calls it wherever it would call `resolveAreaOnLevel`. The aim's own cell is not
- * in the result, so a caster is never inside its own cone.
- *
- * @example
- * ```ts
- * import { coneSector, Level, WALL, FLOOR } from '@datamoc/mw_games/roguelike';
- *
- * const level = new Level(20, 20, [WALL, FLOOR], 1);
- * // a 60-degree cone, 6 cells deep, aimed east from (4, 10)
- * const cells = coneSector(level, { x: 4, y: 10 }, { x: 10, y: 10 }, { degrees: 60, range: 6 });
- * ```
- */
-export declare function coneSector(level: Level, from: Step, to: Step, options: ConeSectorOptions): Step[];
-/**
- * An arcing chain across `candidates`: starting from `origin`, each link is the nearest
- * not-yet-visited candidate within `range` of the previous one, up to `jumps` links. A
- * lightning arc, a contagion, anything that hops from one victim to the next rather than
- * travelling as a projectile - the game applies its own effect per link in order.
- */
-export declare function chainTargets(candidates: readonly Step[], origin: Step, jumps: number, range: number): Step[];
-/**
- * A damage/effect multiplier keyed to range band - the "melee bonus, falls off at range" or
- * "point-blank penalty on a ranged weapon" family of modifiers many games attach to an attack
- * once its distance is known. `mwg` supplies no default bands or multipliers, only the lookup:
- * bands are checked in order, the first whose `max` is at or above `distance` applies, and a
- * distance past every band's `max` falls back to `beyond`.
- *
- * @example
- * ```ts
- * import { rangeMultiplier, areaFalloffMultiplier, type RangeBand } from '@datamoc/mw_games/roguelike';
- *
- * const bands: RangeBand[] = [{ max: 2, multiplier: 1.5 }, { max: 6, multiplier: 1 }];
- * rangeMultiplier(1, bands); // 1.5 - point-blank bonus
- * rangeMultiplier(10, bands, 0.5); // 0.5 - past every band, falls back to `beyond`
- *
- * areaFalloffMultiplier(0, [1, 0.5]); // 1 - first target hit, full damage
- * areaFalloffMultiplier(1, [1, 0.5]); // 0.5 - second target
- * ```
- */
-export interface RangeBand {
-    /** the greatest distance this band covers */
-    max: number;
-    multiplier: number;
-}
-export declare function rangeMultiplier(distance: number, bands: readonly RangeBand[], beyond?: number): number;
-/**
- * A per-target multiplier for an area effect hitting several targets at once, stepping down
- * (or up) by how many targets were already resolved before this one - "full damage to the
- * first target hit, half to every one after" is `areaFalloffMultiplier(index, [1, 0.5])`.
- * `index` is the target's zero-based order among everyone the area shape hit (`resolveArea`'s
- * own returned order is a natural source); an index past the end of `steps` repeats the last
- * step rather than falling back to full strength.
- */
-export declare function areaFalloffMultiplier(index: number, steps: readonly number[]): number;
-/**
- * The cells something shoved from `from` along `direction` (a unit step, one of the 8)
- * travels: every passable cell up to `distance`, stopping before the first impassable
- * one. The game moves the shoved actor to the last cell returned - or nowhere, when the
- * very first cell already blocks, in which case the shove lands against the wall instead.
- */
-export declare function knockbackPath(level: Level, from: Step, direction: Step, distance: number): Step[];
-export interface TargetingControllerOptions {
-    /** where the aim starts: the thrower's own cell */
-    origin: Step;
-    /** how far the aim reaches, in the owning shape's own ruler (`canTarget`'s) */
-    range: number;
-    /** whether a wall between origin and cursor blocks the aim; on by default */
-    requireLineOfSight?: boolean;
-    /** how a confirmed aim resolves into cells; a single cell by default */
-    shape?: AreaShape;
-    /** the cursor's first cell; defaults to `origin` */
-    cursor?: Step;
-    /**
-     * A game's own rule on top of range and sight (not through an ally, not an empty floor
-     * tile). The controller never guesses what is in a cell: only the game knows.
-     */
-    validate?: (target: Step) => boolean;
-}
-/** What `TargetingController.confirm` returns, and what its `onConfirm` carries. Cells only. */
-export interface TargetResult {
-    readonly origin: Step;
-    readonly target: Step;
-    readonly shape: AreaShape;
-    /** the cells the shape affects, resolved through the level's own topology */
-    readonly cells: readonly Step[];
-}
-/**
- * The input-facing half of targeting: a cursor a player moves over cells, the range and
- * line-of-sight rule that decides whether the current aim is legal, an optional preview of
- * the shape, and a confirm/cancel result. It carries no renderer: `moveTo` takes a cell, so
- * a game converts its own pointer position through its own camera, and the controller hands
- * back cells for the game to draw and resolve. Legality beyond range and sight is the
- * optional `validate` hook's job, and damage is never the controller's business.
- *
- * @example
- * ```ts
- * import { Level, FLOOR, WALL, TargetingController } from '@datamoc/mw_games/roguelike';
- *
- * const level = new Level(12, 12, [WALL, FLOOR], 1);
- * const aiming = new TargetingController(level, {
- *   origin: { x: 2, y: 2 },
- *   range: 6,
- *   shape: { kind: 'burst', radius: 1 },
- * });
- *
- * aiming.move(1, 0); // keyboard: one cell east
- * aiming.moveTo({ x: 5, y: 2 }); // pointer: the caller resolved the screen point first
- * console.log(aiming.valid); // in range and in sight
- * console.log(aiming.preview()); // the burst's cells, or [] while the aim is illegal
- *
- * const shot = aiming.confirm(); // null when illegal, the target cells when not
- * ```
- */
-export declare class TargetingController {
-    readonly onMove: Signal<Step>;
-    readonly onConfirm: Signal<TargetResult>;
-    readonly onCancel: Signal<void>;
-    private readonly level;
-    private readonly origin;
-    private readonly range;
-    private readonly requireLineOfSight;
-    private readonly validate?;
-    private shape;
-    private cursor;
-    constructor(level: Level, options: TargetingControllerOptions);
-    /** the cell the cursor is on now, as a copy - mutating it does not move the aim */
-    get target(): Step;
-    /** how many cells the cursor is from the origin, in the level's own ruler */
-    get distance(): number;
-    get inRange(): boolean;
-    get inSight(): boolean;
-    /** whether the current aim is legal: range, sight unless waived, and the game's own rule */
-    get valid(): boolean;
-    /**
-     * Moves the cursor one cell, for keyboard and gamepad navigation. On a square level the
-     * offset is added directly; on a hex level it is looked up among the cursor's six
-     * neighbours, since only the level knows which offset means which direction there. A move
-     * that would leave the map is ignored rather than clamped to its edge.
-     */
-    move(dx: number, dy: number): void;
-    /**
-     * Moves the cursor to a specific cell, for pointer navigation: the caller has already
-     * turned a screen point into a cell through its own camera. Off-map cells are ignored.
-     */
-    moveTo(cell: Step): void;
-    /** Replaces the shape a confirm resolves to, keeping the cursor where it is. */
-    setShape(shape: AreaShape): void;
-    /** The cells the current aim would affect, for a preview overlay; empty while illegal. */
-    preview(): Step[];
-    /** Returns the confirmed target, or null when the current aim is illegal. */
-    confirm(): TargetResult | null;
-    /** Abandons the aim without confirming; the game closes its own overlay on `onCancel`. */
-    cancel(): void;
-}
-//# sourceMappingURL=Targeting.d.ts.map

package/dist/roguelike/Targeting.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Targeting.d.ts","sourceRoot":"","sources":["../../src/roguelike/Targeting.ts"],"names":[],"mappings":"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"}