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.

12.4 KB
Raw Blame

API surface — esengine/replication

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

BinaryHandler — type @experimental

(payload: Uint8Array) => void

ByteReader — class @experimental

f32: () => number
remaining: number
string: () => string
u16: () => number
u32: () => number
u8: () => number
static new (data: Uint8Array): ByteReader
static prototype: ByteReader

ByteWriter — class @experimental

f32: (v: number) => void
finish: () => Uint8Array
length: number
patchU16: (offset: number, v: number) => void
string: (s: string) => void
u16: (v: number) => void
u32: (v: number) => void
u8: (v: number) => void
static new (initialCapacity?: number): ByteWriter
static prototype: ByteWriter

ComponentBuffer — class @experimental

byField: Map<number, FieldSeries>
push: (fieldIndex: number, tick: number, value: unknown) => void
static new (): ComponentBuffer
static prototype: ComponentBuffer

EntityRefMap — interface @experimental

fromWire: (netId: number) => number
toWire: (entity: number) => number

FieldShape — type @experimental

| { kind: 'f32' }
    | { kind: 'bool' }
    | { kind: 'string' }
    | { kind: 'entity' }
    | { kind: 'object'; keys: string[]; shapes: FieldShape[] }
    | { kind: 'json' }

FrameWriter — class @experimental

entry: (netId: number, table: ReplicationTableEntry, fieldMask: number, data: Record<string, unknown>, refs?: EntityRefMap) => void
entryCount: number
finish: () => Uint8Array
static new (tick: number): FrameWriter
static prototype: FrameWriter

InterestPoint — interface @experimental

x: number
y: number
z: number | undefined

InterestPolicy — type @experimental

(view: InterestView) => ReadonlySet<Entity> | 'all'

InterestProvider — interface @experimental

dispose: (() => void) | undefined
prepare: (view: InterestProviderPrepareView) => PreparedInterest

InterestProviderPrepareView — interface @experimental

entered: readonly number[] | undefined
entities: Iterable<number>
entityCount: number
left: readonly number[] | undefined
rechecked: readonly number[] | undefined
world: World

InterestProviderQueryView — interface @experimental

connectionId: number
owned: readonly number[]

InterestView — interface @experimental

candidates: readonly number[]
connectionId: number
owned: readonly number[] | undefined
world: World

InterpolationState — class @experimental

advance: (deltaTicks: number) => number
buffers: Map<number, Map<number, ComponentBuffer>>
delayTicks: number
drop: (netId: number) => void
dropComponent: (netId: number, componentId: number) => void
newestTick: number
push: (netId: number, componentId: number, fieldIndex: number, tick: number, value: unknown) => void
static new (delayTicks: number): InterpolationState
static prototype: InterpolationState

MemoryTransport — class @experimental

delivery: "reliable-ordered"
dropPending: () => void
flush: (limit?: number) => void
on: (event: "message", handler: (data: string | ArrayBuffer) => void) => () => void
pendingCount: number
send: (data: string | ArrayBuffer) => void
static new (options?: MemoryTransportOptions): MemoryTransport
static pair: (options?: MemoryTransportOptions) => [MemoryTransport, MemoryTransport]
static prototype: MemoryTransport

MessageHandler — type @experimental

(payload: T) => void

MessagePortLike — interface @experimental

close: (() => void) | undefined
onmessage: ((event: { data: unknown; }) => void) | null
postMessage: (data: unknown) => void

MessagePortTransport — class @experimental

close: () => void
delivery: "reliable-ordered"
on: (event: "message", handler: (data: string | ArrayBuffer) => void) => () => void
send: (data: string | ArrayBuffer) => void
static new (port: MessagePortLike | MessagePort): MessagePortTransport
static prototype: MessagePortTransport

Net — const @experimental

ResourceDef<NetSession>

NetChannel — class @experimental

