UDPServer

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