@ringozz/godot 0.1.0

package/gen/classes/MultiplayerAPIExtension.ts

@@ -0,0 +1,99 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { MultiplayerAPI } from './MultiplayerAPI.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotArray, PackedInt32Array, StringName, Variant } from '../heap-types/index.ts';
+import type { MultiplayerPeer } from './MultiplayerPeer.ts';
+import type { Object } from './Object.ts';
+
+/**
+ * This class can be used to extend or replace the default {@link MultiplayerAPI} implementation via script or extensions.
+ * The following example extend the default implementation ({@link SceneMultiplayer}) by logging every RPC being made, and every object being configured for replication.
+ *
+ *
+ * ```gdscript
+ *
+ * extends MultiplayerAPIExtension
+ * class_name LogMultiplayer
+ *
+ * # We want to extend the default SceneMultiplayer.
+ * var base_multiplayer = SceneMultiplayer.new()
+ *
+ * func _init():
+ * 	# Just passthrough base signals (copied to var to avoid cyclic reference)
+ * 	var cts = connected_to_server
+ * 	var cf = connection_failed
+ * 	var sd = server_disconnected
+ * 	var pc = peer_connected
+ * 	var pd = peer_disconnected
+ * 	base_multiplayer.connected_to_server.connect(func(): cts.emit())
+ * 	base_multiplayer.connection_failed.connect(func(): cf.emit())
+ * 	base_multiplayer.server_disconnected.connect(func(): sd.emit())
+ * 	base_multiplayer.peer_connected.connect(func(id): pc.emit(id))
+ * 	base_multiplayer.peer_disconnected.connect(func(id): pd.emit(id))
+ *
+ * func _poll():
+ * 	return base_multiplayer.poll()
+ *
+ * # Log RPC being made and forward it to the default multiplayer.
+ * func _rpc(peer: int, object: Object, method: StringName, args: Array) -> Error:
+ * 	print("Got RPC for %d: %s::%s(%s)" % [peer, object, method, args])
+ * 	return base_multiplayer.rpc(peer, object, method, args)
+ *
+ * # Log configuration add. E.g. root path (nullptr, NodePath), replication (Node, Spawner|Synchronizer), custom.
+ * func _object_configuration_add(object, config: Variant) -> Error:
+ * 	if config is MultiplayerSynchronizer:
+ * 		print("Adding synchronization configuration for %s. Synchronizer: %s" % [object, config])
+ * 	elif config is MultiplayerSpawner:
+ * 		print("Adding node %s to the spawn list. Spawner: %s" % [object, config])
+ * 	return base_multiplayer.object_configuration_add(object, config)
+ *
+ * # Log configuration remove. E.g. root path (nullptr, NodePath), replication (Node, Spawner|Synchronizer), custom.
+ * func _object_configuration_remove(object, config: Variant) -> Error:
+ * 	if config is MultiplayerSynchronizer:
+ * 		print("Removing synchronization configuration for %s. Synchronizer: %s" % [object, config])
+ * 	elif config is MultiplayerSpawner:
+ * 		print("Removing node %s from the spawn list. Spawner: %s" % [object, config])
+ * 	return base_multiplayer.object_configuration_remove(object, config)
+ *
+ * # These can be optional, but in our case we want to extend SceneMultiplayer, so forward everything.
+ * func _set_multiplayer_peer(p_peer: MultiplayerPeer):
+ * 	base_multiplayer.multiplayer_peer = p_peer
+ *
+ * func _get_multiplayer_peer() -> MultiplayerPeer:
+ * 	return base_multiplayer.multiplayer_peer
+ *
+ * func _get_unique_id() -> int:
+ * 	return base_multiplayer.get_unique_id()
+ *
+ * func _get_remote_sender_id() -> int:
+ * 	return base_multiplayer.get_remote_sender_id()
+ *
+ * func _get_peer_ids() -> PackedInt32Array:
+ * 	return base_multiplayer.get_peers()
+ *
+ * ```
+ *
+ *
+ * Then in your main scene or in an autoload call {@link SceneTree.setMultiplayer} to start using your custom {@link MultiplayerAPI}:
+ *
+ *
+ * ```gdscript
+ *
+ * # autoload.gd
+ * func _enter_tree():
+ * 	# Sets our custom multiplayer as the main one in SceneTree.
+ * 	get_tree().set_multiplayer(LogMultiplayer.new())
+ *
+ * ```
+ *
+ *
+ * Native extensions can alternatively use the {@link MultiplayerAPI.setDefaultInterface} method during initialization to configure themselves as the default implementation.
+ */
+export class MultiplayerAPIExtension extends MultiplayerAPI {
+    constructor(name = 427) { super(name); }
+
+    static readonly name = _R(427, MultiplayerAPIExtension);
+}

