@ringozz/godot 0.1.0

package/gen/classes/DrawableTexture2D.ts

@@ -0,0 +1,75 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Texture2D } from './Texture2D.ts';
+import type { GodotArray } from '../heap-types/index.ts';
+import type { Color, Rect2i } from '../value-types/index.ts';
+import type { Material } from './Material.ts';
+
+/**
+ * A 2D texture that can be modified via blit calls, copying from a target texture to itself. Primarily intended to be managed in code, a user must call {@link setup} to initialize the state before drawing. Each {@link blitRect} call takes at least a rectangle, the area to draw to, and another texture, what to be drawn. The draw calls use a Texture_Blit Shader to process and calculate the result, pixel by pixel. Users can supply their own ShaderMaterial with custom Texture_Blit shaders for more complex behaviors.
+ */
+export class DrawableTexture2D extends Texture2D {
+    constructor(name = 250) { super(name); }
+
+    /**
+     * Sets the format of this DrawableTexture.
+     */
+    setFormat(format: DrawableFormat): void { _C(this, 11465, format); }
+
+    /**
+     * Sets if mipmaps should be used on this DrawableTexture.
+     */
+    setUseMipmaps(mipmaps: boolean): void { _C(this, 13226, mipmaps); }
+
+    /**
+     * Returns `true` if mipmaps are set to be used on this DrawableTexture.
+     */
+    getUseMipmaps(): boolean { return _C(this, 6982) as boolean; }
+
+    /**
+     * Initializes the DrawableTexture to a White texture of the given `width`, `height`, and `format`.
+     */
+    setup(width: number, height: number, format: DrawableFormat, color?: Color /* = Color(1, 1, 1, 1) */, useMipmaps?: boolean /* = false */): void { _C(this, 13415, width, height, format, color, useMipmaps); }
+
+    /**
+     * Draws to given `rect` on this texture by copying from the given `source`. A `modulate` color can be passed in for the shader to use, but defaults to White. The `mipmap` value can specify a draw to a lower mipmap level. The `material` parameter can take a ShaderMaterial with a TextureBlit Shader for custom drawing behavior.
+     */
+    blitRect(rect: Rect2i, source: Texture2D, modulate?: Color /* = Color(1, 1, 1, 1) */, mipmap?: number /* = 0 */, material?: Material /* = null */): void { _C(this, 1801, rect, source, modulate, mipmap, material); }
+
+    /**
+     * Draws to the given `rect` on this texture, as well as on up to 3 DrawableTexture `extraTargets`. All `extraTargets` must be the same size and DrawableFormat as the original target, otherwise the Shader may fail. Expects up to 4 Texture `sources`, but will replace missing `sources` with default Black Textures.
+     */
+    blitRectMulti(rect: Rect2i, sources: GodotArray<Texture2D>, extraTargets: GodotArray<DrawableTexture2D>, modulate?: Color /* = Color(1, 1, 1, 1) */, mipmap?: number /* = 0 */, material?: Material /* = null */): void { _C(this, 1803, rect, sources, extraTargets, modulate, mipmap, material); }
+
+    /**
+     * Re-calculates the mipmaps for this texture on demand.
+     */
+    generateMipmaps(): void { _C(this, 3632); }
+
+    static readonly name = _R(250, DrawableTexture2D);
+}
+
+export const DrawableFormat = {
+    /**
+     * OpenGL texture format RGBA with four components, each with a bitdepth of 8.
+     */
+    DRAWABLE_FORMAT_RGBA8: 0,
+    /**
+     * OpenGL texture format RGBA with four components, each with a bitdepth of 8.
+     * When drawn to, an sRGB to linear color space conversion is performed.
+     */
+    DRAWABLE_FORMAT_RGBA8_SRGB: 1,
+    /**
+     * OpenGL texture format GL_RGBA16F where there are four components, each a 16-bit "half-precision" floating-point value.
+     */
+    DRAWABLE_FORMAT_RGBAH: 2,
+    /**
+     * OpenGL texture format GL_RGBA32F where there are four components, each a 32-bit floating-point value.
+     */
+    DRAWABLE_FORMAT_RGBAF: 3,
+} as const;
+
+export type DrawableFormat = (typeof DrawableFormat)[keyof typeof DrawableFormat];
+

