Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

14.8 KB
Raw Blame

API surface — esengine/worldgen

Symbols: 0 public · 0 beta · 71 experimental · 0 deprecated

BiomeCondition — interface @experimental

blend: number | undefined
field: string
max: number | undefined
min: number | undefined

BiomeDef — interface @experimental

conditions: readonly BiomeCondition[]
id: string
paint: readonly number[] | undefined
paintStrength: number | undefined
recipes: readonly BiomeRecipe[]
transition: number | undefined
weight: number | undefined

BiomeRecipe — interface @experimental

density: number
layer: string
recipe: string

Environment — class @experimental

inputs: EnvironmentInputs
sample: (x: number, z: number) => FieldValues
static new (inputs: EnvironmentInputs): Environment
static prototype: Environment

EnvironmentInputs — interface @experimental

fields: Record<string, FieldFn> | undefined
ground: (x: number, z: number) => { y: number; up: number; normal?: [number, number, number]; } | null
noise: Partial<Record<string, NoiseField>> | undefined
overrides: ((x: number, z: number) => { field: string; value: number; weight: number; }[]) | undefined
seed: number
shoreDistance: ((x: number, z: number) => number | null) | undefined
space: ((x: number, z: number) => readonly [number, number, number]) | undefined
waterDepth: ((x: number, z: number, y: number) => number | null) | undefined

FaceZones — class @experimental

face: PlanetFace
sync: (world: Iterable<ZoneDef>) => void
zones: Zones
static new (face: PlanetFace): FaceZones
static prototype: FaceZones

FieldFn — type @experimental

(x: number, z: number, at: Readonly<FieldValues>) => number

FieldValues — type @experimental

Record<string, number>

GroundFit — interface @experimental

buriedDepth: number
max: number
mean: number
min: number
relief: number
samples: number
supportDepth: number
y: number

GroundFitResult — type @experimental

{ ok: true; fit: GroundFit } | { ok: false; reason: 'noGround' | 'slope' | 'water' | 'relief' }

GroundingOptions — interface @experimental

maxRelief: number | undefined
mode: "center" | "highest" | "lowest" | "mean" | undefined
offset: number | undefined
samples: number | undefined
size: readonly [number, number]

Group — interface @experimental

anchor: Placement
id: string
layer: string
members: Placement[]
priority: number
radius: number
x: number
z: number

NoiseField — interface @experimental

octaves: number | undefined
scale: number

PlacedObject — const @experimental

ComponentDef<PlacedObjectData>

PlacedObjectData — interface @experimental

id: string
kind: string

Placement — interface @experimental

attach: "align" | "upright"
biome: string
canopy: number
far: { u0: number; v0: number; u1: number; v1: number; tent?: boolean; } | null | undefined
footprint: number
grounding: GroundFit | undefined
group: string
id: string
interactive: string | null
layer: string
material: number
member: string
mesh: number
normal: [number, number, number]
plant: string | null
recipe: string
recipeVersion: number
scale: number
up: [number, number, number] | undefined
x: number
y: number
yaw: number
z: number
zone: string | null

Placement2D — interface @experimental

biome: string
canopy: number
footprint: number
group: string
id: string
interactive: string | null
layer: string
member: string
plant: string | null
recipe: string
scale: number
x: number
y: number
yaw: number
zone: string | null

PlacementChange — interface @experimental

scale: number | undefined
x: number | undefined
y: number | undefined
yaw: number | undefined
z: number | undefined

PlacementDiffs — class @experimental

change: (id: string, change: PlacementChange) => void
changeOf: (id: string) => PlacementChange | undefined
isRemoved: (id: string) => boolean
load: (data: PlacementDiffsData) => void
onChange: ((id: string) => void) | null
remove: (id: string) => void
restore: (id: string) => void
revision: number
subscribe: (listener: NonNullable<PlacementDiffs["onChange"]>) => () => void
toJSON: () => PlacementDiffsData
static new (): PlacementDiffs
static prototype: PlacementDiffs

PlacementDiffsData — interface @experimental

changed: Record<string, PlacementChange>
removed: string[]
version: 1

PlacementLayer — interface @experimental

chunkSize: number | undefined
drawDistance: number
farSpacing: number | undefined
id: string
lodDistance: number | undefined
occupies: boolean | undefined
spacing: number
version: number | undefined

PlaneFrame — interface @experimental

dir: [number, number, number]
eu: [number, number, number]
ev: [number, number, number]

PlanetFace — class @experimental

