@jgengine/core 0.6.0 → 0.8.0

package/dist/combat/effects.js

@@ -1,5 +1,25 @@
 import { applyPoolDelta } from "../scene/entityStats.js";
 import { distanceBetween } from "../scene/spatial.js";
+export function resolveAreaTargets(spatial, input, accept) {
+    const falloff = input.falloff ?? "none";
+    const los = input.los ?? true;
+    const targets = [];
+    for (const instanceId of spatial.inRadius(input.at, input.radius)) {
+        if (los && !spatial.hasLineOfSight(input.at, instanceId))
+            continue;
+        let scale = 1;
+        if (falloff === "linear") {
+            const position = spatial.positionOf(instanceId);
+            if (position === undefined)
+                continue;
+            scale = Math.max(0, 1 - distanceBetween(input.at, position) / input.radius);
+        }
+        if (accept !== undefined && !accept(instanceId))
+            continue;
+        targets.push({ instanceId, scale });
+    }
+    return targets;
+}
 const DEFAULT_DRAIN_STAT = "damage";
 export function createEffectSystem(deps) {
     function resolveRule(instanceId, effect) {
@@ -20,18 +40,21 @@ export function createEffectSystem(deps) {
         }
         return result;
     }
-    function canReceive(instanceId, effect) {
+    function canReceive(instanceId, effect, magnitude) {
         const rule = resolveRule(instanceId, effect);
         if (rule === null)
             return "not-receivable";
         const stats = deps.resolveStats(instanceId);
         if (stats === undefined)
             return "unknown-instance";
-        const anyPoolAboveMin = rule.order.some((statId) => {
+        const restorative = magnitude !== undefined && magnitude < 0;
+        const anyPoolHasHeadroom = rule.order.some((statId) => {
             const stat = stats[statId];
-            return stat !== undefined && stat.current > stat.min;
+            if (stat === undefined)
+                return false;
+            return restorative ? stat.current < stat.max : stat.current > stat.min;
         });
-        if (!anyPoolAboveMin)
+        if (!anyPoolHasHeadroom)
             return "pools-depleted";
         return null;
     }
@@ -60,13 +83,13 @@ export function createEffectSystem(deps) {
         return { instanceId, effect, applied, lethal };
     }
     function applyTo(instanceId, effect, via, from, scale) {
-        if (canReceive(instanceId, effect) !== null)
-            return null;
         const rule = resolveRule(instanceId, effect);
         const stats = deps.resolveStats(instanceId);
         if (rule === null || stats === undefined)
             return null;
         const drainMagnitude = modifiedDrainMagnitude(baseDrainMagnitude(effect, via) * scale, rule);
+        if (canReceive(instanceId, effect, drainMagnitude) !== null)
+            return null;
         const result = drainPools(instanceId, effect, rule, stats, drainMagnitude);
         if (result.lethal)
             deps.onLethal?.(instanceId, { from, via, effect });
@@ -85,20 +108,9 @@ export function createEffectSystem(deps) {
                 const result = applyTo(input.to, input.effect, input.via, input.from, 1);
                 return result === null ? [] : [result];
             }
-            const falloff = input.falloff ?? "none";
-            const los = input.los ?? true;
             const results = [];
-            for (const instanceId of deps.spatial.inRadius(input.at, input.radius)) {
-                if (los && !deps.spatial.hasLineOfSight(input.at, instanceId))
-                    continue;
-                let scale = 1;
-                if (falloff === "linear") {
-                    const position = deps.spatial.positionOf(instanceId);
-                    if (position === undefined)
-                        continue;
-                    scale = Math.max(0, 1 - distanceBetween(input.at, position) / input.radius);
-                }
-                const result = applyTo(instanceId, input.effect, input.via, input.from, scale);
+            for (const target of resolveAreaTargets(deps.spatial, input)) {
+                const result = applyTo(target.instanceId, input.effect, input.via, input.from, target.scale);
                 if (result !== null)
                     results.push(result);
             }

package/dist/combat/hitReaction.d.ts

@@ -0,0 +1,23 @@
+import type { EntityPosition } from "../scene/entityStore.js";
+export interface CameraShake {
+    amplitude: number;
+    decay: number;
+}
+export interface HitReactionConfig {
+    hitstopMs: number;
+    knockback: number;
+    vertical?: number;
+    shake?: CameraShake;
+}
+export interface HitReactionInput {
+    attackerPos: EntityPosition;
+    targetPos: EntityPosition;
+    power?: number;
+}
+export interface HitReaction {
+    hitstopMs: number;
+    impulse: [number, number, number];
+    shake: CameraShake | null;
+}
+export declare function resolveHitReaction(config: HitReactionConfig, input: HitReactionInput): HitReaction;
+export declare function applyImpulse(position: EntityPosition, impulse: [number, number, number]): EntityPosition;

package/dist/combat/hitReaction.js

@@ -0,0 +1,20 @@
+export function resolveHitReaction(config, input) {
+    const power = input.power ?? 1;
+    const dx = input.targetPos[0] - input.attackerPos[0];
+    const dz = input.targetPos[2] - input.attackerPos[2];
+    const planar = Math.hypot(dx, dz);
+    const nx = planar === 0 ? 0 : dx / planar;
+    const nz = planar === 0 ? 0 : dz / planar;
+    const magnitude = config.knockback * power;
+    const shake = config.shake === undefined
+        ? null
+        : { amplitude: config.shake.amplitude * power, decay: config.shake.decay };
+    return {
+        hitstopMs: config.hitstopMs,
+        impulse: [nx * magnitude, (config.vertical ?? 0) * power, nz * magnitude],
+        shake,
+    };
+}
+export function applyImpulse(position, impulse) {
+    return [position[0] + impulse[0], position[1] + impulse[1], position[2] + impulse[2]];
+}

package/dist/combat/projectiles.d.ts

@@ -1,3 +1,4 @@
+import type { BallisticSweep } from "../physics/ballisticSweep.js";
 import type { EntityPosition } from "../scene/entityStore.js";
 import type { Aim } from "../scene/spatial.js";
 import type { CombatSpatialDeps, EffectResult, EffectSystem, EffectVia } from "./effects.js";
@@ -7,11 +8,22 @@ export interface ProjectileShotInput {
     aim: Aim;
     effect: string;
 }
-export interface RaycastHit {
+/** A raycast hit against a scene entity — the ray reached `instanceId` at `distance` along its length. */
+export interface EntityRaycastHit {
+    kind: "entity";
     instanceId: string;
     distance: number;
     at: EntityPosition;
 }
+/** A raycast hit against a placed scene object's bounding box — see `ProjectileObjectsDeps.halfExtents`. */
+export interface ObjectRaycastHit {
+    kind: "object";
+    instanceId: string;
+    catalogId: string;
+    distance: number;
+    at: EntityPosition;
+}
+export type RaycastHit = EntityRaycastHit | ObjectRaycastHit;
 export type Raycast = (from: string, aim: Aim, range: number) => RaycastHit[];
 export interface ProjectileSettleReport {
     from: string;
@@ -20,19 +32,44 @@ export interface ProjectileSettleReport {
     effect: string;
     hit: boolean;
 }
+/** Read-only scene object access for the default `raycast`; matches `ObjectStore.list()`/a catalog lookup structurally. */
+export interface ProjectileObjectsDeps {
+    list(): readonly {
+        instanceId: string;
+        catalogId: string;
+        position: [number, number, number];
+    }[];
+    /** Half-extents of the object's axis-aligned bounding box; `null`/omitted falls back to `[0.5, 0.5, 0.5]`. */
+    halfExtents?(catalogId: string): [number, number, number] | null;
+}
 export interface ProjectileSystemDeps {
     effects: EffectSystem;
     spatial: CombatSpatialDeps;
     getStat(itemId: string, stat: string): number | null;
     raycast?: Raycast;
+    /** Optional object awareness for the default `raycast`; when set, placed objects can block or absorb a shot. */
+    objects?: ProjectileObjectsDeps;
+    /**
+     * Optional collision-aware arc test for ballistic shots (see `createBallisticSweep` in
+     * `physics/ballisticSweep`). A hit settles the shot at the impact point; `null` or omission
+     * falls back to the closed-form landing.
+     */
+    sweepBallistic?: BallisticSweep;
     now?: () => number;
     onSettle?(report: ProjectileSettleReport): void;
 }
+export type ProjectileHit = {
+    kind: "entity";
+    instanceId: string;
+    distance: number;
+} | {
+    kind: "object";
+    instanceId: string;
+    catalogId: string;
+    distance: number;
+};
 export interface ProjectilePrediction {
-    hits: {
-        instanceId: string;
-        distance: number;
-    }[];
+    hits: ProjectileHit[];
     blocked?: boolean;
 }
 export type SettleResult = {

package/dist/combat/projectiles.js

@@ -2,6 +2,38 @@ const DEFAULT_RANGE = 100;
 const DEFAULT_PROJECTILE_SPEED = 15;
 const GRAVITY = 9.8;
 const BASE_HIT_RADIUS = 0.5;
+const DEFAULT_OBJECT_HALF_EXTENTS = [0.5, 0.5, 0.5];
+function isEntityHit(hit) {
+    return hit.kind === "entity";
+}
+function isObjectHit(hit) {
+    return hit.kind === "object";
+}
+function raySegmentAabbDistance(origin, direction, range, min, max) {
+    let tMin = 0;
+    let tMax = range;
+    for (let axis = 0; axis < 3; axis += 1) {
+        const o = origin[axis];
+        const d = direction[axis];
+        const lo = min[axis];
+        const hi = max[axis];
+        if (Math.abs(d) < 1e-9) {
+            if (o < lo || o > hi)
+                return null;
+            continue;
+        }
+        const inv = 1 / d;
+        let t1 = (lo - o) * inv;
+        let t2 = (hi - o) * inv;
+        if (t1 > t2)
+            [t1, t2] = [t2, t1];
+        tMin = Math.max(tMin, t1);
+        tMax = Math.min(tMax, t2);
+        if (tMin > tMax)
+            return null;
+    }
+    return tMin;
+}
 function normalize(vector) {
     const length = Math.sqrt(vector[0] * vector[0] + vector[1] * vector[1] + vector[2] * vector[2]);
     if (length === 0)
@@ -42,7 +74,7 @@ export function createProjectileSystem(deps) {
             if (direction === null)
                 return [];
             const spreadRad = (aimSpreadDeg(aim) * Math.PI) / 180;
-            const hits = [];
+            const entityHits = [];
             for (const instanceId of deps.spatial.inRadius(origin, range)) {
                 if (instanceId === from)
                     continue;
@@ -61,8 +93,42 @@ export function createProjectileSystem(deps) {
                 const perpendicular = Math.sqrt(px * px + py * py + pz * pz);
                 if (perpendicular > BASE_HIT_RADIUS + Math.tan(spreadRad) * along)
                     continue;
-                hits.push({ instanceId, distance: along, at: position });
+                entityHits.push({ kind: "entity", instanceId, distance: along, at: position });
             }
+            let nearestObject = null;
+            for (const object of deps.objects?.list() ?? []) {
+                const half = deps.objects?.halfExtents?.(object.catalogId) ?? DEFAULT_OBJECT_HALF_EXTENTS;
+                const min = [
+                    object.position[0] - half[0],
+                    object.position[1] - half[1],
+                    object.position[2] - half[2],
+                ];
+                const max = [
+                    object.position[0] + half[0],
+                    object.position[1] + half[1],
+                    object.position[2] + half[2],
+                ];
+                const distance = raySegmentAabbDistance(origin, direction, range, min, max);
+                if (distance === null)
+                    continue;
+                if (nearestObject === null || distance < nearestObject.distance) {
+                    nearestObject = {
+                        kind: "object",
+                        instanceId: object.instanceId,
+                        catalogId: object.catalogId,
+                        distance,
+                        at: [
+                            origin[0] + direction[0] * distance,
+                            origin[1] + direction[1] * distance,
+                            origin[2] + direction[2] * distance,
+                        ],
+                    };
+                }
+            }
+            const blockDistance = nearestObject?.distance ?? Infinity;
+            const hits = entityHits.filter((hit) => hit.distance <= blockDistance);
+            if (nearestObject !== null)
+                hits.push(nearestObject);
             return hits.sort((a, b) => a.distance - b.distance);
         });
     function resolveRange(via) {
@@ -71,7 +137,7 @@ export function createProjectileSystem(deps) {
     function isBallistic(via) {
         return itemStat(via, "projectile.fuseTime") !== null || itemStat(via, "explosion.radius") !== null;
     }
-    function ballisticSettlePoint(input) {
+    function ballisticArc(input) {
         const origin = shotOrigin(input.from, input.aim) ?? [0, 0, 0];
         const direction = aimDirection(input.aim) ?? [0, 0, 1];
         const speed = itemStat(input.via, "projectile.speed") ?? DEFAULT_PROJECTILE_SPEED;
@@ -85,16 +151,32 @@ export function createProjectileSystem(deps) {
             : flightCap;
         const flightTime = Math.min(impactTime, flightCap);
         const settledY = Math.max(0, origin[1] + verticalSpeed * flightTime - 0.5 * gravity * flightTime * flightTime);
-        return [
-            origin[0] + direction[0] * speed * flightTime,
-            settledY,
-            origin[2] + direction[2] * speed * flightTime,
-        ];
+        return {
+            origin,
+            velocity: [direction[0] * speed, verticalSpeed, direction[2] * speed],
+            gravity,
+            flightTime,
+            landing: [
+                origin[0] + direction[0] * speed * flightTime,
+                settledY,
+                origin[2] + direction[2] * speed * flightTime,
+            ],
+        };
+    }
+    function ballisticSettlePoint(input) {
+        const arc = ballisticArc(input);
+        const sweep = deps.sweepBallistic;
+        if (sweep !== undefined) {
+            const impact = sweep(arc.origin, arc.velocity, arc.gravity, arc.flightTime);
+            if (impact !== null)
+                return impact.point;
+        }
+        return arc.landing;
     }
     function predictHits(input) {
         const aim = withWeaponSpread(input.via, input.aim);
         const rawHits = raycast(input.from, aim, resolveRange(input.via));
-        const visible = rawHits.filter((hit) => deps.spatial.hasLineOfSight(input.from, hit.instanceId));
+        const visible = rawHits.filter((hit) => isObjectHit(hit) || deps.spatial.hasLineOfSight(input.from, hit.instanceId));
         return { rawHits, visible };
     }
     function settledAt(input, hits) {
@@ -112,7 +194,9 @@ export function createProjectileSystem(deps) {
         willHitProjectile(input) {
             const { rawHits, visible } = predictHits(input);
             const prediction = {
-                hits: visible.map(({ instanceId, distance }) => ({ instanceId, distance })),
+                hits: visible.map((hit) => isObjectHit(hit)
+                    ? { kind: "object", instanceId: hit.instanceId, catalogId: hit.catalogId, distance: hit.distance }
+                    : { kind: "entity", instanceId: hit.instanceId, distance: hit.distance }),
             };
             if (rawHits.length > 0 && visible.length === 0)
                 prediction.blocked = true;
@@ -139,7 +223,9 @@ export function createProjectileSystem(deps) {
                 return { status: "settled", shotId, at, hits: [] };
             }
             const { visible } = predictHits(input);
-            const receivable = visible.filter((hit) => deps.effects.canReceive(hit.instanceId, input.effect) === null);
+            const entityHits = visible.filter(isEntityHit);
+            const objectHits = visible.filter(isObjectHit);
+            const receivable = entityHits.filter((hit) => deps.effects.canReceive(hit.instanceId, input.effect) === null);
             const pellets = Math.max(1, Math.round(itemStat(input.via, "pellets") ?? 1));
             const hits = [];
             if (receivable.length > 0) {
@@ -153,7 +239,7 @@ export function createProjectileSystem(deps) {
                     }));
                 }
             }
-            const at = settledAt(input, receivable);
+            const at = settledAt(input, receivable.length > 0 ? receivable : objectHits);
             deps.onSettle?.({ from: input.from, origin, at, effect: input.effect, hit: receivable.length > 0 });
             return { status: "settled", shotId, at, hits };
         },

package/dist/combat/resistance.d.ts

@@ -0,0 +1,13 @@
+export type ResistVerdict = "immune" | "resist" | "normal" | "vulnerable";
+export interface ResistanceMatrix {
+    categories: Record<string, Record<string, ResistVerdict>>;
+    multipliers?: Partial<Record<ResistVerdict, number>>;
+    default?: ResistVerdict;
+}
+export interface ResistanceResult {
+    verdict: ResistVerdict;
+    multiplier: number;
+    immune: boolean;
+}
+export declare function resolveResistance(matrix: ResistanceMatrix, category: string, targetProperties: readonly string[]): ResistanceResult;
+export declare function resistanceScale(matrix: ResistanceMatrix, category: string, targetProperties: readonly string[]): number;

package/dist/combat/resistance.js

@@ -0,0 +1,46 @@
+const DEFAULT_MULTIPLIERS = {
+    immune: 0,
+    resist: 0.5,
+    normal: 1,
+    vulnerable: 2,
+};
+function multiplierFor(matrix, verdict) {
+    return matrix.multipliers?.[verdict] ?? DEFAULT_MULTIPLIERS[verdict];
+}
+function summaryVerdict(matrix, immune, net) {
+    if (immune)
+        return "immune";
+    const normal = multiplierFor(matrix, "normal");
+    if (net > normal)
+        return "vulnerable";
+    if (net < normal)
+        return "resist";
+    return "normal";
+}
+export function resolveResistance(matrix, category, targetProperties) {
+    const byProperty = matrix.categories[category] ?? {};
+    const fallback = matrix.default ?? "normal";
+    let net = 1;
+    let matched = false;
+    let immune = false;
+    for (const property of targetProperties) {
+        const verdict = byProperty[property];
+        if (verdict === undefined)
+            continue;
+        matched = true;
+        if (verdict === "immune")
+            immune = true;
+        net *= multiplierFor(matrix, verdict);
+    }
+    if (!matched) {
+        if (fallback === "immune")
+            return { verdict: "immune", multiplier: 0, immune: true };
+        const multiplier = multiplierFor(matrix, fallback);
+        return { verdict: fallback, multiplier, immune: false };
+    }
+    const multiplier = immune ? 0 : net;
+    return { verdict: summaryVerdict(matrix, immune, multiplier), multiplier, immune };
+}
+export function resistanceScale(matrix, category, targetProperties) {
+    return resolveResistance(matrix, category, targetProperties).multiplier;
+}

package/dist/combat/telegraph.d.ts

@@ -0,0 +1,31 @@
+import type { EntityPosition } from "../scene/entityStore.js";
+export type TelegraphShape = {
+    kind: "circle";
+    radius: number;
+} | {
+    kind: "ring";
+    radius: number;
+    innerRadius: number;
+} | {
+    kind: "cone";
+    radius: number;
+    angle: number;
+} | {
+    kind: "line";
+    length: number;
+    width: number;
+};
+export interface TelegraphConfig {
+    shape: TelegraphShape;
+    at: EntityPosition;
+    dir?: number;
+    windupMs?: number;
+    turns?: number;
+    kind?: string;
+}
+export declare function telegraphProgress(windupMs: number, startedAtMs: number, nowMs: number): number;
+export declare function telegraphFired(windupMs: number, startedAtMs: number, nowMs: number): boolean;
+export declare function telegraphTurnProgress(config: TelegraphConfig, startedTurn: number, currentTurn: number): number;
+export declare function telegraphFiredAtTurn(config: TelegraphConfig, startedTurn: number, currentTurn: number): boolean;
+export declare function telegraphTurnsRemaining(config: TelegraphConfig, startedTurn: number, currentTurn: number): number;
+export declare function pointInTelegraph(config: TelegraphConfig, point: EntityPosition): boolean;

package/dist/combat/telegraph.js

@@ -0,0 +1,51 @@
+export function telegraphProgress(windupMs, startedAtMs, nowMs) {
+    if (windupMs <= 0)
+        return 1;
+    return Math.max(0, Math.min(1, (nowMs - startedAtMs) / windupMs));
+}
+export function telegraphFired(windupMs, startedAtMs, nowMs) {
+    return nowMs - startedAtMs >= windupMs;
+}
+export function telegraphTurnProgress(config, startedTurn, currentTurn) {
+    const turns = config.turns ?? 0;
+    if (turns <= 0)
+        return 1;
+    return Math.max(0, Math.min(1, (currentTurn - startedTurn) / turns));
+}
+export function telegraphFiredAtTurn(config, startedTurn, currentTurn) {
+    const turns = config.turns ?? 0;
+    return currentTurn - startedTurn >= turns;
+}
+export function telegraphTurnsRemaining(config, startedTurn, currentTurn) {
+    const turns = config.turns ?? 0;
+    return Math.max(0, turns - (currentTurn - startedTurn));
+}
+function planarDelta(config, point) {
+    return { dx: point[0] - config.at[0], dz: point[2] - config.at[2] };
+}
+export function pointInTelegraph(config, point) {
+    const { shape } = config;
+    const { dx, dz } = planarDelta(config, point);
+    const dist = Math.hypot(dx, dz);
+    const dir = config.dir ?? 0;
+    if (shape.kind === "circle")
+        return dist <= shape.radius;
+    if (shape.kind === "ring")
+        return dist >= shape.innerRadius && dist <= shape.radius;
+    if (shape.kind === "cone") {
+        if (dist > shape.radius || dist === 0)
+            return dist === 0;
+        const angleTo = Math.atan2(dx, dz);
+        let delta = angleTo - dir;
+        while (delta > Math.PI)
+            delta -= Math.PI * 2;
+        while (delta < -Math.PI)
+            delta += Math.PI * 2;
+        return Math.abs(delta) <= shape.angle / 2;
+    }
+    const forwardX = Math.sin(dir);
+    const forwardZ = Math.cos(dir);
+    const along = dx * forwardX + dz * forwardZ;
+    const lateral = Math.abs(dx * forwardZ - dz * forwardX);
+    return along >= 0 && along <= shape.length && lateral <= shape.width / 2;
+}

package/dist/commands/commandRegistry.d.ts

@@ -3,7 +3,7 @@ export interface CommandRejection {
 }
 export interface CommandDefinition<TState, TInput> {
     validate?(state: TState, input: TInput): CommandRejection | null;
-    apply(state: TState, input: TInput): TState;
+    apply(state: TState, input: TInput): TState | void;
 }
 export type CommandResult<TState> = {
     status: "applied";

package/dist/commands/commandRegistry.js

@@ -20,7 +20,8 @@ export function createCommandRegistry() {
             const rejection = definition.validate?.(state, input) ?? null;
             if (rejection)
                 return { status: "rejected", reason: rejection.reason };
-            return { status: "applied", state: definition.apply(state, input) };
+            const next = definition.apply(state, input);
+            return { status: "applied", state: next === undefined ? state : next };
         },
     };
 }

package/dist/crafting/crop.d.ts

@@ -0,0 +1,59 @@
+import type { RecipeItem } from "./recipe.js";
+export type SoilState = "untilled" | "tilled";
+export interface CropDef {
+    id: string;
+    stages: readonly number[];
+    regrowDays?: number;
+    needsDailyWater?: boolean;
+    harvest?: RecipeItem;
+}
+export interface CropTileState {
+    soil: SoilState;
+    watered: boolean;
+    cropId: string | null;
+    stage: number;
+    stageProgress: number;
+    harvestable: boolean;
+}
+export type CropCatalog = (cropId: string) => CropDef | null;
+export declare function emptyTile(): CropTileState;
+export declare function canTill(state: CropTileState): boolean;
+export declare function tillTile(state: CropTileState): CropTileState;
+export declare function canPlant(state: CropTileState): boolean;
+export declare function plantCrop(state: CropTileState, cropId: string): CropTileState;
+export declare function waterTile(state: CropTileState): CropTileState;
+export declare function maturityDays(def: CropDef): number;
+export declare function advanceCropDay(def: CropDef, state: CropTileState): CropTileState;
+export interface HarvestResult {
+    state: CropTileState;
+    yield: RecipeItem | null;
+}
+export declare function harvestCrop(def: CropDef, state: CropTileState): HarvestResult;
+export type TileCoord = readonly [number, number];
+export type TilePattern = readonly TileCoord[];
+export declare function tileKey(coord: TileCoord): string;
+export declare function singleTile(): TilePattern;
+export declare function squarePattern(radius: number): TilePattern;
+export declare function diamondPattern(radius: number): TilePattern;
+export declare function rectPattern(width: number, depth: number): TilePattern;
+export declare function patternAt(center: TileCoord, pattern: TilePattern): TileCoord[];
+export interface ApplyToolResult {
+    tiles: Map<string, CropTileState>;
+    changed: TileCoord[];
+}
+export declare function applyToolToTiles(tiles: ReadonlyMap<string, CropTileState>, center: TileCoord, pattern: TilePattern, apply: (state: CropTileState, coord: TileCoord) => CropTileState, fill?: () => CropTileState): ApplyToolResult;
+export interface DayTicker {
+    tick(currentDay: number): number;
+    day(): number;
+}
+export declare function createDayTicker(startDay?: number): DayTicker;
+export interface CropField {
+    get(coord: TileCoord): CropTileState;
+    till(coord: TileCoord, pattern?: TilePattern): TileCoord[];
+    plant(coord: TileCoord, cropId: string): boolean;
+    water(coord: TileCoord, pattern?: TilePattern): TileCoord[];
+    harvest(coord: TileCoord): RecipeItem | null;
+    advanceDay(days?: number): void;
+    tiles(): ReadonlyMap<string, CropTileState>;
+}
+export declare function createCropField(catalog?: CropCatalog): CropField;