@v12-engine/engine 0.1.0 → 0.4.0

package/dist/rules.d.ts

@@ -1,12 +1,14 @@
-import type { DamageType, Stats, UnitTypeDef } from './defs';
+import { type DamageType, type ItemDef, type Stats, type UnitTypeDef } from './defs';
+import type { MessageRef } from './messages';
 import type { Registry } from './registry';
+import { type CleaveNow } from './systems/combat';
 import type { Entity, PlayerId } from './entity';
 import { type Upkeep } from './upkeep';
 import type { World } from './world';
 import type { OrderInit } from './registry';
-import type { GameModule } from './game';
-import type { ScoreRules } from './score';
-import { type HeroRules } from './hero';
+import type { ScoreSettings } from './score';
+import { type HeroSettings } from './hero';
+import { type AttackModifier } from './abilities/triggers';
 /**
  * A rule of `HudSharing`: one value for every unit, or a function deciding it for each (only heroes', only a boss's)
  *
@@ -14,7 +16,7 @@ import { type HeroRules } from './hero';
  */
 export type HudShareRule<T> = T | ((world: World, entity: Entity) => T);
 /**
- * What of a unit the players who see it are told beyond what they always are (`GameRules.hud`), each for the plates
+ * What of a unit the players who see it are told beyond what they always are (`RuleSettings.hud`), each for the plates
  * over it to show. What is not shared never reaches a player, so no screen can show it. A game's own data goes in a
  * component with `replicate` (the client's `hudData` reads it)
  *
@@ -36,21 +38,24 @@ export interface HudSharing {
     shareXp?: HudShareRule<boolean>;
 }
 /**
- * A unit in a queue, not made yet, as the supply it will take is asked of it (`GameRules.supply.of`)
+ * A unit in a queue, not made yet, as the supply it will take is asked of it (`RuleSettings.supply.of`)
  *
  * @beta
  */
 export interface QueuedUnit {
+    /** The unit type being queued */
     readonly def: UnitTypeDef;
+    /** The player who queued it */
     readonly owner: PlayerId;
+    /** Always true: tells a queued unit from an `Entity` where the supply it takes is asked */
     readonly queued: true;
 }
 /**
- * How the fog of war keeps what was seen (`GameRules.fog`)
+ * How the fog of war keeps what was seen (`RuleSettings.fog`)
  *
  * @beta
  */