dispose: (reason?: string) => void
handle: <Req = unknown, Res = unknown>(type: string, handler: RequestHandler<Req, Res>, codec?: RequestCodec<Req, Res>) => () => void
on: <T = unknown>(type: string, handler: MessageHandler<T>, codec?: PayloadCodec<T>) => () => void
onBinary: (channel: number, handler: BinaryHandler) => () => void
request: <Res = unknown, Req = unknown>(type: string, payload: Req, options?: number | RequestOptions) => Promise<Res>
send: <T = unknown>(type: string, payload: T, codec?: PayloadCodec<T>) => void
sendBinary: (channel: number, payload: Uint8Array) => void
setIdempotencyScope: (scope: string) => void
setWire: (format: WireFormat, options?: { acceptJson?: boolean; }) => void
wire: WireFormat
static new (transport: NetTransport, opts?: NetChannelOptions): NetChannel
static prototype: NetChannel

NetChannelOptions — interface @experimental

heartbeat: NetHeartbeatOptions | undefined
idempotency: IdempotencyStore | undefined
idempotencyScope: string | undefined
limits: NetLimitOptions | undefined
requestTimeoutMs: number | undefined

NetGhost — const @experimental

ComponentDef<{}>

NetIds — class @experimental

allocate: () => number
clear: () => void
entityOf: (netId: number) => Entity | undefined
netIdOf: (entity: Entity) => number | undefined
register: (netId: number, entity: Entity) => void
size: number
unregister: (netId: number) => void
unregisterEntity: (entity: Entity) => void
static new (): NetIds
static prototype: NetIds

NetRoleKind — type @experimental

'offline' | 'server' | 'client'

NetSession — class @experimental

client: ReplicationClient | null
connect: (transport: ReliableOrderedTransport, options?: ReplicationClientOptions) => Promise<ReplicationClient>
role: NetRoleKind
server: ReplicationServer | null
startServer: () => ReplicationServer
stop: () => void
static new (app_: App): NetSession
static prototype: NetSession

PredictionOptions — interface @experimental

apply: (world: World, entity: Entity, actions: Record<string, unknown>, dt: number) => void
maxPendingInputs: number | undefined
smoothing: PredictionSmoothing | undefined

PredictionSmoothing — interface @experimental

halfLife: number
maxError: number | undefined

PreparedInterest — interface @experimental

generation: number | undefined
query: (view: InterestProviderQueryView) => ReadonlySet<Entity> | "all"

REPLICATION_CHANNEL — const @experimental

1

REPLICATION_PROTOCOL_VERSION — const @experimental

4

RadiusInterestOptions — interface @experimental

position: ((world: World, entity: Entity) => InterestPoint | null) | undefined

ReplAckMsg — interface @experimental

seq: number
tick: number

ReplComponentRemoveBatch — interface @experimental

entries: { netId: number; componentIds: number[]; }[]
tick: number

ReplComponentSchema — interface @experimental

fields: string[]
name: string
shapes: string[]

ReplDespawnBatch — interface @experimental

netIds: number[]
tick: number

ReplHelloRequest — interface @experimental

abiHash: string
components: ReplComponentSchema[]
protocolVersion: number

ReplHelloResponse — type @experimental

ReplHelloOk | ReplHelloError

ReplInputMsg — interface @experimental

actions: Record<string, unknown>
seq: number

ReplMsg — const @experimental

{ readonly hello: "repl:hello"; readonly spawn: "repl:spawn"; readonly despawn: "repl:despawn"; readonly componentRemove: "repl:crm"; readonly input: "repl:input"; readonly ack: "repl:ack"; }

ReplSpawnBatch — interface @experimental

entities: ReplSpawnEntity[]
tick: number

ReplSpawnEntity — interface @experimental

archetype: string
baseline: SceneComponentData[]
name: string
netId: number
owner: number
parentNetId: number

Replicated — const @experimental

ComponentDef<ReplicatedData>

ReplicatedData — interface @experimental

archetype: string
netId: number
owner: number

ReplicationArchetype — type @experimental

(world: World, entity: Entity) => void