package/gen/classes/MultiplayerPeer.ts

@@ -0,0 +1,148 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { PacketPeer } from './PacketPeer.ts';
+import type { Signal } from '../heap-types/index.ts';
+
+/**
+ * Manages the connection with one or more remote peers acting as server or client and assigning unique IDs to each of them. See also {@link MultiplayerAPI}.
+ * **Note:** The {@link MultiplayerAPI} protocol is an implementation detail and isn't meant to be used by non-Godot servers. It may change without notice.
+ * **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 MultiplayerPeer extends PacketPeer {
+
+    /**
+     * Sets the peer to which packets will be sent.
+     * The `id` can be one of: {@link TARGET_PEER_BROADCAST} to send to all connected peers, {@link TARGET_PEER_SERVER} to send to the peer acting as server, a valid peer ID to send to that specific peer, a negative peer ID to send to all peers except that one. By default, the target peer is {@link TARGET_PEER_BROADCAST}.
+     */
+    setTargetPeer(id: number): void { _C(this, 13006, id); }
+
+    /**
+     * Returns the ID of the {@link MultiplayerPeer} who sent the next available packet. See {@link PacketPeer.getAvailablePacketCount}.
+     */
+    getPacketPeer(): number { return _C(this, 5791) as number; }
+
+    /**
+     * Returns the channel over which the next available packet was received. See {@link PacketPeer.getAvailablePacketCount}.
+     */
+    getPacketChannel(): number { return _C(this, 5784) as number; }
+
+    /**
+     * Returns the transfer mode the remote peer used to send the next available packet. See {@link PacketPeer.getAvailablePacketCount}.
+     */
+    getPacketMode(): TransferMode { return _C(this, 5790) as TransferMode; }
+
+    /**
+     * Waits up to 1 second to receive a new network event.
+     */
+    poll(): void { _C(this, 9471); }
+
+    /**
+     * Immediately close the multiplayer peer returning to the state {@link CONNECTION_DISCONNECTED}. Connected peers will be dropped without emitting {@link peer_disconnected}.
+     */
+    close(): void { _C(this, 2331); }
+
+    /**
+     * Disconnects the given `peer` from this host. If `force` is `true` the {@link peer_disconnected} signal will not be emitted for this peer.
+     */
+    disconnectPeer(peer: number, force?: boolean /* = false */): void { _C(this, 2827, peer, force); }
+
+    /**
+     * Returns the current state of the connection.
+     */
+    getConnectionStatus(): ConnectionStatus { return _C(this, 4278) as ConnectionStatus; }
+
+    /**
+     * Returns the ID of this {@link MultiplayerPeer}.
+     */
+    getUniqueId(): number { return _C(this, 6951) as number; }
+
+    /**
+     * Returns a randomly generated integer that can be used as a network unique ID.
+     */
+    generateUniqueId(): number { return _C(this, 3643) as number; }
+
+    /**
+     * Returns `true` if the server can act as a relay in the current configuration. That is, if the higher level {@link MultiplayerAPI} should notify connected clients of other peers, and implement a relay protocol to allow communication between them.
+     */
+    isServerRelaySupported(): boolean { return _C(this, 8292) as boolean; }
+
+    /**
+     * If `true`, this {@link MultiplayerPeer} refuses new connections.
+     */
+    get refuseNewConnections(): boolean { return _C(this, 8234) as boolean; }
+    set refuseNewConnections(v: boolean) { _C(this, 12504, v); }
+
+    /**
+     * The manner in which to send packets to the target peer. See the {@link setTargetPeer} method.
+     */
+    get transferMode(): TransferMode { return _C(this, 6873) as TransferMode; }
+    set transferMode(v: TransferMode) { _C(this, 13133, v); }
+
+    /**
+     * The channel to use to send packets. Many network APIs such as ENet and WebRTC allow the creation of multiple independent channels which behaves, in a way, like separate connections. This means that reliable data will only block delivery of other packets on that channel, and ordering will only be in respect to the channel the packet is being sent on. Using different channels to send **different and independent** state updates is a common way to optimize network usage and decrease latency in fast-paced games.
+     * **Note:** The default channel (`0`) actually works as 3 separate channels (one for each {@link TransferMode}) so that {@link TRANSFER_MODE_RELIABLE} and {@link TRANSFER_MODE_UNRELIABLE_ORDERED} does not interact with each other by default. Refer to the specific network API documentation (e.g. ENet or WebRTC) to learn how to set up channels correctly.
+     */
+    get transferChannel(): number { return _C(this, 6872) as number; }
+    set transferChannel(v: number) { _C(this, 13132, v); }
+
+    /**
+     * Packets are sent to all connected peers.
+     */
+    static readonly TARGET_PEER_BROADCAST = 0;
+
+    /**
+     * Packets are sent to the remote peer acting as server.
+     */
+    static readonly TARGET_PEER_SERVER = 1;
+
+    /**
+     * Emitted when a remote peer connects.
+     */
+    get peerConnected(): Signal<(id: number) => void> { return _G(this, 9388) as Signal<(id: number) => void>; }
+    set peerConnected(v: ((id: number) => void) | null) { _G(this, 9388, v); }
+
+    /**
+     * Emitted when a remote peer has disconnected.
+     */
+    get peerDisconnected(): Signal<(id: number) => void> { return _G(this, 9392) as Signal<(id: number) => void>; }
+    set peerDisconnected(v: ((id: number) => void) | null) { _G(this, 9392, v); }
+
+    static readonly name = _R(428, MultiplayerPeer);
+}
+
+export const ConnectionStatus = {
+    /**
+     * The MultiplayerPeer is disconnected.
+     */
+    CONNECTION_DISCONNECTED: 0,
+    /**
+     * The MultiplayerPeer is currently connecting to a server.
+     */
+    CONNECTION_CONNECTING: 1,
+    /**
+     * This MultiplayerPeer is connected.
+     */
+    CONNECTION_CONNECTED: 2,
+} as const;
+
+export type ConnectionStatus = (typeof ConnectionStatus)[keyof typeof ConnectionStatus];
+
+export const TransferMode = {
+    /**
+     * Packets are not acknowledged, no resend attempts are made for lost packets. Packets may arrive in any order. Potentially faster than {@link TRANSFER_MODE_UNRELIABLE_ORDERED}. Use for non-critical data, and always consider whether the order matters.
+     */
+    TRANSFER_MODE_UNRELIABLE: 0,
+    /**
+     * Packets are not acknowledged, no resend attempts are made for lost packets. Packets are received in the order they were sent in. Potentially faster than {@link TRANSFER_MODE_RELIABLE}. Use for non-critical data or data that would be outdated if received late due to resend attempt(s) anyway, for example movement and positional data.
+     */
+    TRANSFER_MODE_UNRELIABLE_ORDERED: 1,
+    /**
+     * Packets must be received and resend attempts should be made until the packets are acknowledged. Packets must be received in the order they were sent in. Most reliable transfer mode, but potentially the slowest due to the overhead. Use for critical data that must be transmitted and arrive in order, for example an ability being triggered or a chat message. Consider carefully if the information really is critical, and use sparingly.
+     */
+    TRANSFER_MODE_RELIABLE: 2,
+} as const;
+
+export type TransferMode = (typeof TransferMode)[keyof typeof TransferMode];
+

