export type ArcanePoint = readonly [number, number];
export type ArcaneBox = Readonly<{
    minX: number;
    minZ: number;
    maxX: number;
    maxZ: number;
}>;
/** The strip's chunk rows the land uses (the rest of the strip is open sea): rows 4-11, world z 128-383. */
export declare const ARCANE_STRIP_CHUNK_Z = 4;
export declare const ARCANE_STRIP_CHUNKS_Z = 8;
export declare const ARCANE_STRIP_MIN_Z: number;
export declare const ARCANE_STRIP_MAX_Z: number;
/** The land's size in tiles, and where its local (0, 0) sits in the world: centred in the strip's rows. */
export declare const ARCANE_LAND_W = 300;
export declare const ARCANE_LAND_H = 200;
export declare const ARCANE_LAND_X: number;
export declare const ARCANE_LAND_Z: number;
export declare const ARCANE_LANDS_NAME = "The Arcane Realms";
/** Local to world, and back. */
export declare function arcaneWorld(lx: number, lz: number): {
    x: number;
    z: number;
};
export declare function arcaneLocal(x: number, z: number): {
    x: number;
    z: number;
};
/** Is a world tile inside the land's own 300 x 200 frame (sea margin excluded)? */
export declare function inArcaneFrame(x: number, z: number): boolean;
/** Is a tile centre inside a tile-corner polygon (local or world, as long as both agree)? */
export declare function inArcanePolygon(x: number, z: number, poly: readonly ArcanePoint[]): boolean;
export declare function inArcaneBox(x: number, z: number, b: ArcaneBox, margin?: number): boolean;
/** Distance from a tile centre to a polyline through tile centres. */
export declare function distToArcanePolyline(x: number, z: number, pts: readonly ArcanePoint[]): number;
/**
 * The coast, clockwise from the south-west. The bay in the north middle is the Spire's: the floating city hangs over
 * it, its beam on the headland's platform. The south coast's middle is the Northern Gate's forecourt.
 */
export declare const ARCANE_OUTLINE: readonly ArcanePoint[];
export type ArcanePlateau = {
    id: string;
    name: string;
    poly: readonly ArcanePoint[];
    /** Height of its top (terrain steps, HEIGHT_STEP each). */
    height: number;
    /**
     * 'cliff': every edge onto lower ground is a sheer, blocked rim of grey rock (the ways up are ramps). 'slope': its
     * inland edges grade down a step a tile, only its coast is cliff.
     */
    edge: 'cliff' | 'slope';
};
/**
 * The raised ground: the local views' layered terraces of grey faceted cliff. The Crystal Lakes sit on a high terrace
 * whose outlet falls to the Silverrun; the Arcanum stands on a walled terrace entered by four cut ramps; Zephyr Cliffs
 * are climbed by the ramp only; Rune Fields grade up from the west road.
 */
export declare const ARCANE_PLATEAUS: readonly ArcanePlateau[];
/** Knolls: round hills graded a step a tile, laid over whatever ground is under them. */
export type ArcaneKnoll = {
    id: string;
    x: number;
    z: number;
    top: number;
    flat: number;
};
export declare const ARCANE_KNOLLS: readonly ArcaneKnoll[];
/**
 * Frostveil Peaks, the far range in the north-east: snow foothills in the zone, peaks as cones on top. Ground above
 * ARCANE_PEAK_SOLID_H is mountain (solid); below it the snow is walkable.
 */
