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.

9.8 KB
Raw Blame

API surface — esengine/gameplay

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

ATTACK_KEY — const @experimental

"KeyJ"

COMBAT_ATTACK_END — const @experimental

"attack-end"

COMBAT_ATTACK_START — const @experimental

"attack-start"

COMBAT_HIT — const @experimental

"hit"

DODGE_KEY — const @experimental

"ShiftLeft"

Damage — const @experimental

EventDef<DamagePayload>

DamagePayload — interface @experimental

amount: number
source: number
target: number
x: number
y: number
z: number

FirstPersonController — const @experimental

ComponentDef<FirstPersonControllerData>

FirstPersonControllerData — interface @experimental

acceleration: number
airControl: number
airTime: number
camera: number
coyoteTime: number
crouchEyeHeight: number
crouchHalfHeight: number
crouchMultiplier: number
crouching: boolean
deceleration: number
enabled: boolean
eye: number
eyeHeight: number
eyeSpeed: number
gravityScale: number
jumpBuffer: number
jumpHeld: number
jumpSpeed: number
jumped: boolean
lookSensitivity: number
moveSpeed: number
pitch: number
pitchMax: number
pitchMin: number
pointerLock: boolean
rebuild: number
sprintMultiplier: number
standHalfHeight: number
touchLook: boolean
touchLookFrom: number
touchSensitivity: number
yaw: number

FirstPersonViewModel — const @experimental

ComponentDef<FirstPersonViewModelData>

FirstPersonViewModelData — interface @experimental

farPlane: number
fov: number
layer: number
nearPlane: number

GameplayPlugin — class @experimental

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

GridCell — interface @experimental

col: number
row: number

Health — const @experimental

ComponentDef<HealthData>

HealthData — interface @experimental

current: number
max: number

Hunter — const @experimental

ComponentDef<HunterData>

HunterData — interface @experimental

attackInterval: number
attackRange: number
cooldown: number
enabled: boolean
idleThreshold: number
rotationSpeed: number
state: string

HunterSituation — interface @experimental

alive: boolean
attackRange: number
distance: number
visible: boolean

HunterState — type @experimental

'idle' | 'chase' | 'attack' | 'dead'

MeleeAttack — const @experimental

ComponentDef<MeleeAttackData>

MeleeAttackData — interface @experimental

anchor: number
attackId: number
damage: number
enabled: boolean
hitCount: number
layers: number
radius: number

MeleeAttacks — class @experimental

clear: () => void
close: (entity: Entity) => void
forget: (entity: Entity) => void
live: (entity: Entity) => { id: number; hits: number; } | null
open: (entity: Entity) => number
record: (entity: Entity, target: Entity) => boolean
static new (): MeleeAttacks
static prototype: MeleeAttacks

MeleeOverlapQuery — interface @experimental

overlapSphere: (centre: { x: number; y: number; z: number; }, radius: number, layerMask?: number) => readonly Overlap3DHit[]

MoveBasis — interface @experimental

forward: Vec3
right: Vec3

NearEntity — interface @experimental

distance: number
entity: number
x: number
y: number

NearestOptions — interface @experimental

filter: ((entity: Entity, data: D) => boolean) | undefined
limit: number | undefined
plane: "xy" | "xz" | undefined
radius: number | undefined

PlacementCheck — interface @experimental

blockedCells: GridCell[]
blockers: number[]
clear: boolean

PlacementGrid — interface @experimental

cellHeight: number
cellWidth: number
originX: number | undefined
originY: number | undefined

PlacementProbes — interface @experimental

blocked: ((col: number, row: number) => boolean) | undefined
ignore: ReadonlySet<number> | undefined
mask: number | undefined
physics: { overlapAABB(min: { x: number; y: number; }, max: { x: number; y: number; }, maskBits?: number): Entity[]; } | undefined
solidAt: ((x: number, y: number) => boolean) | undefined
solidStep: number | undefined

PlacementRect — interface @experimental

maxX: number
maxY: number
minX: number
minY: number

SnappedFootprint — interface @experimental

col: number
cols: number
rect: PlacementRect
row: number
rows: number
x: number
y: number

TPC_ATTACK — const @experimental

"attack"

TPC_DODGE — const @experimental

"dodge"

TPC_GROUNDED — const @experimental

"grounded"

TPC_JUMP — const @experimental

"jump"

TPC_SPEED — const @experimental

"speed"

ThirdPersonCamera — const @experimental

ComponentDef<ThirdPersonCameraData>