directionAt: (x: number, z: number) => [number, number, number]
environment: () => Pick<EnvironmentInputs, "ground" | "space">
face: number
fieldsAt: (x: number, z: number) => readonly number[] | null
frameAt: (x: number, z: number) => PlaneFrame
ground: (x: number, z: number) => { y: number; up: number; normal: [number, number, number]; } | null
paintAt: (x: number, z: number) => readonly number[] | null
planeOf: (dx: number, dy: number, dz: number) => { x: number; z: number; } | null
planet: () => PlanetFacts | null
sourcesOnFace: (sources: Iterable<{ x: number; y?: number; z: number; }>, reach: number) => { x: number; z: number; }[]
world: (x: number, y: number, z: number) => [number, number, number]
worldNormal: (normal: readonly [number, number, number], x: number, z: number) => [number, number, number]
zoneOnFace: (zone: ZoneDef) => ZoneDef | null
static new (face: number, planet: () => PlanetFacts | null): PlanetFace
static prototype: PlanetFace

Recipe — interface @experimental

anchor: RecipeMember
id: string
members: readonly RecipeMember[] | undefined
tags: readonly string[] | undefined
version: number

RecipeMember — interface @experimental

arc: readonly [number, number] | undefined
attach: "align" | "upright" | undefined
canopy: number | undefined
chance: number | undefined
count: readonly [number, number] | undefined
far: { u0: number; v0: number; u1: number; v1: number; tent?: boolean; } | undefined
footprint: number
grounding: GroundingOptions | undefined
id: string
interactive: string | undefined
material: string | number | undefined
mesh: string | number | undefined
minUp: number | undefined
plant: string | undefined
ring: readonly [number, number] | undefined
scale: readonly [number, number] | undefined
scaleFootprint: boolean | undefined
tags: readonly string[] | undefined
waterDepth: number | undefined

Rejection — type @experimental

'noBiome' | 'density' | 'noGround' | 'slope' | 'water' | 'relief' | 'zone' | 'occupied' | 'conflict'

RoadOptions — interface @experimental

biome: string | undefined
clearance: number | undefined
excludes: readonly string[] | undefined
falloff: number | undefined
fields: Readonly<Record<string, number>> | undefined
id: string
points: readonly (readonly [number, number])[]
priority: number | undefined
width: number

World2D — interface @experimental

biomeAt: (x: number, y: number) => string | null
diffs: PlacementDiffs
dispose: () => void
plan: WorldPlan
status: () => { ready: number; pending: number; failed: number; }

World2DChunk — interface @experimental

biomeGrid: Uint8Array<ArrayBufferLike>
biomes: readonly string[]
cellSize: number
cells: number
cx: number
cy: number
placements: Placement2D[]
size: number
x0: number
y0: number

World2DOptions — interface @experimental

cellSize: number | undefined
chunkSize: number | undefined
diffs: PlacementDiffs | undefined
loadRadius: number | undefined
publish: (chunk: World2DChunk) => (() => void) | void
rules: string | WorldRules
seed: number | undefined
sources: (() => Iterable<{ x: number; y: number; }>) | undefined
unloadRadius: number | undefined
world: string | undefined
zones: readonly ZoneDef[] | undefined

WorldGen — const @experimental

ComponentDef<WorldGenData>

WorldGenData — interface @experimental

paintGround: boolean
rules: string
seaLevel: number
seed: number
surface: number
version: number
world: string

WorldGenPlugin — class @experimental

build: (app: App) => void
cleanup: (app?: App) => void
name: string
static new (): WorldGenPlugin
static prototype: WorldGenPlugin

WorldGenRes — const @experimental

ResourceDef<WorldGens>

WorldGenStatus — interface @experimental

layers: Record<string, ChunkLayerStatus>
reason: string | undefined
state: "failed" | "loading" | "ready"

WorldGens — class @experimental

@internal app_: App | null
@internal authored_: Map<string, Set<string>>
@internal built_: Map<number, BuiltWorld>
@internal levelled_: Map<string, { signature: string; owners: Set<BuiltWorld>; }>
@internal objects_: Map<string, number>
diffs: (world?: string) => PlacementDiffs
objectOf: (id: string) => Entity | null
plan: (entity?: Entity) => WorldPlan | null
status: (entity: Entity) => WorldGenStatus | null
zones: (world?: string) => Zones
static new (): WorldGens
static prototype: WorldGens

WorldPlan — class @experimental

biomeAt: (x: number, z: number) => string | null
biomeWeights: (x: number, z: number) => { biome: string; weight: number; }[]
env: Environment
explain: (x: number, z: number) => { fields: FieldValues; biomes: { biome: string; weight: number; }[]; zones: { id: string; kind: string; weight: number; }[]; layers: { layer: string; cell: [number, number]; group: string | null; rejected: Rejection | null; detail?: string; }[]; }
group: (li: number, gx: number, gz: number) => Group | Rejection
groupsIn: (layer: string, x0: number, z0: number, x1: number, z1: number) => Group[]
invalidate: () => void
layerIndex: (id: string) => number
paint: (x: number, z: number, base: readonly number[]) => number[]
placementsIn: (x0: number, z0: number, x1: number, z1: number, layers?: readonly string[]) => Placement[]
rules: WorldRules
seed: number
stats: (layer: string, x0: number, z0: number, x1: number, z1: number) => Record<"placed" | Rejection, number>
world: string
zones: Zones
static new (rules: WorldRules, env: Environment, zones: Zones, seed: number, world: string): WorldPlan
static prototype: WorldPlan