package/gen/classes/ENetConnection.ts

@@ -0,0 +1,192 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotArray, PackedByteArray } from '../heap-types/index.ts';
+import type { ENetPacketPeer } from './ENetPacketPeer.ts';
+import type { TLSOptions } from './TLSOptions.ts';
+
+/**
+ * ENet's purpose is to provide a relatively thin, simple and robust network communication layer on top of UDP (User Datagram Protocol).
+ */
+export class ENetConnection extends RefCounted {
+    constructor(name = 251) { super(name); }
+
+    /**
+     * Creates an ENetHost bound to the given `bindAddress` and `bindPort` that allows up to `maxPeers` connected peers, each allocating up to `maxChannels` channels, optionally limiting bandwidth to `inBandwidth` and `outBandwidth` (if greater than zero).
+     * **Note:** It is necessary to create a host in both client and server in order to establish a connection.
+     */
+    createHostBound(bindAddress: string, bindPort: number, maxPeers?: number /* = 32 */, maxChannels?: number /* = 0 */, inBandwidth?: number /* = 0 */, outBandwidth?: number /* = 0 */): Error { return _C(this, 2542, bindAddress, bindPort, maxPeers, maxChannels, inBandwidth, outBandwidth) as Error; }
+
+    /**
+     * Creates an ENetHost that allows up to `maxPeers` connected peers, each allocating up to `maxChannels` channels, optionally limiting bandwidth to `inBandwidth` and `outBandwidth` (if greater than zero).
+     * This method binds a random available dynamic UDP port on the host machine at the *unspecified* address. Use {@link createHostBound} to specify the address and port.
+     * **Note:** It is necessary to create a host in both client and server in order to establish a connection.
+     */
+    createHost(maxPeers?: number /* = 32 */, maxChannels?: number /* = 0 */, inBandwidth?: number /* = 0 */, outBandwidth?: number /* = 0 */): Error { return _C(this, 2541, maxPeers, maxChannels, inBandwidth, outBandwidth) as Error; }
+
+    /**
+     * Destroys the host and all resources associated with it.
+     */
+    destroy(): void { _C(this, 2760); }
+
+    /**
+     * Initiates a connection to a foreign `address` using the specified `port` and allocating the requested `channels`. Optional `data` can be passed during connection in the form of a 32 bit integer.
+     * **Note:** You must call either {@link createHost} or {@link createHostBound} on both ends before calling this method.
+     */
+    connectToHost(address: string, port: number, channels?: number /* = 0 */, data?: number /* = 0 */): ENetPacketPeer { return _C(this, 2438, address, port, channels, data) as ENetPacketPeer; }
+
+    /**
+     * Waits for events on this connection and shuttles packets between the host and its peers, with the given `timeout` (in milliseconds). The returned {@link Array} will have 4 elements. An {@link EventType}, the {@link ENetPacketPeer} which generated the event, the event associated data (if any), the event associated channel (if any). If the generated event is {@link EVENT_RECEIVE}, the received packet will be queued to the associated {@link ENetPacketPeer}.
+     * Call this function regularly to handle connections, disconnections, and to receive new packets.
+     * **Note:** This method must be called on both ends involved in the event (sending and receiving hosts).
+     */
+    service(timeout?: number /* = 0 */): GodotArray { return _C(this, 10378, timeout) as GodotArray; }
+
+    /**
+     * Sends any queued packets on the host specified to its designated peers.
+     */
+    flush(): void { _C(this, 3343); }
+
+    /**
+     * Adjusts the bandwidth limits of a host.
+     */
+    bandwidthLimit(inBandwidth?: number /* = 0 */, outBandwidth?: number /* = 0 */): void { _C(this, 1727, inBandwidth, outBandwidth); }
+
+    /**
+     * Limits the maximum allowed channels of future incoming connections.
+     */
+    channelLimit(limit: number): void { _C(this, 2192, limit); }
+
+    /**
+     * Queues a `packet` to be sent to all peers associated with the host over the specified `channel`. See {@link ENetPacketPeer} `FLAG_*` constants for available packet flags.
+     */
+    broadcast(channel: number, packet: PackedByteArray, flags: number): void { _C(this, 1914, channel, packet, flags); }
+
+    /**
+     * Sets the compression method used for network packets. These have different tradeoffs of compression speed versus bandwidth, you may need to test which one works best for your use case if you use compression at all.
+     * **Note:** Most games' network design involve sending many small packets frequently (smaller than 4 KB each). If in doubt, it is recommended to keep the default compression algorithm as it works best on these small packets.
+     * **Note:** The compression mode must be set to the same value on both the server and all its clients. Clients will fail to connect if the compression mode set on the client differs from the one set on the server.
+     */
+    compress(mode: CompressionMode): void { _C(this, 2410, mode); }
+
+    /**
+     * Configure this ENetHost to use the custom Godot extension allowing DTLS encryption for ENet servers. Call this right after {@link createHostBound} to have ENet expect peers to connect using DTLS. See {@link TLSOptions.server}.
+     */
+    dtlsServerSetup(serverOptions: TLSOptions): Error { return _C(this, 2979, serverOptions) as Error; }
+
+    /**
+     * Configure this ENetHost to use the custom Godot extension allowing DTLS encryption for ENet clients. Call this before {@link connectToHost} to have ENet connect using DTLS validating the server certificate against `hostname`. You can pass the optional `clientOptions` parameter to customize the trusted certification authorities, or disable the common name verification. See {@link TLSOptions.client} and {@link TLSOptions.clientUnsafe}.
+     */
+    dtlsClientSetup(hostname: string, clientOptions?: TLSOptions /* = null */): Error { return _C(this, 2978, hostname, clientOptions) as Error; }
+
+    /**
+     * Configures the DTLS server to automatically drop new connections.
+     * **Note:** This method is only relevant after calling {@link dtlsServerSetup}.
+     */
+    refuseNewConnections(refuse: boolean): void { _C(this, 9801, refuse); }
+
+    /**
+     * Returns and resets host statistics.
+     */
+    popStatistic(statistic: HostStatistic): number { return _C(this, 9481, statistic) as number; }
+
+    /**
+     * Returns the maximum number of channels allowed for connected peers.
+     */
+    getMaxChannels(): number { return _C(this, 5459) as number; }
+
+    /**
+     * Returns the local port to which this peer is bound.
+     */
+    getLocalPort(): number { return _C(this, 5398) as number; }
+
+    /**
+     * Returns the list of peers associated with this host.
+     * **Note:** This list might include some peers that are not fully connected or are still being disconnected.
+     */
+    getPeers(): GodotArray<ENetPacketPeer> { return _C(this, 5873) as GodotArray<ENetPacketPeer>; }
+
+    /**
+     * Sends a `packet` toward a destination from the address and port currently bound by this ENetConnection instance.
+     * This is useful as it serves to establish entries in NAT routing tables on all devices between this bound instance and the public facing internet, allowing a prospective client's connection packets to be routed backward through the NAT device(s) between the public internet and this host.
+     * This requires forward knowledge of a prospective client's address and communication port as seen by the public internet - after any NAT devices have handled their connection request. This information can be obtained by a [STUN](https://en.wikipedia.org/wiki/STUN) service, and must be handed off to your host by an entity that is not the prospective client. This will never work for a client behind a Symmetric NAT due to the nature of the Symmetric NAT routing algorithm, as their IP and Port cannot be known beforehand.
+     */
+    socketSend(destinationAddress: string, destinationPort: number, packet: PackedByteArray): void { _C(this, 13679, destinationAddress, destinationPort, packet); }
+
+    static readonly name = _R(251, ENetConnection);
+}
+
+export const CompressionMode = {
+    /**
+     * No compression. This uses the most bandwidth, but has the upside of requiring the fewest CPU resources. This option may also be used to make network debugging using tools like Wireshark easier.
+     */
+    COMPRESS_NONE: 0,
+    /**
+     * ENet's built-in range encoding. Works well on small packets, but is not the most efficient algorithm on packets larger than 4 KB.
+     */
+    COMPRESS_RANGE_CODER: 1,
+    /**
+     * [FastLZ](https://fastlz.org/) compression. This option uses less CPU resources compared to {@link COMPRESS_ZLIB}, at the expense of using more bandwidth.
+     */
+    COMPRESS_FASTLZ: 2,
+    /**
+     * [Zlib](https://www.zlib.net/) compression. This option uses less bandwidth compared to {@link COMPRESS_FASTLZ}, at the expense of using more CPU resources.
+     */
+    COMPRESS_ZLIB: 3,
+    /**
+     * [Zstandard](https://facebook.github.io/zstd/) compression. Note that this algorithm is not very efficient on packets smaller than 4 KB. Therefore, it's recommended to use other compression algorithms in most cases.
+     */
+    COMPRESS_ZSTD: 4,
+} as const;
+
+export type CompressionMode = (typeof CompressionMode)[keyof typeof CompressionMode];
+
+export const EventType = {
+    /**
+     * An error occurred during {@link service}. You will likely need to {@link destroy} the host and recreate it.
+     */
+    EVENT_ERROR: -1,
+    /**
+     * No event occurred within the specified time limit.
+     */
+    EVENT_NONE: 0,
+    /**
+     * A connection request initiated by enet_host_connect has completed. The array will contain the peer which successfully connected.
+     */
+    EVENT_CONNECT: 1,
+    /**
+     * A peer has disconnected. This event is generated on a successful completion of a disconnect initiated by {@link ENetPacketPeer.peerDisconnect}, if a peer has timed out, or if a connection request initialized by {@link connectToHost} has timed out. The array will contain the peer which disconnected. The data field contains user supplied data describing the disconnection, or 0, if none is available.
+     */
+    EVENT_DISCONNECT: 2,
+    /**
+     * A packet has been received from a peer. The array will contain the peer which sent the packet and the channel number upon which the packet was received. The received packet will be queued to the associated {@link ENetPacketPeer}.
+     */
+    EVENT_RECEIVE: 3,
+} as const;
+
+export type EventType = (typeof EventType)[keyof typeof EventType];
+
+export const HostStatistic = {
+    /**
+     * Total data sent.
+     */
+    HOST_TOTAL_SENT_DATA: 0,
+    /**
+     * Total UDP packets sent.
+     */
+    HOST_TOTAL_SENT_PACKETS: 1,
+    /**
+     * Total data received.
+     */
+    HOST_TOTAL_RECEIVED_DATA: 2,
+    /**
+     * Total UDP packets received.
+     */
+    HOST_TOTAL_RECEIVED_PACKETS: 3,
+} as const;
+
+export type HostStatistic = (typeof HostStatistic)[keyof typeof HostStatistic];
+