export declare const FROSTVEIL_ZONE: readonly ArcanePoint[];
export declare const FROSTVEIL_FOOTHILL_H = 6;
export declare const ARCANE_PEAK_SOLID_H = 12;
export type ArcanePeak = {
    x: number;
    z: number;
    height: number;
    slope: number;
};
export declare const FROSTVEIL_PEAKS: readonly ArcanePeak[];
/** The Northern Pass's two rock shoulders either side of the road up from the gate: solid crag ridges. */
export declare const NORTHERN_PASS_SHOULDERS: readonly (readonly ArcanePoint[])[];
export declare const NORTHERN_PASS_SHOULDER_H = 9;
/** The wall the Northern Gate stands in (the Arcane Wall Segments): one row, either side of the gate. */
export declare const NORTHERN_WALL: {
    readonly z: 192;
    readonly west: readonly [116, 143];
    readonly east: readonly [157, 184];
    readonly height: 3;
};
/** Lakes: water (at `height`, sea level unless given) in a bank that grades up a step a tile. */
export type ArcaneLake = {
    id: string;
    name: string;
    poly: readonly ArcanePoint[];
    height?: number;
};
export declare const ARCANE_LAKES: readonly ArcaneLake[];
/** Islands: land kept out of a lake. The Runed Lake's island holds the Stone Circle, its obelisks and its beam. */
export declare const ARCANE_ISLANDS: ReadonlyArray<{
    id: string;
    poly: readonly ArcanePoint[];
}>;
/** Rivers: water at `height` (sea level, or on a terrace at most its top). */
export type ArcaneRiver = {
    id: string;
    pts: readonly ArcanePoint[];
    halfWidth: number;
    height: number;
};
export declare const ARCANE_RIVERS: readonly ArcaneRiver[];
/**
 * The Rift: a chasm split into the north of Zephyr Cliffs, sheer to dark water at sea level. Floating rocks hang over
 * it (ARCANE_FLOATING_ROCKS).
 */
export declare const THE_RIFT: readonly ArcanePoint[];
/** Roads, laid as Path three tiles wide. Each runs from a stop to the next; the main road is the spine. */
export type ArcaneRoad = {
    id: string;
    pts: readonly ArcanePoint[];
    halfWidth: number;
};
export declare const ARCANE_ROADS: readonly ArcaneRoad[];
/**
 * Bridges: stone decks over the water a road crosses, level with the banks, parapets on their outer rows with a
 * torch pier every six tiles (the Capital's stonebridge kit: the Great Stone Bridge Segment and Bridge Pillar
 * placeholders). `axis` is the way the road runs across.
 */
export type ArcaneBridge = {
    id: string;
    name: string;
    axis: 'ns' | 'ew';
    box: ArcaneBox;
    height: number;
};
export declare const ARCANE_BRIDGES: readonly ArcaneBridge[];
/** Ramps: a road cut up a cliff a step every tile or two, walled either side. `from` is the foot, `to` on top. */
export type ArcaneRamp = {
    id: string;
    from: ArcanePoint;
    to: ArcanePoint;
    halfWidth: number;
};
export declare const ARCANE_RAMPS: readonly ArcaneRamp[];
/**
 * Waterfalls: the frontend's waterfall model (origin at its pool, crown 8 steps up), one where each terrace stream
 * goes over its edge. The builder walks from the stream's last point the way it falls to the first water below and
 * stands the model on that pool tile, scaled to the drop (drop / 8).
 */
export type ArcaneWaterfall = {
    id: string;
    stream: string;
    facing: 'n' | 'e' | 's' | 'w';
};
export declare const ARCANE_WATERFALLS: readonly ArcaneWaterfall[];
/**
 * The sea coast is cliff (a stone rim two tiles deep, crags on its lip) except on these beaches, where the shore
 * grades to sand.
 */
export declare const ARCANE_BEACHES: ReadonlyArray<ArcaneBox & {
    id: string;
}>;
/** Eldergrove: the old wood in the west, planted thick (the road to the Observatory runs through it). */
export declare const ELDERGROVE: readonly ArcanePoint[];
/** The Arcanum's plaza: paved, round, in the middle of the town, the fountain in its middle. */
export declare const ARCANUM_PLAZA: {
    readonly x: 150;
    readonly z: 86;
    readonly radius: 8;
    readonly height: 7;
};
export type ArcaneStop = {
    id: string;
    name: string;
    /** 1-5 for the five stops in walking order; 0 for the side places. */
    order: number;
    /** Where a teleport stands you (local). */
    stand: ArcanePoint;
    what: string;
};
export declare const ARCANE_STOPS: readonly ArcaneStop[];
export declare function arcaneStop(id: string): ArcaneStop;
/** Where a teleport into the land puts you: the Northern Pass's stand, inside the gate. */
export declare const ARCANE_ARRIVAL: {
    x: number;
    z: number;
};
/**
 * The 35 pieces of the Arcane Realms asset sheet (ChatGPT, 2026-10-08, `ASSET-SHEET-35-pieces.png` in the build's task
 * folder): the names phase 2's Blender kit builds to. Every building and prop phase 1 places names the piece it stands
 * in for (`asset`), so the kit replaces them one to one.
 */
