Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

UDPServer

繼承： RefCounted < Object

用於實作 UDP 伺服器的輔助類。

說明

A simple server that opens a UDP socket and returns connected PacketPeerUDP upon receiving new packets. See also PacketPeerUDP.connect_to_host().

After starting the server (listen()), you will need to poll() it at regular intervals (e.g. inside Node._process()) for it to process new packets, delivering them to the appropriate PacketPeerUDP, and taking new connections.

Below a small example of how it can be used:

# server_node.gd
class_name ServerNode
extends Node

var server = UDPServer.new()
var peers = []

func _ready():
    server.listen(4242)

func _process(delta):
    server.poll() # Important!
    if server.is_connection_available():
        var peer = server.take_connection()
        var packet = peer.get_packet()
        print("Accepted peer: %s:%s" % [peer.get_packet_ip(), peer.get_packet_port()])
        print("Received data: %s" % [packet.get_string_from_utf8()])
        # Reply so it knows we received the message.
        peer.put_packet(packet)
        # Keep a reference so we can keep contacting the remote peer.
        peers.append(peer)

    for i in range(0, peers.size()):
        pass # Do something with the connected peers.

// ServerNode.cs
using Godot;
using System.Collections.Generic;

public partial class ServerNode : Node
{
    private UdpServer _server = new UdpServer();
    private List<PacketPeerUdp> _peers  = new List<PacketPeerUdp>();

    public override void _Ready()
    {
        _server.Listen(4242);
    }

    public override void _Process(double delta)
    {
        _server.Poll(); // Important!
        if (_server.IsConnectionAvailable())
        {
            PacketPeerUdp peer = _server.TakeConnection();
            byte[] packet = peer.GetPacket();
            GD.Print($"Accepted Peer: {peer.GetPacketIP()}:{peer.GetPacketPort()}");
            GD.Print($"Received Data: {packet.GetStringFromUtf8()}");
            // Reply so it knows we received the message.
            peer.PutPacket(packet);
            // Keep a reference so we can keep contacting the remote peer.
            _peers.Add(peer);
        }
        foreach (var peer in _peers)
        {
            // Do something with the peers.
        }
    }
}

# client_node.gd
class_name ClientNode
extends Node

var udp = PacketPeerUDP.new()
var connected = false

func _ready():
    udp.connect_to_host("127.0.0.1", 4242)

func _process(delta):
    if !connected:
        # Try to contact server
        udp.put_packet("The answer is... 42!".to_utf8_buffer())
    if udp.get_available_packet_count() > 0:
        print("Connected: %s" % udp.get_packet().get_string_from_utf8())
        connected = true

// ClientNode.cs
using Godot;

public partial class ClientNode : Node
{
    private PacketPeerUdp _udp = new PacketPeerUdp();
    private bool _connected = false;

    public override void _Ready()
    {
        _udp.ConnectToHost("127.0.0.1", 4242);
    }

    public override void _Process(double delta)
    {
        if (!_connected)
        {
            // Try to contact server
            _udp.PutPacket("The Answer Is..42!".ToUtf8Buffer());
        }
        if (_udp.GetAvailablePacketCount() > 0)
        {
            GD.Print($"Connected: {_udp.GetPacket().GetStringFromUtf8()}");
            _connected = true;
        }
    }
}

屬性

int

max_pending_connections

16

方法

int	get_local_port() const
bool	is_connection_available() const
bool	is_listening() const
Error	listen(port: int, bind_address: String = "*")
Error	poll()
void	stop()
PacketPeerUDP	take_connection()

屬性說明

int max_pending_connections = 16 🔗

void set_max_pending_connections(value: int)
int get_max_pending_connections()

定義最大的待定連接數，在poll()期間，任何超過該值的新待定連接將被自動放棄。把這個值設定為0可以有效地防止任何新的待定連接被接受，例如，當你的所有玩家都連接時。

方法說明

int get_local_port() const 🔗

返回該伺服器正在監聽的本地埠。

bool is_connection_available() const 🔗

如果在通訊端中收到一個具有新位址及埠組合的封包，則返回 true。

bool is_listening() const 🔗

如果通訊端是打開的，並且在監聽埠，則返回 true。

Error listen(port: int, bind_address: String = "*") 🔗

啟動伺服器，打開監聽給定埠 port 的 UDP 通訊端。還可以指定 bind_address，僅監聽發送至該位址的封包。另見 PacketPeerUDP.bind()。

Error poll() 🔗

Call this method at regular intervals (e.g. inside Node._process()) to process new packets. Any packet from a known address/port pair will be delivered to the appropriate PacketPeerUDP, while any packet received from an unknown address/port pair will be added as a pending connection (see is_connection_available() and take_connection()). The maximum number of pending connections is defined via max_pending_connections.

void stop() 🔗

停止伺服器，如果 UDP 通訊端處於打開狀態，就關閉它。將關閉所有通過 take_connection() 接受連接的 PacketPeerUDP（不會通知遠端對等體）。

PacketPeerUDP take_connection() 🔗

返回第一個掛起的連接（連接到適當的位址及埠）。如果沒有新的連接可用，將返回 null。另請參閱 is_connection_available()、PacketPeerUDP.connect_to_host()。