fruta 0.0.3 → 0.1.0

package/dist/frutaGl.d.ts

@@ -0,0 +1,277 @@
+import { WebGLBatch, type Uniforms } from './render/webgl';
+import { type ShaderName } from './render/shaders';
+import { type Entity, type EntitySpec } from './world/entities';
+import { Tilemap, type TilemapConfig } from './world/tilemap';
+import * as M from './math/math';
+import { World, type WorldOptions } from './math/physics';
+import { type BurstOptions, type EmitterOptions, type Emitter } from './world/particles';
+import { type TimerHandle } from './world/timers';
+import { type PlayOptions, type Sound, type BeepOptions } from './audio/audio';
+import { Tween, Timeline, type EaseFn, type EaseName } from './animation/animate';
+import { Anim, type AnimState } from './animation/anim';
+import { GamepadController, type GamepadConfig } from './input/gamepad';
+export interface GLScene {
+    enter?(): void;
+    update?(dt: number, time: number): void;
+    leave?(): void;
+}
+export interface GLTweenOptions {
+    to: Record<string, number | string>;
+    duration: number;
+    ease?: EaseName | EaseFn;
+    delay?: number;
+    repeat?: number;
+    yoyo?: boolean;
+    onUpdate?: (target: Record<string, number>, progress: number) => void;
+    onComplete?: () => void;
+}
+export interface FrutaGLConfig {
+    width?: number;
+    height?: number;
+    canvas?: HTMLCanvasElement | string;
+    background?: string;
+    mount?: HTMLElement | string;
+}
+export interface GLGradient {
+    readonly _grad: true;
+    kind: 'linear' | 'radial';
+    stops: Array<[number, string]>;
+    angle: number;
+    key: string;
+}
+export type GLFill = string | GLGradient;
+export interface GLRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    fill?: GLFill;
+    rotation?: number;
+    alpha?: number;
+}
+export interface GLCircle {
+    x: number;
+    y: number;
+    r: number;
+    fill?: GLFill;
+    alpha?: number;
+}
+export interface GLPolygon {
+    points: Array<{
+        x: number;
+        y: number;
+    }>;
+    fill?: GLFill;
+    alpha?: number;
+}
+export interface GLSprite {
+    x: number;
+    y: number;
+    w?: number;
+    h?: number;
+    rotation?: number;
+    alpha?: number;
+    flipX?: boolean;
+    frame?: number;
+    frameW?: number;
+    frameH?: number;
+    cols?: number;
+}
+export interface GLTransform {
+    x?: number;
+    y?: number;
+    rotate?: number;
+    scale?: number | {
+        x: number;
+        y: number;
+    };
+    alpha?: number;
+}
+export interface GLEllipse {
+    x: number;
+    y: number;
+    rx: number;
+    ry: number;
+    rotation?: number;
+    fill?: GLFill;
+    alpha?: number;
+}
+export interface GLLine {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    stroke?: string;
+    strokeWidth?: number;
+    alpha?: number;
+}
+export interface GLText {
+    x: number;
+    y: number;
+    fill?: string;
+    size?: number;
+    font?: string;
+    weight?: string;
+    align?: 'left' | 'center' | 'right';
+    alpha?: number;
+}
+export type Point = {
+    x: number;
+    y: number;
+};
+export type GLLoopFn = (dt: number, time: number) => void;
+export declare class GLCamera {
+    private readonly gl;
+    x: number;
+    y: number;
+    zoom: number;
+    constructor(gl: FrutaGL);
+    follow(target: {
+        x: number;
+        y: number;
+    }, smooth?: number): void;
+    clamp(minX: number, minY: number, maxX: number, maxY: number): void;
+    begin(): void;
+    end(): void;
+    screenToWorld(px: number, py: number): Point;
+}
+export declare class FrutaGL {
+    readonly canvas: HTMLCanvasElement;
+    readonly batch: WebGLBatch;
+    private bg;
+    private stack;
+    private m;
+    private alpha;
+    private readonly circleTex;
+    private readonly colorCache;
+    private readonly normCtx;
+    private readonly warned;
+    readonly camera: GLCamera;
+    private entities;
+    private readonly particles;
+    private readonly timers;
+    private readonly audio;
+    private anims;
+    private gamepads;
+    private scenes;
+    private currentScene;
+    private currentSceneName;
+    private transition;
+    private debugOn;
+    private fps;
+    private readonly watched;
+    private postFX;
+    private postSrc;
+    private postUniforms;
+    private readonly textCanvas;
+    private readonly textCtx;
+    private readonly textCache;
+    private textSeq;
+    private static readonly TEXT_CACHE_MAX;
+    private readonly gradCanvas;
+    private readonly gradCtx;
+    private readonly gradCache;
+    private gradSeq;
+    private userLoop;
+    private rafId;
+    private lastTime;
+    time: number;
+    timeScale: number;
+    private _mouse;
+    private _down;
+    private keys;
+    private keyHandlers;
+    private pressHandlers;
+    private clickHandlers;
+    private moveHandlers;
+    private readonly scrollKeys;
+    private readonly onKeyDown;
+    private readonly onKeyUp;
+    private readonly onPointerMove;
+    private readonly onPointerDown;
+    private readonly onPointerUp;
+    private readonly onClickEv;
+    constructor(config?: FrutaGLConfig);
+    mount(parent?: HTMLElement): this;
+    addImage(name: string, source: TexImageSource): this;
+    load(assets: Record<string, string>): Promise<void>;
+    background(color?: string): this;
+    clear(): this;
+    rect(o: GLRect): this;
+    circle(o: GLCircle): this;
+    ellipse(o: GLEllipse): this;
+    polygon(o: GLPolygon): this;
+    linearGradient(stops: Array<[number, string]> | string[], angle?: number): GLGradient;
+    radialGradient(stops: Array<[number, string]> | string[]): GLGradient;
+    private makeGradient;
+    private fillShape;
+    private gradientTexture;
+    private tp;
+    line(o: GLLine): this;
+    text(content: string, o: GLText): this;
+    sprite(name: string, o: GLSprite): this;
+    push(t?: GLTransform): this;
+    pop(): this;
+    private corners;
+    loop(fn: GLLoopFn): this;
+    private startEngine;
+    stop(): this;
+    add(spec: EntitySpec): Entity;
+    drawEntities(): this;
+    get all(): Entity[];
+    tilemap(config: TilemapConfig): Tilemap;
+    gamepad(config?: GamepadConfig): GamepadController;
+    hits(a: M.Shape, b: M.Shape): boolean;
+    inside(p: M.Vec, s: M.Shape): boolean;
+    solve(a: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+        vx?: number;
+        vy?: number;
+        onGround?: boolean;
+    }, b: M.Rect): 'x' | 'y' | null;
+    physics(opts?: WorldOptions): World;
+    overlap<A extends M.Shape, B extends M.Shape>(a: A | A[], b: B | B[], onHit?: (a: A, b: B) => void): this;
+    burst(opts: BurstOptions): this;
+    emit(opts: EmitterOptions): Emitter;
+    drawParticles(): this;
+    after(seconds: number, fn: () => void): TimerHandle;
+    every(seconds: number, fn: () => void): TimerHandle;
+    store(key: string, value: unknown): this;
+    stored<T>(key: string, fallback: T): T;
+    play(name: string, opts?: PlayOptions): Sound;
+    beep(opts?: BeepOptions): this;
+    volume(v: number): this;
+    mute(on?: boolean): this;
+    loadAudio(assets: Record<string, string>): Promise<void>;
+    scene(name: string, def: GLScene): this;
+    start(name: string, fadeSeconds?: number): this;
+    private swapScene;
+    tween<T extends object>(target: T, opts: GLTweenOptions): Tween;
+    stagger<T extends object>(targets: T[], opts: GLTweenOptions & {
+        each?: number;
+    }): Tween[];
+    timeline(): Timeline;
+    anim(states: Record<string, AnimState>): Anim;
+    private buildTween;
+    private normalizeColor;
+    debug(on?: boolean): this;
+    watch(label: string, value: unknown): this;
+    private drawDebug;
+    shader(frag: string): {
+        draw: (uniforms?: Record<string, number | [number, number]>) => void;
+    };
+    effect(name: ShaderName | string | null, uniforms?: Uniforms): this;
+    get mouse(): Point;
+    get mouseDown(): boolean;
+    keyDown(key: string): boolean;
+    onKey(key: string, fn: () => void): this;
+    onPress(fn: (p: Point) => void): this;
+    onClick(fn: (p: Point) => void): this;
+    onMove(fn: (p: Point) => void): this;
+    destroy(): void;
+    private setMouse;
+    private parse;
+}