package/gen/classes/ENetMultiplayerPeer.ts

@@ -0,0 +1,54 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { MultiplayerPeer } from './MultiplayerPeer.ts';
+import type { Error } from '../global-enums.ts';
+import type { ENetConnection } from './ENetConnection.ts';
+import type { ENetPacketPeer } from './ENetPacketPeer.ts';
+
+/**
+ * A MultiplayerPeer implementation that should be passed to {@link MultiplayerAPI.multiplayerPeer} after being initialized as either a client, server, or mesh. Events can then be handled by connecting to {@link MultiplayerAPI} signals. See {@link ENetConnection} for more information on the ENet library wrapper.
+ * **Note:** ENet only uses UDP, not TCP. When forwarding the server port to make your server accessible on the public Internet, you only need to forward the server port in UDP. You can use the {@link UPNP} class to try to forward the server port automatically when starting the server.
+ */
+export class ENetMultiplayerPeer extends MultiplayerPeer {
+    constructor(name = 252) { super(name); }
+
+    /**
+     * Create server that listens to connections via `port`. The port needs to be an available, unused port between 0 and 65535. Note that ports below 1024 are privileged and may require elevated permissions depending on the platform. To change the interface the server listens on, use {@link setBindIp}. The default IP is the wildcard `"*"`, which listens on all available interfaces. `maxClients` is the maximum number of clients that are allowed at once, any number up to 4095 may be used, although the achievable number of simultaneous clients may be far lower and depends on the application. For additional details on the bandwidth parameters, see {@link createClient}. Returns {@link OK} if a server was created, {@link ERR_ALREADY_IN_USE} if this ENetMultiplayerPeer instance already has an open connection (in which case you need to call {@link MultiplayerPeer.close} first) or {@link ERR_CANT_CREATE} if the server could not be created.
+     */
+    createServer(port: number, maxClients?: number /* = 32 */, maxChannels?: number /* = 0 */, inBandwidth?: number /* = 0 */, outBandwidth?: number /* = 0 */): Error { return _C(this, 2568, port, maxClients, maxChannels, inBandwidth, outBandwidth) as Error; }
+
+    /**
+     * Create client that connects to a server at `address` using specified `port`. The given address needs to be either a fully qualified domain name (e.g. `"www.example.com"`) or an IP address in IPv4 or IPv6 format (e.g. `"192.168.1.1"`). The `port` is the port the server is listening on. The `channelCount` parameter can be used to specify the number of ENet channels allocated for the connection. The `inBandwidth` and `outBandwidth` parameters can be used to limit the incoming and outgoing bandwidth to the given number of bytes per second. The default of 0 means unlimited bandwidth. Note that ENet will strategically drop packets on specific sides of a connection between peers to ensure the peer's bandwidth is not overwhelmed. The bandwidth parameters also determine the window size of a connection which limits the amount of reliable packets that may be in transit at any given time. Returns {@link OK} if a client was created, {@link ERR_ALREADY_IN_USE} if this ENetMultiplayerPeer instance already has an open connection (in which case you need to call {@link MultiplayerPeer.close} first) or {@link ERR_CANT_CREATE} if the client could not be created. If `localPort` is specified, the client will also listen to the given port; this is useful for some NAT traversal techniques.
+     */
+    createClient(address: string, port: number, channelCount?: number /* = 0 */, inBandwidth?: number /* = 0 */, outBandwidth?: number /* = 0 */, localPort?: number /* = 0 */): Error { return _C(this, 2512, address, port, channelCount, inBandwidth, outBandwidth, localPort) as Error; }
+
+    /**
+     * Initialize this {@link MultiplayerPeer} in mesh mode. The provided `uniqueId` will be used as the local peer network unique ID once assigned as the {@link MultiplayerAPI.multiplayerPeer}. In the mesh configuration you will need to set up each new peer manually using {@link ENetConnection} before calling {@link addMeshPeer}. While this technique is more advanced, it allows for better control over the connection process (e.g. when dealing with NAT punch-through) and for better distribution of the network load (which would otherwise be more taxing on the server).
+     */
+    createMesh(uniqueId: number): Error { return _C(this, 2552, uniqueId) as Error; }
+
+    /**
+     * Add a new remote peer with the given `peerId` connected to the given `host`.
+     * **Note:** The `host` must have exactly one peer in the {@link ENetPacketPeer.STATE_CONNECTED} state.
+     */
+    addMeshPeer(peerId: number, host: ENetConnection): Error { return _C(this, 1250, peerId, host) as Error; }
+
+    /**
+     * The IP used when creating a server. This is set to the wildcard `"*"` by default, which binds to all available interfaces. The given IP needs to be in IPv4 or IPv6 address format, for example: `"192.168.1.1"`.
+     */
+    setBindIp(ip: string): void { _C(this, 10663, ip); }
+
+    /**
+     * Returns the {@link ENetPacketPeer} associated to the given `id`.
+     */
+    getPeer(id: number): ENetPacketPeer { return _C(this, 5870, id) as ENetPacketPeer; }
+
+    /**
+     * The underlying {@link ENetConnection} created after {@link createClient} and {@link createServer}.
+     */
+    get host(): ENetConnection { return _C(this, 5048) as ENetConnection; }
+
+    static readonly name = _R(252, ENetMultiplayerPeer);
+}

