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

Processamento Ocioso e Físico

Games run in a loop. Each frame, you need to update the state of your game world before drawing it on screen. Godot provides two virtual methods in the Node class to do so: Node._process() and Node._physics_process(). If you define either or both in a script, the engine will call them automatically.

Há dois tipos de processamento disponíveis para você:

O processamento ocioso permite que você execute o código que atualiza um nó a cada quadro, com a maior frequência possível.
O processamento físico ocorre a uma taxa fixa, 60 vezes por segundo por padrão. Isso é independente da taxa de quadros real do seu jogo e mantém a física funcionando sem problemas. Você deve usá-lo para qualquer coisa que envolva o motor de física, como mover um corpo que colide com o ambiente.

Você pode ativar o processamento ocioso definindo o método _process() em um script. Você pode desativá-lo e ativá-lo novamente chamando Node.set_process().

O motor chama este método toda vez que ele desenha um quadro:

func _process(delta):
    # Do something...
    pass

public override void _Process(double delta)
{
    // Do something...
}

Tenha em mente que a frequência com que o motor chama _process() depende da taxa de quadros do seu aplicativo, que varia com o tempo e entre os dispositivos.

O parâmetro delta da função é o tempo decorrido em segundos desde a chamada anterior para _process(). Use este parâmetro para fazer cálculos independentes da taxa de quadros. Por exemplo, você deve sempre multiplicar um valor de velocidade por delta para animar um objeto em movimento.

O processamento de física funciona com uma função virtual semelhante: _physics_process(). Use-o para cálculos que devem acontecer antes de cada etapa da física, como mover um personagem que colide com o mundo do jogo. Como mencionado acima, _physics_process() executa em intervalos de tempo fixos tanto quanto possível para manter as interações físicas estáveis. Você pode alterar o intervalo entre as etapas de física nas configurações do projeto, em Physics -> Common -> Physics Fps. Por padrão, ele está configurado para ser executado 60 vezes por segundo.

The engine calls this method before every physics step:

func _physics_process(delta):
    # Do something...
    pass

public override void _PhysicsProcess(double delta)
{
    // Do something...
}

A função _process() não é sincronizada com a física. Sua taxa de quadros não é constante e depende do hardware e da otimização do jogo. Sua execução é feita depois do passo da física em jogos de single-thread.

Você pode ver a função _process() em ação criando uma cena com um único nó Label, com o seguinte script anexado a ele:

extends Label

var time = 0

func _process(delta):
    time += delta
    text = str(time) # 'text' is a built-in Label property.

using Godot;

public partial class CustomLabel : Label
{
    private double _time;

    public override void _Process(double delta)
    {
        _time += delta;
        Text = _time.ToString(); // 'Text' is a built-in Label property.
    }
}

Ao executar a cena, você deverá ver um contador aumentando cada quadro.