package/dist/game/behaviors.d.ts

@@ -0,0 +1,38 @@
+import type { BehaviorSpec } from './project';
+export interface PlayEntity {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    onGround: boolean;
+    alive: boolean;
+    r?: number;
+    w?: number;
+    h?: number;
+    rotation?: number;
+    tag?: string;
+    id?: string;
+    remove(): void;
+    [key: string]: unknown;
+}
+export interface PlayContext {
+    app: {
+        keyDown(key: string): boolean;
+        mouse: {
+            x: number;
+            y: number;
+        };
+        mouseDown: boolean;
+    };
+    map?: {
+        move(body: unknown, dt: number): void;
+    };
+    find(idOrTag: string): PlayEntity | undefined;
+    width: number;
+    height: number;
+}
+export type BehaviorFn = (e: PlayEntity, dt: number, time: number, ctx: PlayContext) => void;
+export type BehaviorFactory = (params: Record<string, unknown>) => BehaviorFn;
+export declare const BEHAVIORS: Record<string, BehaviorFactory>;
+export declare const behaviorNames: () => string[];
+export declare function resolveBehavior(spec: BehaviorSpec, scripts?: Record<string, BehaviorFn>): BehaviorFn | null;

package/dist/game/charts.d.ts

@@ -0,0 +1,127 @@
+export interface ChartSurface {
+    canvas: {
+        width: number;
+        height: number;
+    };
+    rect(o: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+        fill?: string;
+        stroke?: string;
+        strokeWidth?: number;
+        radius?: number;
+    }): unknown;
+    circle(o: {
+        x: number;
+        y: number;
+        r: number;
+        fill?: string;
+        stroke?: string;
+        strokeWidth?: number;
+    }): unknown;
+    line(o: {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+        stroke?: string;
+        strokeWidth?: number;
+    }): unknown;
+    text(content: string, o: {
+        x: number;
+        y: number;
+        fill?: string;
+        size?: number;
+        align?: CanvasTextAlign;
+        baseline?: CanvasTextBaseline;
+    }): unknown;
+    polygon(o: {
+        points: {
+            x: number;
+            y: number;
+        }[];
+        fill?: string;
+        stroke?: string;
+        strokeWidth?: number;
+        close?: boolean;
+    }): unknown;
+}
+export type ChartDatum = {
+    label?: string;
+    value: number;
+    color?: string;
+};
+export type Series = {
+    name?: string;
+    color?: string;
+    data: number[];
+};
+export type RadarSeries = {
+    name?: string;
+    color?: string;
+    values: number[];
+};
+interface Box {
+    x?: number;
+    y?: number;
+    w?: number;
+    h?: number;
+}
+export interface LegendOptions {
+    items: {
+        label: string;
+        color: string;
+    }[];
+    x: number;
+    y: number;
+    size?: number;
+}
+export declare function legend(s: ChartSurface, o: LegendOptions): void;
+export interface BarOptions extends Box {
+    data: number[] | ChartDatum[];
+    max?: number;
+    colors?: string[];
+    showValues?: boolean;
+    progress?: number;
+}
+export declare function barChart(s: ChartSurface, o: BarOptions): void;
+export interface LineChartOptions extends Box {
+    series?: Series[];
+    data?: number[];
+    min?: number;
+    max?: number;
+    grid?: boolean;
+    points?: boolean;
+    legend?: boolean;
+    colors?: string[];
+    progress?: number;
+}
+export declare function lineChart(s: ChartSurface, o: LineChartOptions): void;
+export interface PieOptions {
+    data: number[] | ChartDatum[];
+    x?: number;
+    y?: number;
+    r?: number;
+    donut?: number;
+    colors?: string[];
+    legend?: boolean;
+    progress?: number;
+}
+export declare function pieChart(s: ChartSurface, o: PieOptions): void;
+export interface RadarOptions {
+    axes: string[];
+    values?: number[];
+    series?: RadarSeries[];
+    x?: number;
+    y?: number;
+    r?: number;
+    max?: number;
+    rings?: number;
+    colors?: string[];
+    legend?: boolean;
+    progress?: number;
+}
+export declare function radar(s: ChartSurface, o: RadarOptions): void;
+export {};

