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

MainLoop

Eredita: Object

Ereditato da: SceneTree

Classe di base astratta per il ciclo principale del gioco.

Descrizione

MainLoop è la classe base astratta per il ciclo di gioco di un progetto Godot. È ereditata da SceneTree, che è l'implementazione predefinita del ciclo di gioco utilizzata nei progetti Godot, sebbene sia anche possibile scrivere e utilizzare la propria sottoclasse MainLoop al posto dell'albero di scene.

All'avvio dell'applicazione, un'implementazione MainLoop deve essere fornita al sistema operativo; altrimenti, l'applicazione verrà chiusa. Ciò avviene automaticamente (e viene creato uno SceneTree) a meno che non sia fornito uno Script MainLoop dalla riga di comando (ad esempio con godot -s my_loop.gd) o che l'impostazione del progetto ProjectSettings.application/run/main_loop_type non sia sovrascritta.

Ecco uno script di esempio che implementa un semplice MainLoop:

class_name CustomMainLoop
extends MainLoop

var time_elapsed = 0

func _initialize():
    print("Inizializzato:")
    print("  Tempo all'inizio: %s" % str(time_elapsed))

func _process(delta):
    time_elapsed += delta
    # Restituisci true per terminare il ciclo principale.
    return Input.get_mouse_button_mask() != 0 || Input.is_key_pressed(KEY_ESCAPE)

func _finalize():
    print("Finalizzato:")
    print("  Tempo alla fine: %s" % str(time_elapsed))

using Godot;

[GlobalClass]
public partial class CustomMainLoop : MainLoop
{
    private double _timeElapsed = 0;

    public override void _Initialize()
    {
        GD.Print("Inizializzato:");
        GD.Print($"  Tempo all'inizio: {_timeElapsed}");
    }

    public override bool _Process(double delta)
    {
        _timeElapsed += delta;
        // Restituisci true per terminare il ciclo principale.
        return Input.GetMouseButtonMask() != 0 || Input.IsKeyPressed(Key.Escape);
    }

    private void _Finalize()
    {
        GD.Print("Finalizzato:");
        GD.Print($"  Tempo alla fine: {_timeElapsed}");
    }
}

Metodi

void	_finalize() virtual
void	_initialize() virtual
bool	_physics_process(delta: float) virtual
bool	_process(delta: float) virtual

Segnali

on_request_permissions_result(permission: String, granted: bool) 🔗

Emesso quando un utente risponde a una richiesta di autorizzazione.

Costanti

NOTIFICATION_OS_MEMORY_WARNING = 2009 🔗

Notifica ricevuta dal sistema operativo quando l'applicazione supera la sua memoria allocata.

Specifico per la piattaforma iOS.

NOTIFICATION_TRANSLATION_CHANGED = 2010 🔗

Notifica ricevuta quando le traduzioni potrebbero essere cambiate. Può essere attivata dall'utente che cambia le impostazioni locali. Può essere utilizzata per rispondere alle modifiche della lingua, ad esempio per modificare le stringhe dell'interfaccia utente al volo. Utile quando si lavora con il supporto integrato di traduzione, come Object.tr().

NOTIFICATION_WM_ABOUT = 2011 🔗

Notifica ricevuta dal sistema operativo quando viene inviata una richiesta di informazioni "Informazioni".

Specifico per la piattaforma macOS.

NOTIFICATION_CRASH = 2012 🔗

Notifica ricevuta dal gestore degli arresti anomali di Godot quando il motore sta per bloccarsi.

Implementato su piattaforme desktop se il gestore degli arresti anomali è abilitato.

NOTIFICATION_OS_IME_UPDATE = 2013 🔗

Notification received from the OS when an update of the Input Method Engine occurs (e.g. change of IME cursor position or composition string).

Implemented on desktop and web platforms.

NOTIFICATION_APPLICATION_RESUMED = 2014 🔗

Notifica ricevuta dal sistema operativo quando l'applicazione viene ripresa.

Specifico per le piattaforme Android e iOS.

NOTIFICATION_APPLICATION_PAUSED = 2015 🔗

Notifica ricevuta dal sistema operativo quando l'applicazione è in pausa.

Specifico per le piattaforme Android e iOS.

Nota: Su iOS, hai solo circa 5 secondi per terminare un'attività avviata da questo segnale. Se superi questa soglia, iOS chiuderà l'app invece di metterla in pausa.

NOTIFICATION_APPLICATION_FOCUS_IN = 2016 🔗

Notifica ricevuta dal sistema operativo quando l'applicazione è focalizzata, ovvero quando si cambia il focus dal desktop del sistema operativo o da un'applicazione di terze parti a una finestra aperta dell'istanza di Godot.

Implementato su piattaforme desktop e mobili.

NOTIFICATION_APPLICATION_FOCUS_OUT = 2017 🔗

Notifica ricevuta dal sistema operativo quando l'applicazione è perde il focus, ovvero quando si cambia il focus dal desktop del sistema operativo o da un'applicazione di terze parti a una finestra aperta dell'istanza di Godot.

Implementato su piattaforme desktop e mobili.

NOTIFICATION_TEXT_SERVER_CHANGED = 2018 🔗

Notifica ricevuta quando il server di testo viene modificato.

NOTIFICATION_APPLICATION_PIP_MODE_ENTERED = 2019 🔗

Notification received when the application enters picture-in-picture mode.

NOTIFICATION_APPLICATION_PIP_MODE_EXITED = 2020 🔗

Notification received when the application exits picture-in-picture mode.

Descrizioni dei metodi

void _finalize() virtual 🔗

Chiamato prima della chiusura del programma.

void _initialize() virtual 🔗

Chiamato una volta durante l'inizializzazione.

bool _physics_process(delta: float) virtual 🔗

Chiamato ogni tick di fisica. delta è il tempo logico tra i tick di fisica in secondi ed è uguale a Engine.time_scale / Engine.physics_ticks_per_second. Equivalente a Node._physics_process().

Se implementato, il metodo deve restituire un valore booleano. true termina il ciclo principale, mentre false gli consente di procedere al passaggio successivo.

Nota: _physics_process() può essere chiamato fino a Engine.max_physics_steps_per_frame volte per frame (inattivo). È possibile raggiungere tale limite quando il motore soffre di problemi di prestazioni.

Nota: Il delta accumulato potrebbe deviare dai secondi reali.

bool _process(delta: float) virtual 🔗

Chiamato su ogni frame inattivo, prima del rendering e dopo l'elaborazione dei tick di fisica. delta è il tempo tra i frame in secondi. Equivalente a Node._process().

Se implementato, il metodo deve restituire un valore booleano. true termina il ciclo principale, mentre false gli consente di procedere al frame successivo.

Nota: Quando il motore è in difficoltà e il frame rate è ridotto, delta aumenta. Quando delta è aumentato, è limitato a un massimo di Engine.time_scale * Engine.max_physics_steps_per_frame / Engine.physics_ticks_per_second. Pertanto, il delta accumulato potrebbe non rappresentare il tempo reale.

Nota: Quando --fixed-fps è abilitato o il motore è in esecuzione in modalità Movie Maker (vedi MovieWriter), il delta del processo sarà sempre lo stesso per ogni frame, a prescindere dal tempo impiegato per renderizzare il frame.

Nota: È possibile che il delta dei frame sia post-elaborato da OS.delta_smoothing se questa opzione è abilitata per il progetto.