mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2025-12-31 09:49:22 +03:00
309 lines
16 KiB
ReStructuredText
309 lines
16 KiB
ReStructuredText
:github_url: hide
|
||
|
||
.. _class_PacketPeerUDP:
|
||
|
||
PacketPeerUDP
|
||
=============
|
||
|
||
**Hérite de :** :ref:`PacketPeer<class_PacketPeer>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
|
||
|
||
Homologue de paquet UDP.
|
||
|
||
.. rst-class:: classref-introduction-group
|
||
|
||
Description
|
||
-----------
|
||
|
||
UDP packet peer. Can be used to send and receive raw UDP packets as well as :ref:`Variant<class_Variant>`\ s.
|
||
|
||
\ **Example:** Send a packet:
|
||
|
||
::
|
||
|
||
var peer = PacketPeerUDP.new()
|
||
|
||
# Optionally, you can select the local port used to send the packet.
|
||
peer.bind(4444)
|
||
|
||
peer.set_dest_address("1.1.1.1", 4433)
|
||
peer.put_packet("hello".to_utf8_buffer())
|
||
|
||
\ **Example:** Listen for packets:
|
||
|
||
::
|
||
|
||
var peer
|
||
|
||
func _ready():
|
||
peer = PacketPeerUDP.new()
|
||
peer.bind(4433)
|
||
|
||
|
||
func _process(_delta):
|
||
if peer.get_available_packet_count() > 0:
|
||
var array_bytes = peer.get_packet()
|
||
var packet_string = array_bytes.get_string_from_ascii()
|
||
print("Received message: ", packet_string)
|
||
|
||
\ **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.
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Méthodes
|
||
----------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`bind<class_PacketPeerUDP_method_bind>`\ (\ port\: :ref:`int<class_int>`, bind_address\: :ref:`String<class_String>` = "*", recv_buf_size\: :ref:`int<class_int>` = 65536\ ) |
|
||
+---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`close<class_PacketPeerUDP_method_close>`\ (\ ) |
|
||
+---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`connect_to_host<class_PacketPeerUDP_method_connect_to_host>`\ (\ host\: :ref:`String<class_String>`, port\: :ref:`int<class_int>`\ ) |
|
||
+---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`get_local_port<class_PacketPeerUDP_method_get_local_port>`\ (\ ) |const| |
|
||
+---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`get_packet_ip<class_PacketPeerUDP_method_get_packet_ip>`\ (\ ) |const| |
|
||
+---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`get_packet_port<class_PacketPeerUDP_method_get_packet_port>`\ (\ ) |const| |
|
||
+---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_bound<class_PacketPeerUDP_method_is_bound>`\ (\ ) |const| |
|
||
+---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_socket_connected<class_PacketPeerUDP_method_is_socket_connected>`\ (\ ) |const| |
|
||
+---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`join_multicast_group<class_PacketPeerUDP_method_join_multicast_group>`\ (\ multicast_address\: :ref:`String<class_String>`, interface_name\: :ref:`String<class_String>`\ ) |
|
||
+---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`leave_multicast_group<class_PacketPeerUDP_method_leave_multicast_group>`\ (\ multicast_address\: :ref:`String<class_String>`, interface_name\: :ref:`String<class_String>`\ ) |
|
||
+---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`set_broadcast_enabled<class_PacketPeerUDP_method_set_broadcast_enabled>`\ (\ enabled\: :ref:`bool<class_bool>`\ ) |
|
||
+---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`set_dest_address<class_PacketPeerUDP_method_set_dest_address>`\ (\ host\: :ref:`String<class_String>`, port\: :ref:`int<class_int>`\ ) |
|
||
+---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`wait<class_PacketPeerUDP_method_wait>`\ (\ ) |
|
||
+---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Descriptions des méthodes
|
||
--------------------------------------------------
|
||
|
||
.. _class_PacketPeerUDP_method_bind:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Error<enum_@GlobalScope_Error>` **bind**\ (\ port\: :ref:`int<class_int>`, bind_address\: :ref:`String<class_String>` = "*", recv_buf_size\: :ref:`int<class_int>` = 65536\ ) :ref:`🔗<class_PacketPeerUDP_method_bind>`
|
||
|
||
Binds this **PacketPeerUDP** to the specified ``port`` and ``bind_address`` with a buffer size ``recv_buf_size``, allowing it to receive incoming packets.
|
||
|
||
If ``bind_address`` is set to ``"*"`` (default), the peer will be bound on all available addresses (both IPv4 and IPv6).
|
||
|
||
If ``bind_address`` is set to ``"0.0.0.0"`` (for IPv4) or ``"::"`` (for IPv6), the peer will be bound to all available addresses matching that IP type.
|
||
|
||
If ``bind_address`` is set to any valid address (e.g. ``"192.168.1.101"``, ``"::1"``, etc.), the peer will only be bound to the interface with that address (or fail if no interface with the given address exists).
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PacketPeerUDP_method_close:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **close**\ (\ ) :ref:`🔗<class_PacketPeerUDP_method_close>`
|
||
|
||
Closes the **PacketPeerUDP**'s underlying UDP socket.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PacketPeerUDP_method_connect_to_host:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Error<enum_@GlobalScope_Error>` **connect_to_host**\ (\ host\: :ref:`String<class_String>`, port\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PacketPeerUDP_method_connect_to_host>`
|
||
|
||
Calling this method connects this UDP peer to the given ``host``/``port`` pair. UDP is in reality connectionless, so this option only means that incoming packets from different addresses are automatically discarded, and that outgoing packets are always sent to the connected address (future calls to :ref:`set_dest_address()<class_PacketPeerUDP_method_set_dest_address>` are not allowed). This method does not send any data to the remote peer, to do that, use :ref:`PacketPeer.put_var()<class_PacketPeer_method_put_var>` or :ref:`PacketPeer.put_packet()<class_PacketPeer_method_put_packet>` as usual. See also :ref:`UDPServer<class_UDPServer>`.
|
||
|
||
\ **Note:** Connecting to the remote peer does not help to protect from malicious attacks like IP spoofing, etc. Think about using an encryption technique like TLS or DTLS if you feel like your application is transferring sensitive information.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PacketPeerUDP_method_get_local_port:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **get_local_port**\ (\ ) |const| :ref:`🔗<class_PacketPeerUDP_method_get_local_port>`
|
||
|
||
Renvoie le port local auquel ce pair est lié.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PacketPeerUDP_method_get_packet_ip:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **get_packet_ip**\ (\ ) |const| :ref:`🔗<class_PacketPeerUDP_method_get_packet_ip>`
|
||
|
||
Renvoie l'IP du pair distant qui a envoyé le dernier paquet (qui a été reçu avec :ref:`PacketPeer.get_packet()<class_PacketPeer_method_get_packet>` ou :ref:`PacketPeer.get_var()<class_PacketPeer_method_get_var>`).
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PacketPeerUDP_method_get_packet_port:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **get_packet_port**\ (\ ) |const| :ref:`🔗<class_PacketPeerUDP_method_get_packet_port>`
|
||
|
||
Renvoie le port du pair distant qui a envoyé le dernier paquet (qui a été reçu avec :ref:`PacketPeer.get_packet()<class_PacketPeer_method_get_packet>` ou :ref:`PacketPeer.get_var()<class_PacketPeer_method_get_var>`).
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PacketPeerUDP_method_is_bound:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_bound**\ (\ ) |const| :ref:`🔗<class_PacketPeerUDP_method_is_bound>`
|
||
|
||
Returns whether this **PacketPeerUDP** is bound to an address and can receive packets.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PacketPeerUDP_method_is_socket_connected:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_socket_connected**\ (\ ) |const| :ref:`🔗<class_PacketPeerUDP_method_is_socket_connected>`
|
||
|
||
Renvoie ``true`` si le socket UDP est ouvert et a été connecté à une adresse distante. Voir :ref:`connect_to_host()<class_PacketPeerUDP_method_connect_to_host>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PacketPeerUDP_method_join_multicast_group:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Error<enum_@GlobalScope_Error>` **join_multicast_group**\ (\ multicast_address\: :ref:`String<class_String>`, interface_name\: :ref:`String<class_String>`\ ) :ref:`🔗<class_PacketPeerUDP_method_join_multicast_group>`
|
||
|
||
Joins the multicast group specified by ``multicast_address`` using the interface identified by ``interface_name``.
|
||
|
||
You can join the same multicast group with multiple interfaces. Use :ref:`IP.get_local_interfaces()<class_IP_method_get_local_interfaces>` to know which are available.
|
||
|
||
\ **Note:** Some Android devices might require the ``CHANGE_WIFI_MULTICAST_STATE`` permission for multicast to work.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PacketPeerUDP_method_leave_multicast_group:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Error<enum_@GlobalScope_Error>` **leave_multicast_group**\ (\ multicast_address\: :ref:`String<class_String>`, interface_name\: :ref:`String<class_String>`\ ) :ref:`🔗<class_PacketPeerUDP_method_leave_multicast_group>`
|
||
|
||
Removes the interface identified by ``interface_name`` from the multicast group specified by ``multicast_address``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PacketPeerUDP_method_set_broadcast_enabled:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **set_broadcast_enabled**\ (\ enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_PacketPeerUDP_method_set_broadcast_enabled>`
|
||
|
||
Active ou désactive l'envoi de paquets de diffusion (par exemple ``set_dest_address("255.255.255.255", 4343)``. Cette option est désactivée par défaut.
|
||
|
||
\ **Note :** Certains appareils Android peuvent nécessiter la permission ``CHANGE_WIFI_MULTICAST_STATE`` et cette option pour être activée pour recevoir aussi des paquets de diffusion.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PacketPeerUDP_method_set_dest_address:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Error<enum_@GlobalScope_Error>` **set_dest_address**\ (\ host\: :ref:`String<class_String>`, port\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PacketPeerUDP_method_set_dest_address>`
|
||
|
||
Définit l'adresse de destination et le port pour envoyer des paquets et des variables. Un nom d'hôte sera résolu en utilisant le DNS si nécessaire.
|
||
|
||
\ **Note :** :ref:`set_broadcast_enabled()<class_PacketPeerUDP_method_set_broadcast_enabled>` doit être activé avant d'envoyer des paquets à une adresse de diffusion (par exemple ``255.255.255``).
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PacketPeerUDP_method_wait:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Error<enum_@GlobalScope_Error>` **wait**\ (\ ) :ref:`🔗<class_PacketPeerUDP_method_wait>`
|
||
|
||
Waits for a packet to arrive on the bound address. See :ref:`bind()<class_PacketPeerUDP_method_bind>`.
|
||
|
||
\ **Note:** :ref:`wait()<class_PacketPeerUDP_method_wait>` can't be interrupted once it has been called. This can be worked around by allowing the other party to send a specific "death pill" packet like this:
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
socket = PacketPeerUDP.new()
|
||
# Server
|
||
socket.set_dest_address("127.0.0.1", 789)
|
||
socket.put_packet("Time to stop".to_ascii_buffer())
|
||
|
||
# Client
|
||
while socket.wait() == OK:
|
||
var data = socket.get_packet().get_string_from_ascii()
|
||
if data == "Time to stop":
|
||
return
|
||
|
||
.. code-tab:: csharp
|
||
|
||
var socket = new PacketPeerUdp();
|
||
// Server
|
||
socket.SetDestAddress("127.0.0.1", 789);
|
||
socket.PutPacket("Time to stop".ToAsciiBuffer());
|
||
|
||
// Client
|
||
while (socket.Wait() == OK)
|
||
{
|
||
string data = socket.GetPacket().GetStringFromASCII();
|
||
if (data == "Time to stop")
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
.. |virtual| replace:: :abbr:`virtual (Cette méthode doit typiquement être redéfinie par l'utilisateur pour avoir un effet.)`
|
||
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
|
||
.. |const| replace:: :abbr:`const (Cette méthode n'a pas d'effets de bord. Elle ne modifie aucune des variables membres de l'instance.)`
|
||
.. |vararg| replace:: :abbr:`vararg (Cette méthode accepte n'importe quel nombre d'arguments après ceux décris ici.)`
|
||
.. |constructor| replace:: :abbr:`constructor (Cette méthode est utilisée pour construire un type.)`
|
||
.. |static| replace:: :abbr:`static (Cette méthode n'a pas besoin d'instance pour être appelée, elle peut donc être directement appelée en utilisant le nom de la classe.)`
|
||
.. |operator| replace:: :abbr:`operator (Cette méthode décrit un opérateur valide à utiliser avec ce type en tant qu'opérande gauche.)`
|
||
.. |bitfield| replace:: :abbr:`BitField (Cette valeur est un nombre entier composé d'un masque de bits des options suivantes.)`
|
||
.. |void| replace:: :abbr:`void (Aucune valeur de retour.)`
|