package/gen/classes/ENetPacketPeer.ts

@@ -0,0 +1,234 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { PacketPeer } from './PacketPeer.ts';
+import type { Error } from '../global-enums.ts';
+import type { PackedByteArray } from '../heap-types/index.ts';
+
+/**
+ * A PacketPeer implementation representing a peer of an {@link ENetConnection}.
+ * This class cannot be instantiated directly but can be retrieved during {@link ENetConnection.service} or via {@link ENetConnection.getPeers}.
+ * **Note:** When exporting to Android, make sure to enable the `INTERNET` permission in the Android export preset before exporting the project or using one-click deploy. Otherwise, network communication of any kind will be blocked by Android.
+ */
+export class ENetPacketPeer extends PacketPeer {
+
+    /**
+     * Request a disconnection from a peer. An {@link ENetConnection.EVENT_DISCONNECT} will be generated during {@link ENetConnection.service} once the disconnection is complete.
+     */
+    peerDisconnect(data?: number /* = 0 */): void { _C(this, 9389, data); }
+
+    /**
+     * Request a disconnection from a peer, but only after all queued outgoing packets are sent. An {@link ENetConnection.EVENT_DISCONNECT} will be generated during {@link ENetConnection.service} once the disconnection is complete.
+     */
+    peerDisconnectLater(data?: number /* = 0 */): void { _C(this, 9390, data); }
+
+    /**
+     * Force an immediate disconnection from a peer. No {@link ENetConnection.EVENT_DISCONNECT} will be generated. The foreign peer is not guaranteed to receive the disconnect notification, and is reset immediately upon return from this function.
+     */
+    peerDisconnectNow(data?: number /* = 0 */): void { _C(this, 9391, data); }
+
+    /**
+     * Sends a ping request to a peer. ENet automatically pings all connected peers at regular intervals, however, this function may be called to ensure more frequent ping requests.
+     */
+    ping(): void { _C(this, 9428); }
+
+    /**
+     * Sets the `pingInterval` in milliseconds at which pings will be sent to a peer. Pings are used both to monitor the liveness of the connection and also to dynamically adjust the throttle during periods of low traffic so that the throttle has reasonable responsiveness during traffic spikes. The default ping interval is `500` milliseconds.
+     */
+    pingInterval(pingInterval: number): void { _C(this, 9429, pingInterval); }
+
+    /**
+     * Forcefully disconnects a peer. The foreign host represented by the peer is not notified of the disconnection and will timeout on its connection to the local host.
+     */
+    reset(): void { _C(this, 10064); }
+
+    /**
+     * Queues a `packet` to be sent over the specified `channel`. See `FLAG_*` constants for available packet flags.
+     */
+    send(channel: number, packet: PackedByteArray, flags: number): Error { return _C(this, 10368, channel, packet, flags) as Error; }
+
+    /**
+     * Configures throttle parameter for a peer.
+     * Unreliable packets are dropped by ENet in response to the varying conditions of the Internet connection to the peer. The throttle represents a probability that an unreliable packet should not be dropped and thus sent by ENet to the peer. By measuring fluctuations in round trip times of reliable packets over the specified `interval`, ENet will either increase the probability by the amount specified in the `acceleration` parameter, or decrease it by the amount specified in the `deceleration` parameter (both are ratios to {@link PACKET_THROTTLE_SCALE}).
+     * When the throttle has a value of {@link PACKET_THROTTLE_SCALE}, no unreliable packets are dropped by ENet, and so 100% of all unreliable packets will be sent.
+     * When the throttle has a value of `0`, all unreliable packets are dropped by ENet, and so 0% of all unreliable packets will be sent.
+     * Intermediate values for the throttle represent intermediate probabilities between 0% and 100% of unreliable packets being sent. The bandwidth limits of the local and foreign hosts are taken into account to determine a sensible limit for the throttle probability above which it should not raise even in the best of conditions.
+     */
+    throttleConfigure(interval: number, acceleration: number, deceleration: number): void { _C(this, 14246, interval, acceleration, deceleration); }
+
+    /**
+     * Sets the timeout parameters for a peer. The timeout parameters control how and when a peer will timeout from a failure to acknowledge reliable traffic. Timeout values are expressed in milliseconds.
+     * The `timeout` is a factor that, multiplied by a value based on the average round trip time, will determine the timeout limit for a reliable packet. When that limit is reached, the timeout will be doubled, and the peer will be disconnected if that limit has reached `timeoutMin`. The `timeoutMax` parameter, on the other hand, defines a fixed timeout for which any packet must be acknowledged or the peer will be dropped.
+     */
+    setTimeout(timeout: number, timeoutMin: number, timeoutMax: number): void { _C(this, 13089, timeout, timeoutMin, timeoutMax); }
+
+    /**
+     * Returns the ENet flags of the next packet in the received queue. See `FLAG_*` constants for available packet flags. Note that not all flags are replicated from the sending peer to the receiving peer.
+     */
+    getPacketFlags(): number { return _C(this, 5787) as number; }
+
+    /**
+     * Returns the IP address of this peer.
+     */
+    getRemoteAddress(): string { return _C(this, 6125) as string; }
+
+    /**
+     * Returns the remote port of this peer.
+     */
+    getRemotePort(): number { return _C(this, 6127) as number; }
+
+    /**
+     * Returns the requested `statistic` for this peer.
+     */
+    getStatistic(statistic: PeerStatistic): number { return _C(this, 6541, statistic) as number; }
+
+    /**
+     * Returns the current peer state.
+     */
+    getState(): PeerState { return _C(this, 6537) as PeerState; }
+
+    /**
+     * Returns the number of channels allocated for communication with peer.
+     */
+    getChannels(): number { return _C(this, 4140) as number; }
+
+    /**
+     * Returns `true` if the peer is currently active (i.e. the associated {@link ENetConnection} is still valid).
+     */
+    isActive(): boolean { return _C(this, 7746) as boolean; }
+
+    /**
+     * The reference scale for packet loss. See {@link getStatistic} and {@link PEER_PACKET_LOSS}.
+     */
+    static readonly PACKET_LOSS_SCALE = 65536;
+
+    /**
+     * The reference value for throttle configuration. The default value is `32`. See {@link throttleConfigure}.
+     */
+    static readonly PACKET_THROTTLE_SCALE = 32;
+
+    /**
+     * Mark the packet to be sent as reliable.
+     */
+    static readonly FLAG_RELIABLE = 1;
+
+    /**
+     * Mark the packet to be sent unsequenced (unreliable).
+     */
+    static readonly FLAG_UNSEQUENCED = 2;
+
+    /**
+     * Mark the packet to be sent unreliable even if the packet is too big and needs fragmentation (increasing the chance of it being dropped).
+     */
+    static readonly FLAG_UNRELIABLE_FRAGMENT = 8;
+
+    static readonly name = _R(253, ENetPacketPeer);
+}
+
+export const PeerState = {
+    /**
+     * The peer is disconnected.
+     */
+    STATE_DISCONNECTED: 0,
+    /**
+     * The peer is currently attempting to connect.
+     */
+    STATE_CONNECTING: 1,
+    /**
+     * The peer has acknowledged the connection request.
+     */
+    STATE_ACKNOWLEDGING_CONNECT: 2,
+    /**
+     * The peer is currently connecting.
+     */
+    STATE_CONNECTION_PENDING: 3,
+    /**
+     * The peer has successfully connected, but is not ready to communicate with yet ({@link STATE_CONNECTED}).
+     */
+    STATE_CONNECTION_SUCCEEDED: 4,
+    /**
+     * The peer is currently connected and ready to communicate with.
+     */
+    STATE_CONNECTED: 5,
+    /**
+     * The peer is expected to disconnect after it has no more outgoing packets to send.
+     */
+    STATE_DISCONNECT_LATER: 6,
+    /**
+     * The peer is currently disconnecting.
+     */
+    STATE_DISCONNECTING: 7,
+    /**
+     * The peer has acknowledged the disconnection request.
+     */
+    STATE_ACKNOWLEDGING_DISCONNECT: 8,
+    /**
+     * The peer has lost connection, but is not considered truly disconnected (as the peer didn't acknowledge the disconnection request).
+     */
+    STATE_ZOMBIE: 9,
+} as const;
+
+export type PeerState = (typeof PeerState)[keyof typeof PeerState];
+
+export const PeerStatistic = {
+    /**
+     * Mean packet loss of reliable packets as a ratio with respect to the {@link PACKET_LOSS_SCALE}.
+     */
+    PEER_PACKET_LOSS: 0,
+    /**
+     * Packet loss variance.
+     */
+    PEER_PACKET_LOSS_VARIANCE: 1,
+    /**
+     * The time at which packet loss statistics were last updated (in milliseconds since the connection started). The interval for packet loss statistics updates is 10 seconds, and at least one packet must have been sent since the last statistics update.
+     */
+    PEER_PACKET_LOSS_EPOCH: 2,
+    /**
+     * Mean packet round trip time for reliable packets.
+     */
+    PEER_ROUND_TRIP_TIME: 3,
+    /**
+     * Variance of the mean round trip time.
+     */
+    PEER_ROUND_TRIP_TIME_VARIANCE: 4,
+    /**
+     * Last recorded round trip time for a reliable packet.
+     */
+    PEER_LAST_ROUND_TRIP_TIME: 5,
+    /**
+     * Variance of the last trip time recorded.
+     */
+    PEER_LAST_ROUND_TRIP_TIME_VARIANCE: 6,
+    /**
+     * The peer's current throttle status.
+     */
+    PEER_PACKET_THROTTLE: 7,
+    /**
+     * The maximum number of unreliable packets that should not be dropped. This value is always greater than or equal to `1`. The initial value is equal to {@link PACKET_THROTTLE_SCALE}.
+     */
+    PEER_PACKET_THROTTLE_LIMIT: 8,
+    /**
+     * Internal value used to increment the packet throttle counter. The value is hardcoded to `7` and cannot be changed. You probably want to look at {@link PEER_PACKET_THROTTLE_ACCELERATION} instead.
+     */
+    PEER_PACKET_THROTTLE_COUNTER: 9,
+    /**
+     * The time at which throttle statistics were last updated (in milliseconds since the connection started). The interval for throttle statistics updates is {@link PEER_PACKET_THROTTLE_INTERVAL}.
+     */
+    PEER_PACKET_THROTTLE_EPOCH: 10,
+    /**
+     * The throttle's acceleration factor. Higher values will make ENet adapt to fluctuating network conditions faster, causing unrelaible packets to be sent *more* often. The default value is `2`.
+     */
+    PEER_PACKET_THROTTLE_ACCELERATION: 11,
+    /**
+     * The throttle's deceleration factor. Higher values will make ENet adapt to fluctuating network conditions faster, causing unrelaible packets to be sent *less* often. The default value is `2`.
+     */
+    PEER_PACKET_THROTTLE_DECELERATION: 12,
+    /**
+     * The interval over which the lowest mean round trip time should be measured for use by the throttle mechanism (in milliseconds). The default value is `5000`.
+     */
+    PEER_PACKET_THROTTLE_INTERVAL: 13,
+} as const;
+
+export type PeerStatistic = (typeof PeerStatistic)[keyof typeof PeerStatistic];
+

package/gen/classes/EncodedObjectAsID.ts

@@ -0,0 +1,21 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+
+/**
+ * Utility class which holds a reference to the internal identifier of an {@link Object} instance, as given by {@link Object.getInstanceId}. This ID can then be used to retrieve the object instance with {@link instanceFromId}.
+ * This class is used internally by the editor inspector and script debugger, but can also be used in plugins to pass and display objects as their IDs.
+ */
+export class EncodedObjectAsID extends RefCounted {
+    constructor(name = 254) { super(name); }
+
+    /**
+     * The {@link Object} identifier stored in this {@link EncodedObjectAsID} instance. The object instance can be retrieved with {@link instanceFromId}.
+     */
+    get objectId(): number { return _C(this, 5684) as number; }
+    set objectId(v: number) { _C(this, 12156, v); }
+
+    static readonly name = _R(254, EncodedObjectAsID);
+}