package/gen/classes/MultiplayerPeerExtension.ts

@@ -0,0 +1,17 @@
+// 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 { PackedByteArray } from '../heap-types/index.ts';
+import type { ConnectionStatus, TransferMode } from './MultiplayerPeer.ts';
+
+/**
+ * This class is designed to be inherited from a GDExtension plugin to implement custom networking layers for the multiplayer API (such as WebRTC). All the methods below **must** be implemented to have a working custom multiplayer implementation. See also {@link MultiplayerAPI}.
+ */
+export class MultiplayerPeerExtension extends MultiplayerPeer {
+    constructor(name = 429) { super(name); }
+
+    static readonly name = _R(429, MultiplayerPeerExtension);
+}

package/gen/classes/MultiplayerSpawner.ts

@@ -0,0 +1,75 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node } from './Node.ts';
+import type { Callable, NodePath, Signal, Variant } from '../heap-types/index.ts';
+
+/**
+ * Spawnable scenes can be configured in the editor or through code (see {@link addSpawnableScene}).
+ * Also supports custom node spawns through {@link spawn}, calling {@link spawnFunction} on all peers.
+ * Internally, {@link MultiplayerSpawner} uses {@link MultiplayerAPI.objectConfigurationAdd} to notify spawns passing the spawned node as the `object` and itself as the `configuration`, and {@link MultiplayerAPI.objectConfigurationRemove} to notify despawns in a similar way.
+ */
+export class MultiplayerSpawner extends Node {
+    constructor(name = 430) { super(name); }
+
+    /**
+     * Adds a scene path to spawnable scenes, making it automatically replicated from the multiplayer authority to other peers when added as children of the node pointed by {@link spawnPath}.
+     */
+    addSpawnableScene(path: string): void { _C(this, 1293, path); }
+
+    /**
+     * Returns the count of spawnable scene paths.
+     */
+    getSpawnableSceneCount(): number { return _C(this, 6485) as number; }
+
+    /**
+     * Returns the spawnable scene path by index.
+     */
+    getSpawnableScene(index: number): string { return _C(this, 6484, index) as string; }
+
+    /**
+     * Clears all spawnable scenes. Does not despawn existing instances on remote peers.
+     */
+    clearSpawnableScenes(): void { _C(this, 2296); }
+
+    /**
+     * Requests a custom spawn, with `data` passed to {@link spawnFunction} on all peers. Returns the locally spawned node instance already inside the scene tree, and added as a child of the node pointed by {@link spawnPath}.
+     * **Note:** Spawnable scenes are spawned automatically. {@link spawn} is only needed for custom spawns.
+     */
+    spawn(data?: Variant /* = null */): Node { return _C(this, 13766, data) as Node; }
+
+    /**
+     * Path to the spawn root. Spawnable scenes that are added as direct children are replicated to other peers.
+     */
+    get spawnPath(): NodePath { return _C(this, 6483) as NodePath; }
+    set spawnPath(v: NodePath) { _C(this, 12830, v); }
+
+    /**
+     * Maximum number of nodes allowed to be spawned by this spawner. Includes both spawnable scenes and custom spawns.
+     * When set to `0` (the default), there is no limit.
+     */
+    get spawnLimit(): number { return _C(this, 6482) as number; }
+    set spawnLimit(v: number) { _C(this, 12829, v); }
+
+    /**
+     * Method called on all peers when a custom {@link spawn} is requested by the authority. Will receive the `data` parameter, and should return a {@link Node} that is not in the scene tree.
+     * **Note:** The returned node should **not** be added to the scene with {@link Node.addChild}. This is done automatically.
+     */
+    get spawnFunction(): Callable { return _C(this, 6481) as Callable; }
+    set spawnFunction(v: Callable) { _C(this, 12828, v); }
+
+    /**
+     * Emitted when a spawnable scene or custom spawn was despawned by the multiplayer authority. Only called on remote peers.
+     */
+    get despawned(): Signal<(node: Node) => void> { return _G(this, 2759) as Signal<(node: Node) => void>; }
+    set despawned(v: ((node: Node) => void) | null) { _G(this, 2759, v); }
+
+    /**
+     * Emitted when a spawnable scene or custom spawn was spawned by the multiplayer authority. Only called on remote peers.
+     */
+    get spawned(): Signal<(node: Node) => void> { return _G(this, 13770) as Signal<(node: Node) => void>; }
+    set spawned(v: ((node: Node) => void) | null) { _G(this, 13770, v); }
+
+    static readonly name = _R(430, MultiplayerSpawner);
+}

