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

Eredita: RefCounted < Object

Classe di supporto per implementare un server UDP.

Descrizione

Un semplice server che apre un socket UDP e restituisce i PacketPeerUDP connessi quando riceve nuovi pacchetti. Vedi anche PacketPeerUDP.connect_to_host().

Dopo aver avviato il server (listen()), sarà necessario chiamare poll() a intervalli regolari (ad esempio all'interno di Node._process()) affinché elabori nuovi pacchetti, li consegni al PacketPeerUDP appropriato e prenda nuove connessioni.

Di seguito un piccolo esempio di come può essere utilizzato:

# server_node.gd
class_name ServerNode
extends Node

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

func _ready():
    server.listen(4242)

func _process(delta):
    server.poll() # Importante!
    if server.is_connection_available():
        var peer = server.take_connection()
        var packet = peer.get_packet()
        print("Peer accettato: %s:%s" % [peer.get_packet_ip(), peer.get_packet_port()])
        print("Dati riceviti: %s" % [packet.get_string_from_utf8()])
        # Rispondi per far sapere che abbiamo ricevuto il messaggio.
        peer.put_packet(packet)
        # Mantieni un riferimento per poter continuare a contattare il peer remoto.
        peers.append(peer)

    for i in range(0, peers.size()):
        pass # Fai qualcosa con i peer connessi.

// 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(); // Importante!
        if (_server.IsConnectionAvailable())
        {
            PacketPeerUdp peer = _server.TakeConnection();
            byte[] packet = peer.GetPacket();
            GD.Print($"Peer accettato: {peer.GetPacketIP()}:{peer.GetPacketPort()}");
            GD.Print($"Dati ricevuti: {packet.GetStringFromUtf8()}");
            // Rispondi per far sapere che abbiamo ricevuto il messaggio.
            peer.PutPacket(packet);
            // Mantieni un riferimento per poter continuare a contattare il peer remoto.
            _peers.Add(peer);
        }
        foreach (var peer in _peers)
        {
            // Fai qualcosa con i peer connessi.
        }
    }
}

# 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:
        # Prova a contattare il server
        udp.put_packet("La risposta è...42!".to_utf8_buffer())
    if udp.get_available_packet_count() > 0:
        print("Connesso: %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)
        {
            // Prova a contattare il server
            _udp.PutPacket("La risposta è...42!".ToUtf8Buffer());
        }
        if (_udp.GetAvailablePacketCount() > 0)
        {
            GD.Print($"Connesso: {_udp.GetPacket().GetStringFromUtf8()}");
            _connected = true;
        }
    }
}

Proprietà

int

max_pending_connections

16

Metodi

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()

Descrizioni delle proprietà

int max_pending_connections = 16 🔗

void set_max_pending_connections(value: int)
int get_max_pending_connections()

Definisci il numero massimo di connessioni in sospeso, durante poll(), qualsiasi nuova connessione in sospeso che superi quel valore sarà automaticamente rinunciata. Impostando questo valore su 0 si impedisce effettivamente che qualsiasi nuova connessione in sospeso sia accettata (ad esempio quando tutti i tuoi giocatori si sono connessi).

Descrizioni dei metodi

int get_local_port() const 🔗

Restituisce la porta locale che questo server sta ascoltando.

bool is_connection_available() const 🔗

Restituisce true se un pacchetto con una nuova combinazione indirizzo/porta è stato ricevuto sul socket.

bool is_listening() const 🔗

Restituisce true se il socket è aperto e in ascolto su una porta.

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

Avvia il server aprendo un socket UDP in ascolto sulla porta port. Facoltativamente, puoi specificare un bind_address per ascoltare solo i pacchetti inviati a quell'indirizzo. Vedi anche PacketPeerUDP.bind().

Error poll() 🔗

Chiama questo metodo a intervalli regolari (ad esempio all'interno di Node._process()) per elaborare nuovi pacchetti. Qualsiasi pacchetto da una coppia indirizzo/porta nota sarà consegnato al PacketPeerUDP appropriato, mentre qualsiasi pacchetto ricevuto da una coppia indirizzo/porta sconosciuta sarà aggiunto come connessione in sospeso (vedi is_connection_available() e take_connection()). Il numero massimo di connessioni in sospeso è definito tramite max_pending_connections.

void stop() 🔗

Arresta il server, chiudendo il socket UDP se aperto. Chiuderà tutti i PacketPeerUDP connessi accettati tramite take_connection() (i peer remoti non saranno notificati).

PacketPeerUDP take_connection() 🔗

Restituisce la prima connessione in sospeso (connesso all'indirizzo/porta appropriato). Restituirà null se nessuna nuova connessione è disponibile. Vedi anche is_connection_available(), PacketPeerUDP.connect_to_host().