package/dist/game/play.d.ts

@@ -0,0 +1,4 @@
+import Fruta from '../fruta';
+import type { GameProject } from './project';
+import { type BehaviorFn } from './behaviors';
+export declare function playProject(el: HTMLElement | string, project: GameProject, scripts?: Record<string, BehaviorFn>): ReturnType<typeof Fruta>;

package/dist/game/project.d.ts

@@ -0,0 +1,54 @@
+export interface GameProject {
+    meta: {
+        name: string;
+        width: number;
+        height: number;
+        background?: string;
+    };
+    assets?: {
+        sprites?: Record<string, string>;
+        sounds?: Record<string, string>;
+    };
+    scenes: GameScene[];
+    start?: string;
+}
+export interface GameScene {
+    name: string;
+    background?: string;
+    tilemap?: {
+        size: number;
+        data: string[];
+        tiles: Record<string, {
+            solid?: boolean;
+            color?: string;
+        }>;
+    };
+    camera?: {
+        follow: string;
+        clamp?: boolean;
+    };
+    entities: GameEntity[];
+}
+export interface GameEntity {
+    id?: string;
+    tag?: string;
+    x: number;
+    y: number;
+    shape?: 'rect' | 'circle';
+    w?: number;
+    h?: number;
+    r?: number;
+    color?: string;
+    sprite?: string;
+    rotation?: number;
+    vx?: number;
+    vy?: number;
+    behaviors?: BehaviorSpec[];
+    props?: Record<string, unknown>;
+}
+export type BehaviorSpec = string | ({
+    type: string;
+} & Record<string, unknown>);
+export declare const saveProject: (p: GameProject) => string;
+export declare const loadProject: (json: string) => GameProject;
+export declare function validateProject(p: GameProject, extraBehaviors?: string[]): string[];