package/gen/classes/MultiplayerSynchronizer.ts

@@ -0,0 +1,119 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node } from './Node.ts';
+import type { Callable, NodePath, Signal } from '../heap-types/index.ts';
+import type { SceneReplicationConfig } from './SceneReplicationConfig.ts';
+
+/**
+ * By default, {@link MultiplayerSynchronizer} synchronizes configured properties to all peers.
+ * Visibility can be handled directly with {@link setVisibilityFor} or as-needed with {@link addVisibilityFilter} and {@link updateVisibility}.
+ * {@link MultiplayerSpawner}s will handle nodes according to visibility of synchronizers as long as the node at {@link rootPath} was spawned by one.
+ * Internally, {@link MultiplayerSynchronizer} uses {@link MultiplayerAPI.objectConfigurationAdd} to notify synchronization start passing the {@link Node} at {@link rootPath} as the `object` and itself as the `configuration`, and uses {@link MultiplayerAPI.objectConfigurationRemove} to notify synchronization end in a similar way.
+ * **Note:** Synchronization is not supported for {@link Object} type properties, like {@link Resource}. Properties that are unique to each peer, like the instance IDs of {@link Object}s (see {@link Object.getInstanceId}) or {@link RID}s, will also not work in synchronization.
+ */
+export class MultiplayerSynchronizer extends Node {
+    constructor(name = 431) { super(name); }
+
+    /**
+     * Updates the visibility of `forPeer` according to visibility filters. If `forPeer` is `0` (the default), all peers' visibilties are updated.
+     */
+    updateVisibility(forPeer?: number /* = 0 */): void { _C(this, 14585, forPeer); }
+
+    /**
+     * Adds a peer visibility filter for this synchronizer.
+     * `filter` should take a peer ID {@link int} and return a {@link bool}.
+     */
+    addVisibilityFilter(filter: Callable): void { _C(this, 1336, filter); }
+
+    /**
+     * Removes a peer visibility filter from this synchronizer.
+     */
+    removeVisibilityFilter(filter: Callable): void { _C(this, 9990, filter); }
+
+    /**
+     * Sets the visibility of `peer` to `visible`. If `peer` is `0`, the value of {@link publicVisibility} will be updated instead.
+     */
+    setVisibilityFor(peer: number, visible: boolean): void { _C(this, 13318, peer, visible); }
+
+    /**
+     * Queries the current visibility for peer `peer`.
+     */
+    getVisibilityFor(peer: number): boolean { return _C(this, 7090, peer) as boolean; }
+
+    /**
+     * Node path that replicated properties are relative to.
+     * If {@link rootPath} was spawned by a {@link MultiplayerSpawner}, the node will be also be spawned and despawned based on this synchronizer visibility options.
+     */
+    get rootPath(): NodePath { return _C(this, 6201) as NodePath; }
+    set rootPath(v: NodePath) { _C(this, 12573, v); }
+
+    /**
+     * Time interval between synchronizations. Used when the replication is set to {@link SceneReplicationConfig.REPLICATION_MODE_ALWAYS}. If set to `0.0` (the default), synchronizations happen every network process frame.
+     */
+    get replicationInterval(): number { return _C(this, 6150) as number; }
+    set replicationInterval(v: number) { _C(this, 12532, v); }
+
+    /**
+     * Time interval between delta synchronizations. Used when the replication is set to {@link SceneReplicationConfig.REPLICATION_MODE_ON_CHANGE}. If set to `0.0` (the default), delta synchronizations happen every network process frame.
+     */
+    get deltaInterval(): number { return _C(this, 4462) as number; }
+    set deltaInterval(v: number) { _C(this, 11077, v); }
+
+    /**
+     * Resource containing which properties to synchronize.
+     */
+    get replicationConfig(): SceneReplicationConfig { return _C(this, 6149) as SceneReplicationConfig; }
+    set replicationConfig(v: SceneReplicationConfig) { _C(this, 12531, v); }
+
+    /**
+     * Specifies when visibility filters are updated.
+     */
+    get visibilityUpdateMode(): VisibilityUpdateMode { return _C(this, 7102) as VisibilityUpdateMode; }
+    set visibilityUpdateMode(v: VisibilityUpdateMode) { _C(this, 13330, v); }
+
+    /**
+     * Whether synchronization should be visible to all peers by default. See {@link setVisibilityFor} and {@link addVisibilityFilter} for ways of configuring fine-grained visibility options.
+     */
+    get publicVisibility(): boolean { return _C(this, 8449) as boolean; }
+    set publicVisibility(v: boolean) { _C(this, 13323, v); }
+
+    /**
+     * Emitted when a new synchronization state is received by this synchronizer after the properties have been updated.
+     */
+    get _synchronized(): Signal<() => void> { return _G(this, 14086) as Signal<() => void>; }
+    set _synchronized(v: (() => void) | null) { _G(this, 14086, v); }
+
+    /**
+     * Emitted when a new delta synchronization state is received by this synchronizer after the properties have been updated.
+     */
+    get deltaSynchronized(): Signal<() => void> { return _G(this, 2735) as Signal<() => void>; }
+    set deltaSynchronized(v: (() => void) | null) { _G(this, 2735, v); }
+
+    /**
+     * Emitted when visibility of `forPeer` is updated. See {@link updateVisibility}.
+     */
+    get visibilityChanged(): Signal<(forPeer: number) => void> { return _G(this, 14772) as Signal<(forPeer: number) => void>; }
+    set visibilityChanged(v: ((forPeer: number) => void) | null) { _G(this, 14772, v); }
+
+    static readonly name = _R(431, MultiplayerSynchronizer);
+}
+
+export const VisibilityUpdateMode = {
+    /**
+     * Visibility filters are updated during process frames (see {@link Node.NOTIFICATION_INTERNAL_PROCESS}).
+     */
+    VISIBILITY_PROCESS_IDLE: 0,
+    /**
+     * Visibility filters are updated during physics frames (see {@link Node.NOTIFICATION_INTERNAL_PHYSICS_PROCESS}).
+     */
+    VISIBILITY_PROCESS_PHYSICS: 1,
+    /**
+     * Visibility filters are not updated automatically, and must be updated manually by calling {@link updateVisibility}.
+     */
+    VISIBILITY_PROCESS_NONE: 2,
+} as const;
+
+export type VisibilityUpdateMode = (typeof VisibilityUpdateMode)[keyof typeof VisibilityUpdateMode];
+

