Frequentemente, desejarei usar um valor de velocidade como 2,5 para mover meu personagem em um jogo baseado em pixels. A detecção de colisão geralmente será mais difícil se eu fizer isso. Então, acabo fazendo algo assim:

moveX(2);
if (ticks % 2 == 0) { // or if (moveTime % 2 == 0)
    moveX(1);
}

Eu me encolho por dentro toda vez que tenho que escrever isso, existe uma maneira mais limpa de mover um personagem com valores de velocidade não inteiros ou continuarei preso a fazê-lo para sempre?

Bresenham

Antigamente, quando as pessoas ainda escreviam suas próprias rotinas básicas de vídeo para desenhar linhas e círculos, não era incomum usar o algoritmo de linha de Bresenham para isso.

Bresenham resolve esse problema: você deseja desenhar uma linha na tela que mova os dxpixels na direção horizontal e ao mesmo tempo estenda os dypixels na direção vertical. Existe um caractere "flutuante" inerente às linhas; mesmo se você tiver pixels inteiros, você acaba com inclinações racionais.

O algoritmo precisa ser rápido, o que significa que ele pode usar apenas aritmética inteira; e também foge sem multiplicação ou divisão, apenas adição e subtração.

Você pode adaptar isso para o seu caso:

• Sua "direção x" (em termos do algoritmo de Bresenham) é o seu relógio.
• Sua "direção y" é o valor que você deseja incrementar (ou seja, a posição do seu personagem - cuidado, este não é realmente o "y" do seu sprite ou o que quer que seja na tela, mais um valor abstrato)

"x / y" aqui não é o local na tela, mas o valor de uma de suas dimensões no tempo. Obviamente, se o seu sprite estiver sendo executado em uma direção arbitrária na tela, você terá vários Bresenhams executando separadamente, 2 para 2D, 3 para 3D.

Exemplo

Digamos que você queira mover seu personagem em um movimento simples de 0 a 25 ao longo de um dos seus eixos. Como está se movendo com a velocidade 2.5, ele chegará lá no quadro 10.

É o mesmo que "desenhar uma linha" de (0,0) a (10,25). Pegue o algoritmo de linha de Bresenham e deixe correr. Se você fizer o que é certo (e quando estudá-lo, rapidamente ficará claro como o faz), gerará 11 "pontos" para você (0,0), (1,2), (2, 5), (3,7), (4,10) ... (10,25).

Dicas sobre adaptação

Se você pesquisar esse algoritmo no Google e encontrar algum código (a Wikipedia possui um tratado bastante grande), há algumas coisas que você precisa observar:

• Obviamente, funciona para todos os tipos de dxe dy. Você está interessado em um caso específico (por exemplo, você nunca terá dx=0).
• A implementação de costume terá vários casos diferentes para os quadrantes da tela, dependendo se dxe dysão positivos, negativos, e também se abs(dx)>abs(dy)ou não. É claro que você também escolhe o que precisa aqui. Você deve ter certeza de que a direção que é aumentada a 1cada escala é sempre a direção do "relógio".

Se você aplicar essas simplificações, o resultado será muito simples e se livrará completamente de quaisquer reais.

Existe uma ótima maneira de fazer exatamente o que você deseja.

Além de uma floatvelocidade, você precisará ter uma segunda floatvariável que conterá e acumulará uma diferença entre a velocidade real e a velocidade arredondada . Essa diferença é então combinada com a própria velocidade.

#include <iostream>
#include <cmath>

int main()
{
    int pos = 10; 
    float vel = 0.3, vel_lag = 0;

    for (int i = 0; i < 20; i++)   
    {
        float real_vel = vel + vel_lag;
        int int_vel = std::lround(real_vel);
        vel_lag = real_vel - int_vel;

        std::cout << pos << ' ';
        pos += int_vel;
    }
}

Saída:

10 10 11 11 11 12 12 12 12 13 13 13 14 14 14 15 15 15 15 16

Use valores flutuantes para movimento e valores inteiros para colisão e renderização.

Aqui está um exemplo:

class Character {
    float position;
public:
    void move(float delta) {
        this->position += delta;
    }
    int getPosition() const {
        return lround(this->position);
    }
};

Quando você se move, você usa o move()que acumula as posições fracionárias. Mas a colisão e a renderização podem lidar com posições integrais usando a getPosition()função