export declare const ARCANE_ASSET_PIECES: readonly ["northern-gate-portal", "arcane-wall-segment", "watch-post", "spire-beacon", "great-stone-bridge-segment", "bridge-pillar", "stone-path-tile", "rope-bridge", "cliff-stairs", "floating-rock-cluster", "runed-obelisk", "stone-circle-monolith", "runed-pedestal", "waystone", "lake-shrine", "zephyr-arch", "arcane-lamp", "crystal-outcrop", "crystal-cluster", "blue-roof-hall", "apprentice-hut", "arcanum-house", "mage-stall", "arcane-forge", "crafting-bench", "rune-banner", "runed-lake-dock", "lake-edge-tile", "terrain-rock", "evergreen-tree", "arcane-tree", "hedge-bush", "flower-bed", "wooden-fence", "market-canopy"];
export type ArcaneAssetPiece = (typeof ARCANE_ASSET_PIECES)[number];
/**
 * What stands in for each piece today (kind and style, the existing kit), so the review and phase 2 see the mapping in
 * one place. Pieces with no stand-in yet are `slot`: phase 1 keeps their ground clear (ARCANE_SLOTS) and places nothing.
 */
export declare const ARCANE_PLACEHOLDERS: Readonly<Record<ArcaneAssetPiece, string>>;
/**
 * The large shapes, from the kits that exist today: the Capital's three.js keep, manors, temple, gatehouse, towers
 * and fountain, the woods' hooded statues and arch, the market's stalls. PHASE 1 PLACEHOLDERS: phase 2 (the Blender
 * kit) replaces each with its `asset` piece. `x`, `z` are local; the style's last letter faces it.
 */
export type ArcaneBuilding = {
    id: string;
    name: string;
    asset: ArcaneAssetPiece;
    kind: string;
    style: string;
    x: number;
    z: number;
    scale?: number;
    /** Ground under it is levelled to this height (and a walk-in's inside floored). */
    level?: number;
};
export declare const ARCANE_BUILDINGS: readonly ArcaneBuilding[];
/** Slots phase 2 fills (kept clear now): the pieces with no stand-in. */
export declare const ARCANE_SLOTS: ReadonlyArray<{
    asset: ArcaneAssetPiece;
    x: number;
    z: number;
    note: string;
}>;
/** The Stone Circle on the Rune Isle: rune stones round a medallion, five runed obelisks outside the ring. */
export declare const STONE_CIRCLE: {
    readonly x: 191;
    readonly z: 139;
    readonly radius: 5;
    readonly stones: 8;
    readonly obelisks: 5;
    readonly obeliskRadius: 8.5;
};
/** The Spire's pad: a paved round platform on the headland, the beam's foot at its centre. */
export declare const SPIRE_LANDING: {
    readonly x: 150;
    readonly z: 38;
    readonly radius: 6;
    readonly height: 5;
};
/** The summit shrine on Zephyr Cliffs: a pedestal and obelisks, a crystal floating over it (client sky). */
export declare const ZEPHYR_SHRINE: {
    readonly x: 272;
    readonly z: 96;
};
/**
 * The sky (drawn by the client only while you are in the land, no collision): the floating city over the bay with its
 * beam to the pad, the Rune Isle's beam, the floating rocks and the shrine's crystal. `alt` is world units above the
 * sea; `size` its radius in tiles. The game camera looks down, so the city hangs low enough to be in frame from the
 * Arcanum's north road and the pad when the camera is lowered.
 */
export declare const ARCANE_SPIRE: {
    readonly x: 150;
    readonly z: 26;
    readonly alt: 20;
    readonly size: 26;
};
export type ArcaneBeam = {
    id: string;
    x: number;
    z: number;
    footHeight: number;
    top: number;
    radius: number;
};
export declare const ARCANE_BEAMS: readonly ArcaneBeam[];
export type ArcaneFloatingRock = {
    x: number;
    z: number;
    alt: number;
    size: number;
    crystal?: boolean;
};
export declare const ARCANE_FLOATING_ROCKS: readonly ArcaneFloatingRock[];
export declare const ARCANE_SKY_CRYSTALS: ReadonlyArray<{
    x: number;
    z: number;
    alt: number;
}>;
/** Every stop, world tiles: for teleports and smokes. */
export declare function arcaneStopWorld(stop: ArcaneStop): {
    x: number;
    z: number;
};
//# sourceMappingURL=arcaneLands.d.ts.map