Seringkali saya ingin menggunakan nilai kecepatan seperti 2,5 untuk memindahkan karakter saya dalam game berbasis pixel. Deteksi tabrakan umumnya akan lebih sulit jika saya melakukannya. Jadi saya akhirnya melakukan sesuatu seperti ini:

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

Saya merasa ngeri di dalam setiap kali saya harus menulis itu, apakah ada cara yang lebih bersih untuk memindahkan karakter dengan nilai kecepatan non-integer atau akankah saya tetap terjebak melakukan ini selamanya?

Bresenham

Di masa lalu, ketika orang masih menulis rutin video dasar mereka sendiri untuk menggambar garis dan lingkaran, itu tidak pernah terdengar menggunakan algoritma garis Bresenham untuk itu.

Bresenham memecahkan masalah ini: Anda ingin menggambar garis pada layar yang menggerakkan dxpiksel dalam arah horizontal sementara pada saat yang sama menjangkau dypiksel dalam arah vertikal. Ada karakter "ringan" yang melekat pada garis; bahkan jika Anda memiliki piksel bilangan bulat, Anda berakhir dengan kecenderungan rasional.

Algoritme harus cepat, yang artinya dapat menggunakan integer aritmatika saja; dan itu juga hilang tanpa penggandaan atau pembagian, hanya penambahan dan pengurangan.

Anda dapat menyesuaikan itu untuk kasus Anda:

• "Arah x" Anda (dalam hal algoritma Bresenham) adalah jam Anda.
• "Arah y" Anda adalah nilai yang ingin Anda tambahkan (yaitu, posisi karakter Anda - hati-hati, ini sebenarnya bukan "y" dari sprite Anda atau apa pun di layar, lebih merupakan nilai abstrak)

"x / y" di sini bukan lokasi di layar, tetapi nilai salah satu dimensi Anda dalam waktu. Jelas, jika sprite Anda berjalan dengan arah yang sewenang-wenang melintasi layar, Anda akan memiliki beberapa Bresenhams yang berjalan secara terpisah, 2 untuk 2D, 3 untuk 3D.

Contoh

Katakanlah Anda ingin memindahkan karakter Anda dalam gerakan sederhana dari 0 hingga 25 di sepanjang salah satu sumbu Anda. Saat bergerak dengan kecepatan 2.5, ia akan muncul di frame 10.

Ini sama dengan "menggambar garis" dari (0,0) hingga (10,25). Ambil algoritme garis Bresenham dan biarkan berjalan. Jika Anda melakukannya dengan benar (dan ketika Anda mempelajarinya, itu akan dengan cepat menjadi jelas bagaimana Anda melakukannya dengan benar), maka itu akan menghasilkan 11 "poin" untuk Anda (0,0), (1,2), (2, 5), (3,7), (4,10) ... (10,25).

Petunjuk adaptasi

Jika Anda google algoritma itu dan menemukan beberapa kode (Wikipedia memiliki perjanjian yang cukup besar di dalamnya), ada beberapa hal yang perlu Anda perhatikan:

• Ini jelas bekerja untuk semua jenis dxdan dy. Anda tertarik pada satu kasus khusus (yaitu, Anda tidak akan pernah memilikinya dx=0).
• Implementasi yang biasa akan memiliki beberapa kasus yang berbeda untuk kuadran di layar, tergantung pada apakah dxdan dypositif, negatif, dan juga apakah abs(dx)>abs(dy)atau tidak. Anda tentu juga memilih apa yang Anda butuhkan di sini. Anda harus memastikan secara khusus bahwa arah yang ditingkatkan oleh 1setiap tick selalu merupakan arah "jam" Anda.

Jika Anda menerapkan penyederhanaan ini, hasilnya akan sangat sederhana, dan singkirkan semua realita.

Ada cara hebat untuk melakukan apa yang Anda inginkan.

Selain floatkecepatan, Anda harus memiliki floatvariabel kedua yang akan berisi dan mengakumulasikan perbedaan antara kecepatan nyata dan kecepatan bulat . Perbedaan ini kemudian dikombinasikan dengan kecepatan itu sendiri.

#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;
    }
}

Keluaran:

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

Gunakan nilai mengambang untuk gerakan dan nilai integer untuk tabrakan dan rendering.

Ini sebuah contoh:

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

Ketika Anda bergerak, Anda menggunakan move()yang mengakumulasi posisi fraksional. Tetapi tabrakan dan rendering dapat menangani posisi integral dengan menggunakan getPosition()fungsi tersebut.