ThirdPersonCameraData — interface @experimental

distance: number
enabled: boolean
followDamping: number
maxPitch: number
minPitch: number
obstruction: boolean
obstructionLayers: number
obstructionRadius: number
pitch: number
sensitivity: number
target: number
targetOffset: Vec3
yaw: number

ThirdPersonController — const @experimental

ComponentDef<ThirdPersonControllerData>

ThirdPersonControllerData — interface @experimental

acceleration: number
airControl: number
camera: number
cameraRelative: boolean
deceleration: number
enabled: boolean
idleThreshold: number
jumpSpeed: number
moveSpeed: number
rotationSpeed: number

WORLD_BASIS — const @experimental

MoveBasis

applyDamage — function @experimental

(world: World, blows: Iterable<DamagePayload>): void

approachVelocity — function @experimental

(current: { x: number; z: number; }, target: { x: number; z: number; }, acceleration: number, deceleration: number, dt: number): { x: number; z: number; }

cameraGroundBasis — function @experimental

(yawDeg: number): { forward: Vec3; right: Vec3; }

checkPlacement — function @experimental

(grid: PlacementGrid, footprint: SnappedFootprint, probes?: PlacementProbes): PlacementCheck

clampPitch — function @experimental

(pitch: number, min: number, max: number): number

crouchAfter — function @experimental

(crouching: boolean, wantsCrouch: boolean, roomToStand: boolean): boolean

dampFactor — function @experimental

(damping: number, dt: number): number

decideHunterState — function @experimental

(s: HunterSituation): HunterState

desiredDirection — function @experimental

(input: { x: number; y: number; }, basis: MoveBasis): Vec3

facingYaw — function @experimental

(direction: Vec3): number

gameplayPlugin — const @experimental

GameplayPlugin

gridCellAt — function @experimental

(grid: PlacementGrid, x: number, y: number): GridCell

gridCellCentre — function @experimental

(grid: PlacementGrid, col: number, row: number): { x: number; y: number; }

huntTargets — function @experimental

(world: World, animator: AnimatorControllerAPI | null, attackTrigger: string, dt: number): void

lookAfter — function @experimental

(yaw: number, pitch: number, dx: number, dy: number, degreesPerPixel: number, pitchMin: number, pitchMax: number): { yaw: number; pitch: number; }

nearestEntities — function @experimental

<D>(world: World, component: ComponentDef<D>, from: { x: number; y: number; }, options?: NearestOptions<D>): NearEntity[]

nearestMarkers — function @experimental

(world: World, from: { x: number; y: number; }, options?: Omit<NearestOptions<MarkerData>, "filter"> & { type?: string | readonly string[]; has?: Readonly<Record<string, string>>; }): NearEntity[]

observeMotion — function @experimental

(world: World, animator: AnimatorControllerAPI | null, dt: number): void

orbitOffset — function @experimental

(yawDeg: number, pitchDeg: number): Vec3

pitchRotation — function @experimental

(pitchDeg: number): { w: number; x: number; y: number; z: number; }

requestMotion — function @experimental

(world: World, input: InputState, dt: number, animator?: AnimatorControllerAPI | null): void

resolveMeleeHits — function @experimental

(world: World, attacks: MeleeAttacks, queries: MeleeOverlapQuery | null, events: Iterable<AnimatorEventPayload>, damage: { send(blow: DamagePayload): void; }): void

restoreToFull — function @experimental

(world: World, entity: Entity): void

rootMotionVelocity — function @experimental

(delta: { x: number; z: number; }, seconds: number): { x: number; z: number; }

shortestAngleDelta — function @experimental

(from: number, to: number): number

snapFootprint — function @experimental

(grid: PlacementGrid, x: number, y: number, cols: number, rows: number): SnappedFootprint

snapToGrid — function @experimental

(grid: PlacementGrid, x: number, y: number, mode?: "centre" | "corner"): { x: number; y: number; col: number; row: number; }

turnToward — function @experimental

(from: number, to: number, degreesPerSecond: number, dt: number): number

updateCameras — function @experimental

(world: World, input: InputState, queries: Physics3DQueries | null, dt: number): void

walkDirection — function @experimental

(stick: { x: number; y: number; }, yaw: number): { x: number; z: number; }

yawOfQuaternion — function @experimental

(q: { w: number; y: number; }): number

yawQuaternion — function @experimental

(yawDeg: number): { w: number; x: number; y: number; z: number; }

yawRotation — function @experimental

(yawDeg: number): { w: number; x: number; y: number; z: number; }