package/dist/input/gamepad.d.ts

@@ -0,0 +1,38 @@
+export interface GamepadConfig {
+    index?: number;
+    deadzone?: number;
+    buttons?: Record<string, string | number>;
+    axes?: {
+        leftX?: number;
+        leftY?: number;
+        rightX?: number;
+        rightY?: number;
+    };
+}
+export declare class GamepadController {
+    private readonly config;
+    private prev;
+    private curr;
+    private pad;
+    private liveIndex;
+    private readonly onConnect;
+    private readonly onDisconnect;
+    constructor(config: GamepadConfig);
+    update(): void;
+    dispose(): void;
+    private indexOf;
+    get connected(): boolean;
+    get mapping(): string;
+    down(name: string): boolean;
+    pressed(name: string): boolean;
+    released(name: string): boolean;
+    value(name: string): number;
+    axis(name: string): number;
+    stick(side: 'left' | 'right'): {
+        x: number;
+        y: number;
+    };
+    allPressed(): string[];
+    pressedIndices(): number[];
+    axes(): number[];
+}

package/dist/math/math.d.ts

@@ -0,0 +1,37 @@
+export interface Rect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface Circle {
+    x: number;
+    y: number;
+    r: number;
+}
+export type Shape = Rect | Circle;
+export interface Vec {
+    x: number;
+    y: number;
+}
+export declare const lerp: (a: number, b: number, t: number) => number;
+export declare const clamp: (v: number, min: number, max: number) => number;
+export declare const map: (v: number, inMin: number, inMax: number, outMin: number, outMax: number) => number;
+export declare const dist: (ax: number, ay: number, bx: number, by: number) => number;
+export declare const angle: (ax: number, ay: number, bx: number, by: number) => number;
+export declare const rand: (min: number, max: number) => number;
+export declare const randInt: (min: number, max: number) => number;
+export declare const pick: <T>(arr: T[]) => T;
+export declare const hits: (a: Shape, b: Shape) => boolean;
+export declare const inside: (p: Vec, s: Shape) => boolean;
+export declare const resolve: (a: Rect, b: Rect) => Vec | null;
+export declare const cubicBezier: (p0: Vec, p1: Vec, p2: Vec, p3: Vec, t: number) => Vec;
+export declare const bezierPath: (p0: Vec, p1: Vec, p2: Vec, p3: Vec, steps?: number) => Vec[];
+export interface Hex {
+    q: number;
+    r: number;
+}
+export declare const hexToPixel: (q: number, r: number, size: number) => Vec;
+export declare const hexRound: (q: number, r: number) => Hex;
+export declare const pixelToHex: (x: number, y: number, size: number) => Hex;
+export declare const hexNeighbors: (q: number, r: number) => Hex[];

