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

Jogos rodam em um loop. A cada quadro, você precisa atualizar o estado do mundo do seu jogo antes de desenhá-lo na tela. O Godot fornece dois métodos virtuais na classe Node para fazer isso: Node._process() e Node._physics_process(). Se você definir um ou ambos em um script, o motor os chamará automaticamente.

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.

O motor chama este método antes de cada passo da física:

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.