package/gen/classes/Mutex.ts

@@ -0,0 +1,37 @@
+// 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';
+
+/**
+ * A synchronization mutex (mutual exclusion). This is used to synchronize multiple {@link Thread}s, and is equivalent to a binary {@link Semaphore}. It guarantees that only one thread can access a critical section at a time.
+ * This is a reentrant mutex, meaning that it can be locked multiple times by one thread, provided it also unlocks it as many times.
+ * **Warning:** To ensure proper cleanup without crashes or deadlocks, the following conditions must be met:
+ * - When a {@link Mutex}'s reference count reaches zero and it is therefore destroyed, no threads (including the one on which the destruction will happen) must have it locked.
+ * - When a {@link Thread}'s reference count reaches zero and it is therefore destroyed, it must not have any mutex locked.
+ */
+export class Mutex extends RefCounted {
+    constructor(name = 432) { super(name); }
+
+    /**
+     * Locks this {@link Mutex}, blocks until it is unlocked by the current owner.
+     * **Note:** This function returns without blocking if the thread already has ownership of the mutex.
+     */
+    lock(): void { _C(this, 8701); }
+
+    /**
+     * Tries locking this {@link Mutex}, but does not block. Returns `true` on success, `false` otherwise.
+     * **Note:** This function returns `true` if the thread already has ownership of the mutex.
+     */
+    tryLock(): boolean { return _C(this, 14422) as boolean; }
+
+    /**
+     * Unlocks this {@link Mutex}, leaving it to other threads.
+     * **Note:** If a thread called {@link lock} or {@link tryLock} multiple times while already having ownership of the mutex, it must also call {@link unlock} the same number of times in order to unlock it correctly.
+     * **Warning:** Calling {@link unlock} more times than {@link lock} on a given thread, thus ending up trying to unlock a non-locked mutex, is wrong and may causes crashes or deadlocks.
+     */
+    unlock(): void { _C(this, 14481); }
+
+    static readonly name = _R(432, Mutex);
+}