-export interface FogRules {
+export interface FogSettings {
     /** Part of its sight a unit has at night, for types that do not say (`UnitTypeDef.sightNight`) */
     nightSight: number;
     /**
@@ -73,39 +78,53 @@ export interface FogRules {
  * The numbers and formulas of a kind of game that are not about any one unit: the supply cap, what selling gives
  * back, how a hit is mitigated. In groups, each about one thing: supply, production, the economy, combat, movement,
  * the fog, talk, the camps, heroes, what the HUD is told, the score. A game module changes the ones it wants
- * (`GameModule.rules`: any of a group, the rest of it the engine's) and a pack the ones it brings (`GamePack.rules`).
+ * (`Rules.settings`: any of a group, the rest of it the engine's) and a pack the ones it brings (`GamePack.settings`).
  *
- * Read them from `world.rules` in the simulation, and from `session.registry.rules` on a player's screen.
+ * Read them from `world.settings` in the simulation, and from `session.registry.settings` on a player's screen.
  *
  * @beta
  */
-export interface GameRules {
-    /** What armies cost in supply, and how much a player may have (`SupplyRules`) */
-    supply: SupplyRules;
-    /** What buildings make and how they go up (`ProductionRules`) */
-    production: ProductionRules;
-    /** What is paid back, paid for and given away (`EconomyRules`) */
-    economy: EconomyRules;
-    /** How a hit lands and how much of it is felt, and who fights whom (`CombatRules`) */
-    combat: CombatRules;
-    /** How units find their way among each other (`MovementRules`) */
-    movement: MovementRules;
-    /** What is seen and kept of what was (`FogRules`) */
-    fog: FogRules;
-    /** Pings, chat and pauses (`TalkRules`) */
-    talk: TalkRules;
-    /**
-     * Creeps' camps (`camps.ts`): how far creeps chase away from their camp (`leash`), whether they sleep at home at night
-     * until attacked (`sleep`), and the seconds after a camp is cleared that it comes back, for every camp (`respawn`, see
-     * `Camp.respawn`; never when left out). What makes creeps keep to them, sleep and come back is the heroes pack's
-     * (`withHeroes`)
-     */
-    camps: CampRules;
-    /**
-     * Heroes' numbers (`HeroRules`): how many a player may have, the experience a level takes, what bringing one back
-     * costs. The heroes pack's to change (`withHeroes(rules)`); the classic RTS numbers when left out
-     */
-    heroes: HeroRules;
+export interface RuleSettings {
+    /** What armies cost in supply, and how much a player may have (`SupplySettings`) */
+    supply: SupplySettings;
+    /** What buildings make and how they go up (`ProductionSettings`) */
+    production: ProductionSettings;
+    /** What is paid back, paid for and given away (`EconomySettings`) */
+    economy: EconomySettings;
+    /**
+     * What a hero may carry and how what it carries works (`ItemSettings`): the limits of groups of items (one pair of
+     * boots), unique passives counted once, the game's own rule of what may be carried
+     *
+     * @beta
+     */
+    items: ItemSettings;
+    /**
+     * Shops (`ShopSettings`): the seconds within which a purchase is taken back
+     *
+     * @beta
+     */
+    shop: ShopSettings;
+    /** How a hit lands and how much of it is felt, and who fights whom (`CombatSettings`) */
+    combat: CombatSettings;
+    /** How units find their way among each other (`MovementSettings`) */
+    movement: MovementSettings;
+    /** What is seen and kept of what was (`FogSettings`) */
+    fog: FogSettings;
+    /** Pings, chat and pauses (`TalkSettings`) */
+    talk: TalkSettings;
+    /**
+     * Creeps' camps (`camps.ts`, `CampSettings`): how far from its centre a camp fights (`leash`), how long a creep chases
+     * without a blow (`chaseTime`), how long after the last blow the camp goes home (`resetAfter`), whether all of it
+     * answers a hit at once (`helpAtOnce`), whether creeps sleep at home at night until attacked (`sleep`), and the
+     * seconds after a camp is cleared that it comes back (`respawn`; never when left out). What makes creeps keep to them,
+     * sleep and come back is the heroes pack's (`heroesPack`). See docs/creeps.md
+     */
+    camps: CampSettings;
+    /**
+     * Heroes' numbers (`HeroSettings`): how many a player may have, the experience a level takes, what bringing one back
+     * costs. The heroes pack's to change (`heroesPack(rules)`); the classic RTS numbers when left out
+     */
+    heroes: HeroSettings;
     /**
      * What of a unit the players who see it are told beyond what they always are (its health, mana, level, buffs and
      * their stacks), for the plates over it to show (indicators-plan U3): the seconds left of its buffs, its abilities,
@@ -116,12 +135,12 @@ export interface GameRules {
     hud: HudSharing;
     /**
      * What the game counts of its players for its score (a classic RTS score screen): kills, losses, damage, healing,
-     * resources, its own (`ScoreRules`, `presetScore()`, `defineStat`). Counted by the rules as the game goes, kept in
+     * resources, its own (`ScoreSettings`, `presetScore()`, `defineStat`). Counted by the rules as the game goes, kept in
      * saves, told to the players as it says. Nothing is counted when left out
      *
      * @beta
      */
-    score?: ScoreRules;
+    score?: ScoreSettings;
     /**
      * Whether a player may command an entity: its owner, and whoever the owner shares control with
      * (`world.sides.shareControl`, a force's `sharedControl`), when left out. What every command is checked against, and
@@ -130,17 +149,17 @@ export interface GameRules {
     mayCommand(world: World, player: PlayerId, entity: Entity): boolean;
 }
 /**
- * Supply (`GameRules.supply`)
+ * Supply (`RuleSettings.supply`)
  *
  * @beta
  */
-export interface SupplyRules {
+export interface SupplySettings {
     /** Supply no player can go past, however much they build to provide it */
     max: number;
     /**
      * Pools of supply besides the one there always is (`supply`, food), by name, each with what it is called and its
-     * most: a cap on commanders, on vehicles. A unit takes of one with `supplies`, a building provides with
-     * `suppliesProvided`. None when left out
+     * most: a cap on commanders, on vehicles. A unit takes of one with `supply`, a building provides with
+     * `supplyGiven`. None when left out
      */
     pools?: Record<string, {
         name: string;
@@ -153,11 +172,11 @@ export interface SupplyRules {
     of(world: World, unit: Entity | QueuedUnit): number;
 }
 /**
- * Production and construction (`GameRules.production`)
+ * Production and construction (`RuleSettings.production`)
  *
  * @beta
  */
-export interface ProductionRules {
+export interface ProductionSettings {
     /** Things a building can have waiting to be made */
     queue: number;
     /** Part of what a structure cost that comes back when it is called off while being built */
@@ -168,11 +187,11 @@ export interface ProductionRules {
     buildRate(world: World, structure: Entity, builders: number): number;
 }
 /**
- * Selling, repairing, giving and upkeep (`GameRules.economy`)
+ * Selling, repairing, giving and upkeep (`RuleSettings.economy`)
  *
  * @beta
  */
-export interface EconomyRules {
+export interface EconomySettings {
     /** Part of an item's price a shop pays for it */
     sellPrice: number;
     /** Part of what a building cost that mending all of its health costs */
@@ -183,15 +202,48 @@ export interface EconomyRules {
     upkeep(world: World, player: PlayerId): Upkeep;
 }
 /**
- * Fighting (`GameRules.combat`)
+ * What a hero may carry, and how what it carries works (`RuleSettings.items`)
+ *
+ * @beta
+ */
+export interface ItemSettings {
+    /**
+     * The most of a group of items (`ItemDef.group`) one carrier may have, by group: `{ boots: 1 }` when left out. An
+     * item's own `groupLimit` comes first; a group named nowhere is 1
+     */
+    groups: Record<string, number>;
+    /** Whether the passives of items sharing a `unique` name work once for all of them (yes), or each (no) */
+    unique: boolean;
+    /**
+     * The game's own rule of what a carrier may take, asked after the engine's (a group's limit) as it buys an item, picks
+     * one up or is handed one: a reason to refuse (a `MessageRef`, told to the player), nothing to let it. `uses` are
+     * the parts buying it uses up, by id (none for a pick-up or a hand-over). Everything may when left out
+     */
+    mayCarry?: (world: World, carrier: Entity, item: ItemDef, uses: readonly string[]) => MessageRef | undefined;
+}
+/**
+ * Shops (`RuleSettings.shop`): taking a purchase back
  *
  * @beta
  */
-export interface CombatRules {
+export interface ShopSettings {
+    /**
+     * Seconds within which a purchase is undone (`undoBuy`, the `undoBuy` command: the shop window's Undo) for all it
+     * cost, as long as the buyer stands at the shop still and has not used the item: what it took is given back, the
+     * parts it used up come back, the shop has it back in stock. 10 when left out; 0 for no undoing
+     */
+    undo: number;
+}
+/**
+ * Fighting (`RuleSettings.combat`)
+ *
+ * @beta
+ */
+export interface CombatSettings {
     /**
      * Whether a basic attack of `attacker` strikes critically, and what it multiplies the damage by then: a number for a
      * critical strike, nothing for none. Asked as the attack goes off, before whether it misses. None when left out (a
-     * game's crits: `withMobaStats`, or its own)
+     * game's crits: `mobaStatsPack`, or its own)
      */
     critical(world: World, attacker: Entity, stats: Readonly<Stats>): number | undefined;
     /**
@@ -199,11 +251,22 @@ export interface CombatRules {
      * of whoever deals it, when someone does. Armor and magic resist, with penetration, when left out
      */
     mitigation(type: DamageType, target: Readonly<Stats>, source?: Readonly<Stats>): number;
+    /**
+     * What damage is multiplied by once mitigated, before shields, for the stats of who takes it and of who deals it
+     * (when someone does): their `incomingDamage` (and of the type: `incomingMagicDamage`) and `outgoingDamage`, never
+     * below none, when left out (`damageScale`)
+     */
+    damageScale(type: DamageType, target: Readonly<Stats>, source?: Readonly<Stats>): number;
+    /**
+     * What healing is multiplied by, for the stats of who gets it, before the `beforeHeal` hook: its `incomingHealing`,
+     * never below none, when left out (`healingScale`)
+     */
+    healingScale(target: Readonly<Stats>, source?: Readonly<Stats>): number;
     /**
      * Keeps stats within what the game allows, once everything that changes them was added up. Changes them in place.
      * The default keeps attack speed within its limits (below)
      */
-    clampStats(stats: Stats, rules: Readonly<GameRules>): void;
+    clampStats(stats: Stats, rules: Readonly<RuleSettings>): void;
     /** Seconds an ability takes to be ready again, for a unit with these stats. Its cooldown as it is, when left out */
     cooldown(seconds: number, stats: Readonly<Stats>): number;
     /**
@@ -213,6 +276,18 @@ export interface CombatRules {
     slowTaken(stats: Readonly<Stats>, slow: number): number;
     /** What the heals and shields `source` gives are multiplied by. 1, when left out */
     healPower(world: World, source: Entity): number;
+    /**
+     * What a blow from up close of `attacker`'s weapon at that place cleaves: the part of its damage the enemies round
+     * `target` take, how far round it, how wide a cone. Its attack's own or a buff's, the larger part, when left out
+     * (`cleaveOf`); nothing for none
+     */
+    cleave(world: World, attacker: Entity, target: Entity, weapon: number): CleaveNow | undefined;
+    /**
+     * Which of what an attack of `attacker` sets off go off (its attack modifiers: the `onHit` of its abilities, items
+     * and buffs that can now), of those it is given, in their order. One a slot, the highest `priority`, and all of
+     * those of no slot, when left out (`bySlot`); `(world, attacker, target, modifiers) => modifiers` for all of them
+     */
+    attackModifiers(world: World, attacker: Entity, target: Entity, modifiers: readonly AttackModifier[]): readonly AttackModifier[];
     /** Nobody attacks slower or faster than this, whatever they carry: [lowest, highest] attack speed */
     attackSpeedLimits: [number, number];
     /** Seconds a corpse lies where a unit of flesh died, for spells to use (see `raiseDead`). None at all for 0 */
@@ -233,13 +308,6 @@ export interface CombatRules {
      * weapon for what is on the ground, a second for the air. Asked for every target looked at: keep it cheap
      */
     pickAttack(world: World, attacker: Entity, target: Entity): number;
-    /**
-     * What a hit is multiplied by for the attack's type against the target's armour type, as classic RTS games have it
-     * (pierce against light, siege against fortified), before armour and shields: none when left out. Attacks name
-     * their type (`AttackDef.attackType`), abilities as they deal damage (`DamageOptions.attackType`), unit types their
-     * armour (`UnitTypeDef.armourType`); a type the table has not got is refused as the game is made
-     */
-    damageTable?: DamageTable;
     /**
      * The layer an attacker fights from, around a target: room is counted apart for each (see `engageRoom`). The air
      * for what flies, the water for boats, the ground for the rest, when left out; any name of the game's own besides
@@ -257,13 +325,32 @@ export interface CombatRules {
      * when left out; Infinity never
      */
     giveUpChase(world: World, attacker: Entity, target: Entity): number;
+    /**
+     * How far from the middle of a target an attacker waits for room there, when it was told to attack it and it has no
+     * room for it or no way to it (`holdOff`): on its own side, out of the way of those fighting it. Just behind them
+     * when left out (`defaultQueueDistance`): the target's size, two of the attacker, its reach and half a cell
+     */
+    queueDistance(world: World, attacker: Entity, target: Entity): number;
+    /**
+     * Whether an order given to a unit in the recovery after its blow (`AttackDef.recovery`) cuts the recovery short and
+     * is carried out at once. Nothing is given back of the attack: its cooldown runs on. Never, when left out: the order
+     * waits until the recovery is over
+     */
+    recoveryCancels(world: World, entity: Entity): boolean;
+    /**
+     * How far from an ally that is hit an idle unit of the same owner comes to its help: it takes the attacker, as a
+     * camp's creeps do (`helpAtOnce`). Asked of each helper, with the ally hit: how far apart they are (centre to centre)
+     * it must be at most. Never more than `HELP_SEARCH` (20) is looked for. 0 turns it off. The helper's acquisition range
+     * and 4 more, when left out
+     */
+    helpRange(world: World, helper: Entity, victim: Entity): number;
 }
 /**
- * How units move among each other (`GameRules.movement`)
+ * How units move among each other (`RuleSettings.movement`)
  *
  * @beta
  */
-export interface MovementRules {
+export interface MovementSettings {
     /**
      * Whether an ally standing in the way of a unit on its way steps aside when asked (see `makeWay`). Those standing
      * about with nothing to do, or waiting by a fight for a spot in it, when left out: not those fighting, walking or
@@ -298,13 +385,19 @@ export interface MovementRules {
      * tick for every unit that moves: keep it cheap. Its speed as it is, when left out
      */
     moveSpeed(world: World, entity: Entity, speed: number): number;
+    /**
+     * How fast a unit turns, in radians a second, where its type says nothing of its own (`UnitTypeDef.turnRate`): on
+     * its way, to face what it attacks, works on or casts at. 12 when left out, which is all but at once (a half turn
+     * in a quarter of a second); 2 or 3 for units that visibly come round, as a classic RTS's do, less for ships
+     */
+    turnRate: number;
 }
 /**
- * Pings, chat and pauses (`GameRules.talk`)
+ * Pings, chat and pauses (`RuleSettings.talk`)
  *
  * @beta
  */
-export interface TalkRules {
+export interface TalkSettings {
     /**
      * Pings (see `ping`): how many a player may send `within` so many seconds, the kinds there are (a hero arena game's
      * when left out; a game adds its own), and what each kind asks of a computer ally (indicators-plan P4): a request on
@@ -331,65 +424,59 @@ export interface TalkRules {
         seconds: number;
     };
 }
-/**
- * A damage table: what a hit of each attack type is multiplied by against each armour type (`GameRules.combat.damageTable`).
- * `table[attack][armour]`, the rows the attacks in their order, the columns the armours in theirs
- *
- * @beta
- */
-export interface DamageTable {
-    attacks: readonly string[];
-    armours: readonly string[];
-    table: readonly (readonly number[])[];
-}
-/**
- * What a hit is multiplied by, by a damage table: 1 for no table, no attack type, no armour type, or one the table
- * has not got
- *
- * @beta
- */
-export declare function damageMultiplier(table: DamageTable | undefined, attackType: string | undefined, armourType: string | undefined): number;
-/**
- * Refuses a damage table that is not one, and a unit type whose attack or armour names a type the table has not got:
- * as the game is made, so that a misspelling fails then and not in a fight. A game without a table is checked for
- * nothing
- *
- * @beta
- */
-export declare function checkDamageTable(game: GameModule): void;
 /**
  * The engine's rules: those of a classic RTS melee game
  *
  * @beta
  */
-export declare const defaultRules: Readonly<GameRules>;
+export declare const defaultSettings: Readonly<RuleSettings>;
 /**
- * Creeps' camps' rules (`GameRules.camps`)
+ * Creeps' camps' rules (`RuleSettings.camps`)
  *
  * @beta
  */
-export interface CampRules {
-    /** How far creeps chase away from their camp */
+export interface CampSettings {
+    /**
+     * How far from the camp's centre its creeps fight, in cells: what goes past it is let go of, and a creep led past it
+     * turns back. 14 by default. A camp's own is `Camp.leash` (`spawnCamp`'s `leash`)
+     */
     leash: number;
+    /**
+     * Seconds a creep chases what has neither hit it nor been hit by it before it lets it go for the next of the camp's
+     * list (`Camp.aggro`): a kiting archer is not followed round the camp for ever. 5 by default. A camp's own is
+     * `Camp.chaseTime`
+     */
+    chaseTime: number;
+    /**
+     * Seconds without a blow (none of the camp's creeps hitting or hit) before the camp gives up the fight and goes home:
+     * until then its creeps wait where they stand for what comes next. 6 by default. A camp's own is `Camp.resetAfter`;
+     * `resetCamp` sends one home now
+     */
+    resetAfter: number;
+    /**
+     * Whether every creep of a camp answers a hit on one of them at once, as it lands, rather than at its next look round
+     * (every fourth tick). True by default. A camp's own is `Camp.helpAtOnce`
+     */
+    helpAtOnce: boolean;
     /** Whether creeps sleep at home at night, until attacked */
     sleep: boolean;
     /** Seconds after a camp is cleared that it comes back, for every camp (see `Camp.respawn`). Never when left out */
     respawn?: number;
 }
 /** What is said of a group of the rules: any of it, a group in it in part as well. A function, a list and a table whole */
-export type RulesPart<T> = T extends (...args: never[]) => unknown ? T : T extends readonly unknown[] ? T : T extends object ? {
-    [K in keyof T]?: RulesPart<T[K]>;
+export type SettingsPart<T> = T extends (...args: never[]) => unknown ? T : T extends readonly unknown[] ? T : T extends object ? {
+    [K in keyof T]?: SettingsPart<T[K]>;
 } : T;
 /**
- * What a game says of its rules (`GameModule.rules`), or a pack (`GamePack.rules`): any of them, a group in part
- * (`{ supply: { max: 200 } }`), the engine's for the rest. The damage table, the score and the HUD's sharing are
+ * What a game says of its rules (`Rules.settings`), or a pack (`GamePack.settings`): any of them, a group in part
+ * (`{ supply: { max: 200 } }`), the engine's for the rest. The score and the HUD's sharing are
  * given whole
  *
  * @beta
  */
-export type RulesInit = {
-    [K in Exclude<keyof GameRules, 'score' | 'hud'>]?: RulesPart<GameRules[K]>;
+export type RuleSettingsInit = {
+    [K in Exclude<keyof RuleSettings, 'score' | 'hud'>]?: SettingsPart<RuleSettings[K]>;
 } & {
-    score?: ScoreRules;
+    score?: ScoreSettings;
     hud?: HudSharing;
 };

package/dist/rules.js

@@ -0,0 +1,179 @@
+import { clamp } from "./math.js";
+import { supplyOf } from "./defs.js";
+import { orderSays } from "./orders/facts.js";
+import { damageScale, healingScale, mitigation } from "./stats.js";
+import { moving } from "./entity.js";
+import { defaultHeroSettings } from "./hero.js";
+import { defaultPickAttack, farthestAcquisition } from "./attacks.js";
+import { defaultEngageLayer, defaultEngageRoom, defaultQueueDistance } from "./engagement.js";
+import { UPHILL_MISS, cleaveOf, shootsUphill } from "./systems/combat.js";
+import { upkeepOf } from "./upkeep.js";
+import { groundSpeedAt } from "./groundSpeed.js";
+import { bySlot } from "./abilities/triggers.js";
+//#region src/rules.ts
+/**
+* The engine's rules: those of a classic RTS melee game
+*
+* @beta
+*/
+var defaultSettings = Object.freeze({
+	supply: {
+		max: 100,
+		pools: void 0,
+		of: (_world, unit) => supplyOf(unit.def)
+	},
+	production: {
+		queue: 7,
+		cancelRefund: .75,
+		constructionHealth: .1,
+		buildRate: (_world, _structure, builders) => 1 + (builders - 1) * .5
+	},
+	economy: {
+		sellPrice: .7,
+		repairCost: .35,
+		tradeTax: 0,
+		upkeep: (world, player) => upkeepOf(world, player)
+	},
+	items: {
+		groups: { boots: 1 },
+		unique: true,
+		mayCarry: void 0
+	},
+	shop: { undo: 10 },
+	combat: {
+		critical: () => void 0,
+		mitigation,
+		damageScale,
+		healingScale,
+		clampStats(stats, rules) {
+			const { attackSpeedLimits } = rules.combat;
+			if (stats.attackSpeed > 0) stats.attackSpeed = clamp(stats.attackSpeed, attackSpeedLimits[0], attackSpeedLimits[1]);
+		},
+		cooldown: (seconds) => seconds,
+		slowTaken: (_stats, slow) => slow,
+		healPower: () => 1,
+		cleave: cleaveOf,
+		attackModifiers: bySlot,
+		attackSpeedLimits: [.1, 5],
+		corpseTime: 60,
+		missChance: (world, attacker, target) => shootsUphill(world, attacker, target) ? UPHILL_MISS : 0,
+		splash: (_world, source, other, distance, radius) => other === source ? 0 : distance <= radius / 2 ? 1 : .5,
+		acquisitionRange: (_world, entity) => farthestAcquisition(entity.def),
+		pickAttack: defaultPickAttack,
+		engageLayer: defaultEngageLayer,
+		engageRoom: defaultEngageRoom,
+		giveUpChase: () => 1,
+		queueDistance: defaultQueueDistance,
+		recoveryCancels: () => false,
+		helpRange: (world, helper) => world.settings.combat.acquisitionRange(world, helper) + 4
+	},
+	movement: {
+		makesWay: (world, _mover, other) => other.get(moving)?.status !== "moving" && !other.get(moving)?.anchored && (other.orders.length === 0 || orderSays(world, other, "waiting")),
+		lookAhead: () => 3,
+		goesAround: (_world, _mover, _around, longer, straight) => longer <= 1.5 + straight * .25,
+		formation: () => "rows",
+		moveSpeed: (world, entity, speed) => speed * groundSpeedAt(world, entity),
+		turnRate: 12,
+		together: false
+	},
+	fog: {
+		nightSight: .6,
+		explored: void 0,
+		startExplored: void 0,
+		mask: void 0
+	},
+	talk: {
+		pings: {
+			most: 4,
+			within: 5,
+			kinds: [
+				"look",
+				"danger",
+				"assist",
+				"onMyWay"
+			],
+			meanings: {
+				danger: "help",
+				assist: "help",
+				push: "attack",
+				hold: "defend",
+				retreat: "rally"
+			}
+		},
+		lines: {
+			most: 5,
+			within: 5,
+			length: 160
+		},
+		pauses: {
+			each: 3,
+			seconds: 60
+		}
+	},
+	camps: {
+		leash: 14,
+		chaseTime: 5,
+		resetAfter: 6,
+		helpAtOnce: true,
+		sleep: true,
+		respawn: void 0
+	},
+	heroes: defaultHeroSettings,
+	hud: {},
+	score: void 0,
+	mayCommand: (world, player, entity) => entity.owner === player || world.sides.controlOf(entity.owner).includes(player)
+});
+/** Whether a value is a group of the rules to be laid over in part: a plain object of named parts, not a table or a list */
+var isGroup = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+/**
+* Lays what is said of rules over rules, group by group: a group of named parts (`supply`, `talk.pings`) part by part,
+* everything else whole. A name the rules have not got is refused: a typo would otherwise change nothing, without a word
+*
+* @internal
+*/
+function laySettings(under, over, path = "") {
+	const laid = { ...under };
+	for (const [key, value] of Object.entries(over)) {
+		if (value === void 0) continue;
+		if (!(key in under)) throw new Error(`"${path}${key}" is not a game rule`);
+		const before = under[key];
+		laid[key] = isGroup(before) && Object.keys(before).length && isGroup(value) ? laySettings(before, value, `${path}${key}.`) : value;
+	}
+	return laid;
+}
+/**
+* What is said of rules laid over what was said before (a pack's over the game's, a mod's over the game's), group by
+* group as `laySettings` does, neither of them whole
+*
+* @internal
+*/
+function overSettings(under, over) {
+	const laid = { ...under };
+	for (const [key, value] of Object.entries(over)) {
+		if (value === void 0) continue;
+		const before = laid[key];
+		laid[key] = isGroup(before) && isGroup(value) ? overSettings(before, value) : value;
+	}
+	return laid;
+}
+/**
+* The names of the rules what is said of them changes, group by group (`supply.max`, `talk.pings.most`): what two
+* mods are found to both change by
+*
+* @internal
+*/
+function rulesSaid(said, path = "") {
+	return Object.entries(said).flatMap(([key, value]) => value === void 0 ? [] : isGroup(value) && Object.keys(value).length ? rulesSaid(value, `${path}${key}.`) : [`${path}${key}`]);
+}
+/**
+* The rules of a game: what its module changes, over the engine's
+*
+* @internal
+*/
+function resolveSettings(changes = {}) {
+	return Object.freeze(laySettings(defaultSettings, changes));
+}
+//#endregion
+export { defaultSettings, laySettings, overSettings, resolveSettings, rulesSaid };
+
+//# sourceMappingURL=rules.js.map