package/dist/math/pathfind.d.ts

@@ -0,0 +1,7 @@
+export interface Cell {
+    x: number;
+    y: number;
+}
+export declare function findPath(start: Cell, goal: Cell, cols: number, rows: number, blocked: (x: number, y: number) => boolean, opts?: {
+    diagonal?: boolean;
+}): Cell[] | null;

package/dist/math/physics.d.ts

@@ -0,0 +1,38 @@
+export interface Body {
+    x: number;
+    y: number;
+    w?: number;
+    h?: number;
+    r?: number;
+    vx: number;
+    vy: number;
+    mass: number;
+    restitution: number;
+    friction: number;
+    onGround?: boolean;
+    tag?: string;
+    [k: string]: unknown;
+}
+export interface WorldOptions {
+    gravity?: number;
+    iterations?: number;
+    damping?: number;
+}
+export declare class World {
+    bodies: Body[];
+    gravity: number;
+    iterations: number;
+    damping: number;
+    constructor(opts?: WorldOptions);
+    add<T extends {
+        x: number;
+        y: number;
+    }>(obj: T, opts?: Partial<Body>): T & Body;
+    box(x: number, y: number, w: number, h: number, opts?: Partial<Body>): Body;
+    circle(x: number, y: number, r: number, opts?: Partial<Body>): Body;
+    static(x: number, y: number, w: number, h: number, opts?: Partial<Body>): Body;
+    remove(b: Body): void;
+    step(dt: number): void;
+    private solveVelocity;
+    private correct;
+}

package/dist/math/pool.d.ts

@@ -0,0 +1,11 @@
+export declare class Pool<T> {
+    private factory;
+    readonly items: T[];
+    count: number;
+    constructor(size: number, factory: () => T);
+    get capacity(): number;
+    spawn(): T | null;
+    kill(i: number): void;
+    clear(): void;
+    grow(by: number): void;
+}

package/dist/math/spatial.d.ts

@@ -0,0 +1,10 @@
+export declare class SpatialHash<T> {
+    private cellSize;
+    private cells;
+    private used;
+    constructor(cellSize: number);
+    private key;
+    clear(): void;
+    insert(x: number, y: number, item: T): void;
+    query(x: number, y: number, r: number, out: T[]): T[];
+}

package/dist/render/create/FontCreator.d.ts

@@ -0,0 +1,16 @@
+import CanvasTarget from './canvasTarget';
+export default class FontCreator extends CanvasTarget {
+    loadFont(family: string, source: string, descriptors?: FontFaceDescriptors): this;
+    fontRenderingType(value: string): this;
+    fontFill(message: string, x: number, y: number, maxWidth?: number): this;
+    fontStrokeText(text: string, x: number, y: number, maxWidth?: number): this;
+    fontStyle(style: string): this;
+    fontAlign(style: CanvasTextAlign): this;
+    fontDirection(style: CanvasDirection): this;
+    fontBaseline(style: CanvasTextBaseline): this;
+    fontVariantCaps(style: CanvasFontVariantCaps): this;
+    fontKerning(style: CanvasFontKerning): this;
+    fontWordSpacing(style: string): this;
+    fontS(style: CanvasFontStretch): this;
+    fontMeasure(text: string): TextMetrics;
+}

package/dist/render/create/SaveRestore.d.ts

@@ -0,0 +1,5 @@
+import CanvasTarget from './canvasTarget';
+export default class SaveRestore extends CanvasTarget {
+    save(): void;
+    restore(): void;
+}