Index · Object → RefCounted → PacketPeer → MultiplayerPeer

MultiplayerPeer

Abstract class for specialized PacketPeers used by the MultiplayerAPI.

Inherited by (5): ENetMultiplayerPeerMultiplayerPeerExtensionOfflineMultiplayerPeerWebRTCMultiplayerPeerWebSocketMultiplayerPeer
Class Description

Manages the connection with one or more remote peers acting as server or client and assigning unique IDs to each of them. See also MultiplayerAPI.

Note: The 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.

Properties

var refuse_new_connections: bool = false

If true, this MultiplayerPeer refuses new connections.

var transfer_channel: int = 0

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 TransferMode) so that TRANSFER_MODE_RELIABLE and 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.

var transfer_mode: MultiplayerPeer.TransferMode = 2

The manner in which to send packets to the target peer. See the set_target_peer() method.

Inherited from PacketPeer (1)

Methods

func close() -> void

Immediately close the multiplayer peer returning to the state CONNECTION_DISCONNECTED. Connected peers will be dropped without emitting peer_disconnected.

func disconnect_peer(peer: int, force: bool = false) -> void

Disconnects the given peer from this host. If force is true the peer_disconnected signal will not be emitted for this peer.

func generate_unique_id() -> int

Returns a randomly generated integer that can be used as a network unique ID.

func get_connection_status() -> MultiplayerPeer.ConnectionStatus

Returns the current state of the connection.

func get_packet_channel() -> int

Returns the channel over which the next available packet was received. See PacketPeer.get_available_packet_count().

func get_packet_mode() -> MultiplayerPeer.TransferMode

Returns the transfer mode the remote peer used to send the next available packet. See PacketPeer.get_available_packet_count().

func get_packet_peer() -> int

Returns the ID of the MultiplayerPeer who sent the next available packet. See PacketPeer.get_available_packet_count().

func get_unique_id() -> int

Returns the ID of this MultiplayerPeer.

func is_server_relay_supported() -> bool

Returns true if the server can act as a relay in the current configuration. That is, if the higher level MultiplayerAPI should notify connected clients of other peers, and implement a relay protocol to allow communication between them.

func poll() -> void

Waits up to 1 second to receive a new network event.

func set_target_peer(id: int) -> void

Sets the peer to which packets will be sent.

The id can be one of: TARGET_PEER_BROADCAST to send to all connected peers, 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 TARGET_PEER_BROADCAST.

Inherited from PacketPeer (6)
func get_packet_error() -> Error
func get_var(allow_objects: bool = false) -> Variant
func put_packet(buffer: PackedByteArray) -> Error
func put_var(var: Variant, full_objects: bool = false) -> Error
Inherited from RefCounted (4)
func init_ref() -> bool
func reference() -> bool
func unreference() -> bool
Inherited from Object (62)
func _get(property: StringName) -> Variant
func _get_property_list() -> Dictionary[]
func _init() -> void
func _iter_get(iter: Variant) -> Variant
func _iter_init(iter: Array) -> bool
func _iter_next(iter: Array) -> bool
func _notification(what: int) -> void
func _set(property: StringName, value: Variant) -> bool
func _to_string() -> String
func _validate_property(property: Dictionary) -> void
func add_user_signal(signal: String, arguments: Array = []) -> void
func call(method: StringName) -> Variant
func callv(method: StringName, arg_array: Array) -> Variant
func cancel_free() -> void
func connect(signal: StringName, callable: Callable, flags: int = 0) -> Error
func disconnect(signal: StringName, callable: Callable) -> void
func emit_signal(signal: StringName) -> Error
func free() -> void
func get(property: StringName) -> Variant
func get_class() -> String
func get_incoming_connections() -> Dictionary[]
func get_indexed(property_path: NodePath) -> Variant
func get_meta(name: StringName, default: Variant = null) -> Variant
func get_meta_list() -> StringName[]
func get_method_list() -> Dictionary[]
func get_property_list() -> Dictionary[]
func get_signal_connection_list(signal: StringName) -> Dictionary[]
func get_signal_list() -> Dictionary[]
func has_meta(name: StringName) -> bool
func has_method(method: StringName) -> bool
func has_signal(signal: StringName) -> bool
func is_class(class: StringName) -> bool
func is_connected(signal: StringName, callable: Callable) -> bool
func notification(what: int, reversed: bool = false) -> void
func remove_meta(name: StringName) -> void
func remove_user_signal(signal: StringName) -> void
func set(property: StringName, value: Variant) -> void
func set_block_signals(enable: bool) -> void
func set_deferred(property: StringName, value: Variant) -> void
func set_indexed(property_path: NodePath, value: Variant) -> void
func set_message_translation(enable: bool) -> void
func set_meta(name: StringName, value: Variant) -> void
func set_script(script: Variant) -> void
func set_translation_domain(domain: StringName) -> void
func to_string() -> String
func tr(message: StringName, context: StringName = &"") -> String
func tr_n(message: StringName, plural_message: StringName, n: int, context: StringName = &"") -> String

Signals

signal peer_connected(id: int)

Emitted when a remote peer connects.

signal peer_disconnected(id: int)

Emitted when a remote peer has disconnected.

Inherited from Object (2)

Enums & Constants

enum ConnectionStatus
CONNECTION_DISCONNECTED = 0

The MultiplayerPeer is disconnected.

CONNECTION_CONNECTING = 1

The MultiplayerPeer is currently connecting to a server.

CONNECTION_CONNECTED = 2

This MultiplayerPeer is connected.

enum TransferMode
TRANSFER_MODE_UNRELIABLE = 0

Packets are not acknowledged, no resend attempts are made for lost packets. Packets may arrive in any order. Potentially faster than TRANSFER_MODE_UNRELIABLE_ORDERED. Use for non-critical data, and always consider whether the order matters.

TRANSFER_MODE_UNRELIABLE_ORDERED = 1

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 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_RELIABLE = 2

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.

const TARGET_PEER_BROADCAST = 0

Packets are sent to all connected peers.

const TARGET_PEER_SERVER = 1

Packets are sent to the remote peer acting as server.