mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2025-12-31 09:49:22 +03:00
416 lines
21 KiB
ReStructuredText
416 lines
21 KiB
ReStructuredText
:github_url: hide
|
|
|
|
.. meta::
|
|
:keywords: network
|
|
|
|
.. _class_MultiplayerPeer:
|
|
|
|
MultiplayerPeer
|
|
===============
|
|
|
|
**Eredita:** :ref:`PacketPeer<class_PacketPeer>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
|
|
|
|
**Ereditato da:** :ref:`ENetMultiplayerPeer<class_ENetMultiplayerPeer>`, :ref:`MultiplayerPeerExtension<class_MultiplayerPeerExtension>`, :ref:`OfflineMultiplayerPeer<class_OfflineMultiplayerPeer>`, :ref:`WebRTCMultiplayerPeer<class_WebRTCMultiplayerPeer>`, :ref:`WebSocketMultiplayerPeer<class_WebSocketMultiplayerPeer>`
|
|
|
|
Classe astratta per :ref:`PacketPeer<class_PacketPeer>` specializzati utilizzati da :ref:`MultiplayerAPI<class_MultiplayerAPI>`.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Descrizione
|
|
----------------------
|
|
|
|
Gestisce la connessione con uno o più peer remoti che agiscono come server o client e assegna ID univoci a ciascuno di essi. Vedi anche :ref:`MultiplayerAPI<class_MultiplayerAPI>`.
|
|
|
|
\ **Nota:** Il protocollo della :ref:`MultiplayerAPI<class_MultiplayerAPI>` è un dettaglio di implementazione e non è pensato per essere utilizzato da server non Godot. Potrebbe cambiare senza preavviso.
|
|
|
|
\ **Nota:** Quando si esporta su Android, assicurarsi di abilitare l'autorizzazione ``INTERNET`` nella preimpostazione d'esportazione Android prima di esportare il progetto o di utilizzare la distribuzione con un clic. Altrimenti, qualsiasi tipo di comunicazione di rete sarà bloccata da Android.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Tutorial
|
|
----------------
|
|
|
|
- :doc:`API Multigiocatore di alto livello <../tutorials/networking/high_level_multiplayer>`
|
|
|
|
.. rst-class:: classref-reftable-group
|
|
|
|
Proprietà
|
|
------------------
|
|
|
|
.. table::
|
|
:widths: auto
|
|
|
|
+--------------------------------------------------------+--------------------------------------------------------------------------------------+-----------+
|
|
| :ref:`bool<class_bool>` | :ref:`refuse_new_connections<class_MultiplayerPeer_property_refuse_new_connections>` | ``false`` |
|
|
+--------------------------------------------------------+--------------------------------------------------------------------------------------+-----------+
|
|
| :ref:`int<class_int>` | :ref:`transfer_channel<class_MultiplayerPeer_property_transfer_channel>` | ``0`` |
|
|
+--------------------------------------------------------+--------------------------------------------------------------------------------------+-----------+
|
|
| :ref:`TransferMode<enum_MultiplayerPeer_TransferMode>` | :ref:`transfer_mode<class_MultiplayerPeer_property_transfer_mode>` | ``2`` |
|
|
+--------------------------------------------------------+--------------------------------------------------------------------------------------+-----------+
|
|
|
|
.. rst-class:: classref-reftable-group
|
|
|
|
Metodi
|
|
------------
|
|
|
|
.. table::
|
|
:widths: auto
|
|
|
|
+----------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`close<class_MultiplayerPeer_method_close>`\ (\ ) |
|
|
+----------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`disconnect_peer<class_MultiplayerPeer_method_disconnect_peer>`\ (\ peer\: :ref:`int<class_int>`, force\: :ref:`bool<class_bool>` = false\ ) |
|
|
+----------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`generate_unique_id<class_MultiplayerPeer_method_generate_unique_id>`\ (\ ) |const| |
|
|
+----------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`ConnectionStatus<enum_MultiplayerPeer_ConnectionStatus>` | :ref:`get_connection_status<class_MultiplayerPeer_method_get_connection_status>`\ (\ ) |const| |
|
|
+----------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`get_packet_channel<class_MultiplayerPeer_method_get_packet_channel>`\ (\ ) |const| |
|
|
+----------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`TransferMode<enum_MultiplayerPeer_TransferMode>` | :ref:`get_packet_mode<class_MultiplayerPeer_method_get_packet_mode>`\ (\ ) |const| |
|
|
+----------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`get_packet_peer<class_MultiplayerPeer_method_get_packet_peer>`\ (\ ) |const| |
|
|
+----------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`get_unique_id<class_MultiplayerPeer_method_get_unique_id>`\ (\ ) |const| |
|
|
+----------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`is_server_relay_supported<class_MultiplayerPeer_method_is_server_relay_supported>`\ (\ ) |const| |
|
|
+----------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`poll<class_MultiplayerPeer_method_poll>`\ (\ ) |
|
|
+----------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`set_target_peer<class_MultiplayerPeer_method_set_target_peer>`\ (\ id\: :ref:`int<class_int>`\ ) |
|
|
+----------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Segnali
|
|
--------------
|
|
|
|
.. _class_MultiplayerPeer_signal_peer_connected:
|
|
|
|
.. rst-class:: classref-signal
|
|
|
|
**peer_connected**\ (\ id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_MultiplayerPeer_signal_peer_connected>`
|
|
|
|
Emesso quando un peer remoto si connette.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_MultiplayerPeer_signal_peer_disconnected:
|
|
|
|
.. rst-class:: classref-signal
|
|
|
|
**peer_disconnected**\ (\ id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_MultiplayerPeer_signal_peer_disconnected>`
|
|
|
|
Emesso quando un peer remoto si è disconnesso.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Enumerazioni
|
|
------------------------
|
|
|
|
.. _enum_MultiplayerPeer_ConnectionStatus:
|
|
|
|
.. rst-class:: classref-enumeration
|
|
|
|
enum **ConnectionStatus**: :ref:`🔗<enum_MultiplayerPeer_ConnectionStatus>`
|
|
|
|
.. _class_MultiplayerPeer_constant_CONNECTION_DISCONNECTED:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`ConnectionStatus<enum_MultiplayerPeer_ConnectionStatus>` **CONNECTION_DISCONNECTED** = ``0``
|
|
|
|
Il MultiplayerPeer è disconnesso.
|
|
|
|
.. _class_MultiplayerPeer_constant_CONNECTION_CONNECTING:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`ConnectionStatus<enum_MultiplayerPeer_ConnectionStatus>` **CONNECTION_CONNECTING** = ``1``
|
|
|
|
Il MultiplayerPeer si sta attualmente connettendo a un server.
|
|
|
|
.. _class_MultiplayerPeer_constant_CONNECTION_CONNECTED:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`ConnectionStatus<enum_MultiplayerPeer_ConnectionStatus>` **CONNECTION_CONNECTED** = ``2``
|
|
|
|
Questo MultiplayerPeer è connesso.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _enum_MultiplayerPeer_TransferMode:
|
|
|
|
.. rst-class:: classref-enumeration
|
|
|
|
enum **TransferMode**: :ref:`🔗<enum_MultiplayerPeer_TransferMode>`
|
|
|
|
.. _class_MultiplayerPeer_constant_TRANSFER_MODE_UNRELIABLE:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`TransferMode<enum_MultiplayerPeer_TransferMode>` **TRANSFER_MODE_UNRELIABLE** = ``0``
|
|
|
|
I pacchetti non sono confermati, non sono effettuati tentativi di reinvio per i pacchetti persi. I pacchetti possono arrivare in qualsiasi ordine. Potenzialmente più veloce di :ref:`TRANSFER_MODE_UNRELIABLE_ORDERED<class_MultiplayerPeer_constant_TRANSFER_MODE_UNRELIABLE_ORDERED>`. Utilizzare per dati non critici e considerare sempre se l'ordine è importante.
|
|
|
|
.. _class_MultiplayerPeer_constant_TRANSFER_MODE_UNRELIABLE_ORDERED:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`TransferMode<enum_MultiplayerPeer_TransferMode>` **TRANSFER_MODE_UNRELIABLE_ORDERED** = ``1``
|
|
|
|
I pacchetti non sono confermati, non sono effettuati tentativi di reinvio per i pacchetti persi. I pacchetti sono ricevuti nell'ordine in cui sono stati inviati. Potenzialmente più veloce di :ref:`TRANSFER_MODE_RELIABLE<class_MultiplayerPeer_constant_TRANSFER_MODE_RELIABLE>`. Utilizzare per dati non critici o dati che sarebbero comunque obsoleti se ricevuti in ritardo a causa dei tentativi di reinvio, ad esempio dati di movimento e di posizione.
|
|
|
|
.. _class_MultiplayerPeer_constant_TRANSFER_MODE_RELIABLE:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`TransferMode<enum_MultiplayerPeer_TransferMode>` **TRANSFER_MODE_RELIABLE** = ``2``
|
|
|
|
I pacchetti devono essere ricevuti e devono essere effettuati tentativi di reinvio finché i pacchetti non sono confermati. I pacchetti devono essere ricevuti nell'ordine in cui sono stati inviati. È la modalità di trasferimento più affidabile, ma potenzialmente la più lenta a causa del sovraccarico. Utilizzare per dati critici che devono essere trasmessi e arrivare in ordine, ad esempio un'abilità attivata o un messaggio in chat. Considerare attentamente se le informazioni sono davvero critiche e utilizzare con moderazione.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Costanti
|
|
----------------
|
|
|
|
.. _class_MultiplayerPeer_constant_TARGET_PEER_BROADCAST:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**TARGET_PEER_BROADCAST** = ``0`` :ref:`🔗<class_MultiplayerPeer_constant_TARGET_PEER_BROADCAST>`
|
|
|
|
I pacchetti sono inviati a tutti i peer connessi.
|
|
|
|
.. _class_MultiplayerPeer_constant_TARGET_PEER_SERVER:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**TARGET_PEER_SERVER** = ``1`` :ref:`🔗<class_MultiplayerPeer_constant_TARGET_PEER_SERVER>`
|
|
|
|
I pacchetti sono inviati al peer remoto che funge da server.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descrizioni delle proprietà
|
|
------------------------------------------------------
|
|
|
|
.. _class_MultiplayerPeer_property_refuse_new_connections:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`bool<class_bool>` **refuse_new_connections** = ``false`` :ref:`🔗<class_MultiplayerPeer_property_refuse_new_connections>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_refuse_new_connections**\ (\ value\: :ref:`bool<class_bool>`\ )
|
|
- :ref:`bool<class_bool>` **is_refusing_new_connections**\ (\ )
|
|
|
|
Se ``true``, questo **MultiplayerPeer** rifiuta nuove connessioni.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_MultiplayerPeer_property_transfer_channel:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`int<class_int>` **transfer_channel** = ``0`` :ref:`🔗<class_MultiplayerPeer_property_transfer_channel>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_transfer_channel**\ (\ value\: :ref:`int<class_int>`\ )
|
|
- :ref:`int<class_int>` **get_transfer_channel**\ (\ )
|
|
|
|
Il canale da usare per inviare pacchetti. Molte API di rete come ENet e WebRTC consentono la creazione di più canali indipendenti che si comportano, in un certo senso, come connessioni separate. Ciò significa che i dati affidabili bloccheranno solo la consegna di altri pacchetti su quel canale e l'ordinamento sarà solo in base al canale su cui il pacchetto viene inviato. Usare canali diversi per inviare aggiornamenti **diversi e indipendenti** di stato è un modo comune per ottimizzare l'utilizzo della rete e ridurre la latenza nei giochi molto dinamici.
|
|
|
|
\ **Nota:** Il canale predefinito (``0``) funziona in realtà come 3 canali separati (uno per ogni :ref:`TransferMode<enum_MultiplayerPeer_TransferMode>`) in modo che :ref:`TRANSFER_MODE_RELIABLE<class_MultiplayerPeer_constant_TRANSFER_MODE_RELIABLE>` e :ref:`TRANSFER_MODE_UNRELIABLE_ORDERED<class_MultiplayerPeer_constant_TRANSFER_MODE_UNRELIABLE_ORDERED>` non interagiscano tra loro per impostazione predefinita. Fai riferimento alla documentazione specifica dell'API di rete (ad esempio ENet o WebRTC) per imparare come impostare correttamente i canali.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_MultiplayerPeer_property_transfer_mode:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`TransferMode<enum_MultiplayerPeer_TransferMode>` **transfer_mode** = ``2`` :ref:`🔗<class_MultiplayerPeer_property_transfer_mode>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_transfer_mode**\ (\ value\: :ref:`TransferMode<enum_MultiplayerPeer_TransferMode>`\ )
|
|
- :ref:`TransferMode<enum_MultiplayerPeer_TransferMode>` **get_transfer_mode**\ (\ )
|
|
|
|
Il modo in cui inviare pacchetti al peer di destinazione. Vedi il metodo :ref:`set_target_peer()<class_MultiplayerPeer_method_set_target_peer>`.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descrizioni dei metodi
|
|
--------------------------------------------
|
|
|
|
.. _class_MultiplayerPeer_method_close:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **close**\ (\ ) :ref:`🔗<class_MultiplayerPeer_method_close>`
|
|
|
|
Chiude immediatamente il peer multigiocatore tornando allo stato :ref:`CONNECTION_DISCONNECTED<class_MultiplayerPeer_constant_CONNECTION_DISCONNECTED>`. I peer connessi verranno eliminati senza emettere :ref:`peer_disconnected<class_MultiplayerPeer_signal_peer_disconnected>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_MultiplayerPeer_method_disconnect_peer:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **disconnect_peer**\ (\ peer\: :ref:`int<class_int>`, force\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_MultiplayerPeer_method_disconnect_peer>`
|
|
|
|
Disconnette il ``peer`` fornito da questo host. Se ``force`` è ``true`` il segnale :ref:`peer_disconnected<class_MultiplayerPeer_signal_peer_disconnected>` non verrà emesso per questo peer.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_MultiplayerPeer_method_generate_unique_id:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`int<class_int>` **generate_unique_id**\ (\ ) |const| :ref:`🔗<class_MultiplayerPeer_method_generate_unique_id>`
|
|
|
|
Restituisce un numero intero generato a caso che può essere utilizzato come ID univoco di rete.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_MultiplayerPeer_method_get_connection_status:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`ConnectionStatus<enum_MultiplayerPeer_ConnectionStatus>` **get_connection_status**\ (\ ) |const| :ref:`🔗<class_MultiplayerPeer_method_get_connection_status>`
|
|
|
|
Restituisce lo stato attuale della connessione.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_MultiplayerPeer_method_get_packet_channel:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`int<class_int>` **get_packet_channel**\ (\ ) |const| :ref:`🔗<class_MultiplayerPeer_method_get_packet_channel>`
|
|
|
|
Restituisce il canale su cui è stato ricevuto il prossimo pacchetto disponibile. Vedi :ref:`PacketPeer.get_available_packet_count()<class_PacketPeer_method_get_available_packet_count>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_MultiplayerPeer_method_get_packet_mode:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`TransferMode<enum_MultiplayerPeer_TransferMode>` **get_packet_mode**\ (\ ) |const| :ref:`🔗<class_MultiplayerPeer_method_get_packet_mode>`
|
|
|
|
Restituisce la modalità di trasferimento utilizzata dal peer remoto per inviare il prossimo pacchetto disponibile. Vedi :ref:`PacketPeer.get_available_packet_count()<class_PacketPeer_method_get_available_packet_count>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_MultiplayerPeer_method_get_packet_peer:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`int<class_int>` **get_packet_peer**\ (\ ) |const| :ref:`🔗<class_MultiplayerPeer_method_get_packet_peer>`
|
|
|
|
Restituisce l'ID del **MultiplayerPeer** che ha inviato il prossimo pacchetto disponibile. Vedi :ref:`PacketPeer.get_available_packet_count()<class_PacketPeer_method_get_available_packet_count>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_MultiplayerPeer_method_get_unique_id:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`int<class_int>` **get_unique_id**\ (\ ) |const| :ref:`🔗<class_MultiplayerPeer_method_get_unique_id>`
|
|
|
|
Restituisce l'ID di questo **MultiplayerPeer**.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_MultiplayerPeer_method_is_server_relay_supported:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`bool<class_bool>` **is_server_relay_supported**\ (\ ) |const| :ref:`🔗<class_MultiplayerPeer_method_is_server_relay_supported>`
|
|
|
|
Restituisce ``true`` se il server può fungere da ripetitore nella configurazione attuale. Ovvero, se la :ref:`MultiplayerAPI<class_MultiplayerAPI>` di livello superiore deve notificare ai client connessi la presenza di altri peer, e implementare un protocollo di ripetizione per consentirne la comunicazione.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_MultiplayerPeer_method_poll:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **poll**\ (\ ) :ref:`🔗<class_MultiplayerPeer_method_poll>`
|
|
|
|
Attende fino a 1 secondo per ricevere un nuovo evento di rete.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_MultiplayerPeer_method_set_target_peer:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **set_target_peer**\ (\ id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_MultiplayerPeer_method_set_target_peer>`
|
|
|
|
Imposta il peer a cui verranno inviati i pacchetti.
|
|
|
|
L'``id`` può essere uno dei seguenti: :ref:`TARGET_PEER_BROADCAST<class_MultiplayerPeer_constant_TARGET_PEER_BROADCAST>` per inviare a tutti i peer connessi, :ref:`TARGET_PEER_SERVER<class_MultiplayerPeer_constant_TARGET_PEER_SERVER>` per inviare al peer che funge da server, un ID peer valido per inviare a quel peer specifico, un ID peer negativo da inviare a tutti i peer tranne quello. Come predefinito, il peer di destinazione è :ref:`TARGET_PEER_BROADCAST<class_MultiplayerPeer_constant_TARGET_PEER_BROADCAST>`.
|
|
|
|
.. |virtual| replace:: :abbr:`virtual (Questo metodo dovrebbe solitamente essere sovrascritto dall'utente per aver un effetto.)`
|
|
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
|
|
.. |const| replace:: :abbr:`const (Questo metodo non ha effetti collaterali. Non modifica alcuna variabile appartenente all'istanza.)`
|
|
.. |vararg| replace:: :abbr:`vararg (Questo metodo accetta qualsiasi numero di argomenti oltre a quelli descritti qui.)`
|
|
.. |constructor| replace:: :abbr:`constructor (Questo metodo è utilizzato per creare un tipo.)`
|
|
.. |static| replace:: :abbr:`static (Questo metodo non necessita di alcun'istanza per essere chiamato, quindi può essere chiamato direttamente usando il nome della classe.)`
|
|
.. |operator| replace:: :abbr:`operator (Questo metodo descrive un operatore valido da usare con questo tipo come operando di sinistra.)`
|
|
.. |bitfield| replace:: :abbr:`BitField (Questo valore è un intero composto da una maschera di bit dei seguenti flag.)`
|
|
.. |void| replace:: :abbr:`void (Nessun valore restituito.)`
|