ReplicationClient — class @experimental

@internal setFixedDelta: (dt: number) => void
applyPending: () => void
connect: (transport: ReliableOrderedTransport) => Promise<void>
connected: boolean
connectionId: number
disconnect: () => void
enablePrediction: (options: PredictionOptions) => void
netIds: NetIds
ownsEntity: (entity: Entity) => boolean
predictionEnabled: boolean
sampleInterpolation: (deltaTicks: number) => void
sendInput: (actions: Record<string, unknown>) => void
serverTick: number
table: ReplicationTable
static new (world: World, options?: ReplicationClientOptions): ReplicationClient
static prototype: ReplicationClient

ReplicationClientOptions — interface @experimental

interpolationDelayTicks: number | undefined
prediction: PredictionOptions | undefined

ReplicationPlugin — class @experimental

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

ReplicationServer — class @experimental

@internal deltaRowsSent: number
@internal dirtyCandidates: number
@internal entersSent: number
@internal fullScans: number
@internal journalReads: number
@internal ownerScanVisits: number
@internal payloadsBuilt: number
@internal profileSample: boolean
@internal samplePhases: Map<string, number>
@internal viewerLinks: number
@internal visibilityRecomputes: number
attachConnection: (transport: ReliableOrderedTransport) => number
beginTick: (fixedDelta: number) => void
clientIds: number[]
connectionCount: number
detachConnection: (id: number) => void
dispose: () => void
inputOf: (connectionId: number) => ReplInputMsg | null
leavesSent: number
netIds: NetIds
populationScans: number
sample: (tick: number) => void
setInterestPolicy: (policy: InterestPolicy | null) => void
setInterestProvider: (provider: InterestProvider | null) => void
table: ReplicationTable
tickInputOf: (connectionId: number) => ReplInputMsg | null
static new (world: World): ReplicationServer
static prototype: ReplicationServer

ReplicationTable — interface @experimental

byName: Map<string, ReplicationTableEntry>
entries: ReplicationTableEntry[]

ReplicationTableEntry — interface @experimental

def: AnyComponentDef
fields: string[]
id: number
name: string
shapes: FieldShape[]

RequestHandler — type @experimental

(payload: Req) => Res | Promise<Res>

StateEntry — interface @experimental

componentId: number
fieldMask: number
netId: number
values: unknown[]

StateFrame — interface @experimental

entries: StateEntry[]
tick: number

buildReplicationTable — function @experimental

(): ReplicationTable

cloneValue — function @experimental

<T>(v: T): T

createMemoryTransportPair — function @experimental

(options?: MemoryTransportOptions): [MemoryTransport, MemoryTransport]

decodeStateFrame — function @experimental

(payload: Uint8Array, table: ReplicationTable, refs?: EntityRefMap): StateFrame

decodeValue — function @experimental

(r: ByteReader, shape: FieldShape, refs?: EntityRefMap): unknown

diffSchemas — function @experimental

(mine: ReplComponentSchema[], theirs: ReplComponentSchema[]): string | null

encodeValue — function @experimental

(w: ByteWriter, shape: FieldShape, value: unknown, refs?: EntityRefMap): void

lerpValue — function @experimental

(shape: FieldShape, a: unknown, b: unknown, t: number): unknown

predictionReplays — function @experimental

(scope: SpeculationScope, prediction: PredictionOptions, entity: Entity, actions: Record<string, unknown>, dt: number): ReplayReport

radiusInterest — function @experimental

(radius: number, options?: RadiusInterestOptions): InterestPolicy

radiusInterestProvider — function @experimental

(radius: number, options?: RadiusInterestOptions): InterestProvider

registerReplicationArchetype — function @experimental

(key: string, build: ReplicationArchetype): void

replicationPlugin — const @experimental

ReplicationPlugin

shapeSignature — function @experimental

(shape: FieldShape): string

tableSchemas — function @experimental

(table: ReplicationTable): ReplComponentSchema[]