WorldRules — interface @experimental

biomes: readonly BiomeDef[]
fields: Record<string, FieldFn> | undefined
id: string
layers: readonly PlacementLayer[]
noise: Partial<Record<string, NoiseField>> | undefined
plants: Readonly<Record<string, PlantKind>> | undefined
recipes: readonly Recipe[]
versions: readonly number[]

WorldRulesAssetLoader — class @experimental

extensions: string[]
load: (path: string, ctx: LoadContext) => Promise<WorldRules>
type: "world-rules"
unload: () => void
static new (): WorldRulesAssetLoader
static prototype: WorldRulesAssetLoader

WorldSurface — const @experimental

{ readonly Plane: 0; readonly Planet: 1; }

WorldZone — const @experimental

ComponentDef<WorldZoneData>

WorldZoneData — interface @experimental

biome: string
excludes: string
falloff: number
flatten: boolean
kind: string
priority: number
radius: number
shape: number
sizeX: number
sizeZ: number

ZoneDef — interface @experimental

biome: string | undefined
excludes: readonly string[]
falloff: number
fields: Readonly<Record<string, number>> | undefined
flatten: number | "ground" | undefined
id: string
kind: string
priority: number
shape: ZoneShape

ZoneShape — type @experimental

| { type: 'circle'; x: number; z: number; radius: number; y?: number }
    | { type: 'rect'; x: number; z: number; halfX: number; halfZ: number; yaw?: number; y?: number; facing?: readonly [number, number, number] }

ZoneShapeKind — const @experimental

{ readonly Circle: 0; readonly Box: 1; }

Zones — class @experimental

all: () => IterableIterator<ZoneDef>
at: (x: number, z: number, reach?: number) => { zone: ZoneDef; weight: number; }[]
delete: (id: string) => void
excluding: (x: number, z: number, radius: number, tags: readonly string[], seed: number) => ZoneDef | null
get: (id: string) => ZoneDef | undefined
onChange: ((bounds: [number, number, number, number], zone: ZoneDef) => void) | null
revision: number
set: (zone: ZoneDef) => void
subscribe: (listener: NonNullable<Zones["onChange"]>) => () => void
static new (): Zones
static prototype: Zones

bandWeight — function @experimental

(c: BiomeCondition, v: number): number

createWorld2D — function @experimental

(app: App, id: string, options: World2DOptions): World2D

faceHalf — const @experimental

(radius: number) => number

faceUnit — const @experimental

(radius: number) => number

fbm — function @experimental

(x: number, z: number, seed: number, octaves: number): number

fbm3 — function @experimental

(x: number, y: number, z: number, seed: number, octaves: number): number

fitGroundFootprint — function @experimental

(inputs: Pick<EnvironmentInputs, "ground" | "waterDepth">, x: number, z: number, yaw: number, scale: number, options: GroundingOptions, limits?: { minUp?: number; waterDepth?: number; }): GroundFitResult

hash01 — function @experimental

(...v: number[]): number

hashString — function @experimental

(s: string): number

isRulesFile — function @experimental

(ref: string): boolean

parseWorldRules — function @experimental

(json: unknown, file?: string): WorldRules

placement2D — function @experimental

(p: Placement): Placement2D

planetFaces — function @experimental

(planet: () => PlanetFacts | null): PlanetFace[]

registerWorldRules — function @experimental

(rules: WorldRules): void

removeRoad — function @experimental

(zones: Zones, id: string): void

roadZones — function @experimental

(options: RoadOptions): ZoneDef[]

setRoad — function @experimental

(zones: Zones, options: RoadOptions): void

streamingPoints2D — function @experimental

(app: App): { x: number; y: number; }[]

validateGrounding — function @experimental

(options: GroundingOptions): void

world2dChunk — function @experimental

(plan: WorldPlan, diffs: PlacementDiffs, cx: number, cy: number, size: number, cells: number): { chunk: World2DChunk; ids: string[]; }

worldGenPlugin — const @experimental

Plugin

worldRules — function @experimental

(id: string): WorldRules | undefined

zoneBounds — function @experimental

(zone: ZoneDef): [number, number, number, number]

zoneDistance — function @experimental

(shape: ZoneShape, x: number, z: number): number

zoneWeight — function @experimental

(zone: ZoneDef, d: number): number