Dasar Physics Platformer 2D, Bagian 7: Bidang Miring

() translation by (you can also view the original English article)

Final product image — What You'll Be Creating

Demo

Demo tersebut menunjukkan hasil akhir implementasi bidang miring. Gunakan WASD untuk menggerakkan karakter. Tombol mouse kanan membuat sebuah petak. Kamu bisa menggunakan roda gulir atau tombol panah untuk memilih petak yang ingin kamu tempatkan. Slider mengubah ukuran karakter pemain.

Demo tersebut dibuat menggunakan Unity 5.5.2f1, dan source code juga kompetibel dengan Unity versi tersebut.

Bidang Miring

Bidang miring menambahkan banyak fleksibilitas pada game, dalam hal interaksi yang bisa terjadi dengan medan dalam permainan dan variasi visual, tapi implementasinya bisa sangat rumit, terutama jika kita ingin mendukung banyak jenis bidang miring.

Seperti pada bagian sebelumnya, kita akan melanjutkan pekerjaan yang kita buat, walaupun kita akan mengerjakan ulang sebagian besar kode yang sudah kita tulis. Yang kita perlukan dari bagian awal adalah pergerakan karakter dan tilemap.

Kamu bisa mengunduh file proyek dari bagian sebelumnya lalu menulis kode bersama tutorial ini.

Perubahan pada Integrasi Pergerakan

Karena membuat bidang miring bekerja cukup sulit, akan lebih baik jika kita bisa membuat beberapa hal lebih mudah. Beberapa waktu yang lalu saya menemukan blog post tentang bagaimana Matt Thorson menangani physics dalam gamenya. Pada dasarnya, tekniknya adalah membuat pergerakkan selalu terjadi dalam interval 1 piksel. Jika sebuah pergerakan pada sebuah frame lebih besar dari satu piksel, vektor pergerakan dibagi jadi banyak gerakan 1 piksel, dan setelah setiap gerakan kita periksa tabrakan dengan tanah.

Ini akan memudahkan kita untuk menemukan rintangan sepanjang garis pergerakan di satu waktu bersamaan, melainkan kita lakukan secara iteratif. Teknik ini membuat implementasi lebih sederhana, tapi meningkatkan jumlah pemeriksaan tabrakan yang dilakukan, jadi mungkin teknik ini tidak cocok untuk game di mana banyak objek yang bergerak, terutama permainan resolusi tinggi di mana pergerakan gerak objek lebih tinggi. Keuntungan lainnya adalah walaupun ada lebih banyak pemeriksaan tabrakan, setiap pemeriksaan akan lebih sederhana karena kita tahu karakter hanya bergerak sejauh satu piksel.

Data Bidang Miring

Kita mulai mendefinisikan data yang kita butuhkan untuk merepresentasikan bidang miring. Pertama, kita perlu peta ketinggian dari bidang miring, yang akan menentukan bentuk bidang miring tersebut. Kita mulai dengan bidang miring 45 derajat.

Kita definisikan juga bentuk lain; bentuk ini akan melambangkan tonjolan pada permukaan tanah.

Tentu saja kita ingin menggunakan variasi dari bidang miring ini, tergantung dari di mana kita menempatkannya. Contohnya, untuk bidang miring 45 derajat yang kita buat, cocok jika ada blok solid di sisi kanannya, jika blok solid ada di sebelah kiri, kita perlu gunakan versi pencerminan dari petak bidang miring tersebut. Kita perlu mencerminkan bidang miring di sumbu X dan Y dan memutarnya 90 derajat untuk bisa mengakses semua variasi dari sebuah bidang miring.

Kita lihat bagaimana perubahan untuk bidang miring 45 derajat.

Seperti yang bisa dilihat, dalam kasus ini kita bisa mendapatkan semua variasi dengan pencerminan. Kita tidak perlu memutar bidang miring 90 derajat, tapi kitalihat bagaimana dengan bidang miring kedua.

Dalam kasus ini, rotasi 90 derajat membuat kita bisa menempatkan bidang miring ini di tembok.

Memperhitungkan Offset

Kita gunakan data yang kita definisikan untuk menghitung offset yang perlu diterapkan pada objek yang tumpang tindih dengan sebuah petak. Offset tersebut akan memiliki informasi tentang:

berapa banyak objek perlu bergerak atas/bawah/kiri/kanan agar tidak bertabrakan dengan petak
seberapa banyak objek perlu bergerak agar berada tepat di sebelah atas/bawah/kiri/kanan dari permukaan bidang miring

Bagian hijau pada gambar di atas adalah bagian di mana objek tumpang tindih dengan bagian kosong pada petak, dan kotak kuning menunjukkan area di mana objek tumpang tindih dengan bidang miring.

Sekarang, kita mulai melihat bagaimana menghitung offset untuk kasus nomor 1.

Objek tidak bertabrakan dengan bagian manapun dari bidang miring. Artinya kita tidak perlu menggerakkannya keluar dari tabrakan, jadi bagian pertama dari offset kita diatur menjadi 0.

Untuk bagian kedua dari offset, jika kita ingin bagian bawah objek menyentuh bidan gmiring, kita perlu menggerakkannya 3 piksel ke bawah. Jika kita ingin sisi kanan objek menyentuh bidang miring, kita perlu menggerakkannya 3 piksel ke kanan. Untuk sisi kiri objek menyentuh sisi kanan dari bidang miring, kita perlu menggerakkannya 16 piksel ke kanan. Begitu pula, jika kita ingin bagian atas objek menyentuh bidang miring, kita perlu menggerakkannya 16 piksel ke bawah.

Sekarang, kenapa kita perlu informasi berapa jarak antara sisi objek dan bidang miring? Data ini sangat berguna saat kita ingin sebuah objek menempel pada bidang miring.

Sebagai contoh, misalkan objek bergerak ke kiri pada bidang miring 45 derajat kita. Jika objek tersebut bergerak cukup cepat, objek tersebut akan berada di udara, dan akhirnya akan turun ke bidang miring lain, dan seterusnya. Jika kita ingin tetap berada pada bidan gmiring, setiap bergerak ke kiri, kita perlu mendorongkan ke bawah agar tetap menyentuh bidang miring. Animasi di bawah menunjukkan perbedaan antara fitur menempel pada bidang miring aktif atau tidak.

Kita akan menyimpan banyak sekali data di sini, pada dasarnya, kita ingin menghitung offset untuk setiap tumpang tindih yang bisa terjadi dengan sebuah petak. Ini artinya untuk setiap posisi dan untuk setiap ukuran tumpang tindih, kita punya referensi cepat untuk seberapa banyak kita perlu menggerakkan objek. Perlu diperhatikan kita tidak bisa menyimpan offset akhir karena kita tidak bisa menyimpan offset untuk setiap AABB yang mungkin, tapi mudah untuk mengatur offset jika diketahui tumpang tindih AABB dengan petak bidang miring.

Mendefinisikan Petak

Kita akan mendefinisikan semua data bidang miring pada kelas statik Slopes.

1	public static class Slopes
2	{
3	}

Pertama, kita tangani peta ketinggian. Kita definisikan beberapa contoh untuk diproses lain kesempatan.

1	public static readonly sbyte[] empty = new sbyte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
2	public static readonly sbyte[] full = new sbyte[16] { 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 };
3	public static readonly sbyte[] slope45 = new sbyte[16] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
4	public static readonly sbyte[] slopeMid1 = new sbyte[16] { 1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1 };

Kita tambahkan tipe pengujian petak untuk maising-masing bidang miring yang dibuat.

public enum TileType
{
    Empty,
    Block,
    OneWay,

    TestSlopeMid1,
    TestSlopeMid1FX,
    TestSlopeMid1FY,
    TestSlopeMid1FXY,
    TestSlopeMid1F90,
    TestSlopeMid1F90X,
    TestSlopeMid1F90Y,
    TestSlopeMid1F90XY,

    TestSlope45,
    TestSlope45FX,
    TestSlope45FY,
    TestSlope45FXY,
    TestSlope45F90,
    TestSlope45F90X,
    TestSlope45F90Y,
    TestSlope45F90XY,
    
    Count
}

Kita buat enumerasi lain untuk tipe tabrakan petak. Ini akan berguna untuk menentukan tipe tabrakan yang sama untuk berbagai petak, contohnya bidang miring 45 derajat dengan rumput atau bidang miring 45 derajat dengan batu.

public enum TileCollisionType
{
    Empty,
    Block,
    OneWay,

    SlopeMid1,
    SlopeMid1FX,
    SlopeMid1FY,
    SlopeMid1FXY,
    SlopeMid1F90,
    SlopeMid1F90X,
    SlopeMid1F90Y,
    SlopeMid1F90XY,

    Slope45,
    Slope45FX,
    Slope45FY,
    Slope45FXY,
    Slope45F90,
    Slope45F90X,
    Slope45F90Y,
    Slope45F90XY,
    
    Count
}

Sekarang kita buat array yang akan menyimpan semua peta ketinggian petak. Array ini akan diindeks berdasarkan enumerasi TileCollisionType.

1	public static readonly sbyte[] empty = new sbyte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
2	public static readonly sbyte[] full = new sbyte[16] { 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 };
3	public static readonly sbyte[] slope45 = new sbyte[16] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
4	public static readonly sbyte[] slopeMid1 = new sbyte[16] { 1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1 };
5
6	public static sbyte[][] slopesHeights;

Memproses Bidang Miring

Sebelum kita mulai menghitung offset, kita ingin membuat peta ketinggian kita sepenuhnya menjadi bitmap tabrakan. Ini akan membuat mudah untuk menentukan apakah sebuah AABB bertabrakan dengan sebuah petak dan memungkinkan bentuk petak yang rumit jika itu yang kita butuhkan. Kita buat array untuk bitmap-bitmap tersebut.

public static readonly sbyte[] empty = new sbyte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
public static readonly sbyte[] full = new sbyte[16] { 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 };
public static readonly sbyte[] slope45 = new sbyte[16] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
public static readonly sbyte[] slopeMid1 = new sbyte[16] { 1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1 };

public static sbyte[][] slopesHeights;
public static sbyte[][][] slopesExtended;

Sekarang kita buat fungsi yang akan mengubah peta ketinggian menjadi bitmap.

public static sbyte[][] Extend(sbyte[] slope)
{
    sbyte[][] extended = new sbyte[Map.cTileSize][];

    for (int x = 0; x < Map.cTileSize; ++x)
    {
        extended[x] = new sbyte[Map.cTileSize];

        for (int y = 0; y < Map.cTileSize; ++y)
            extended[x][y] = System.Convert.ToSByte(y < slope[x]);
    }

    return extended;
}

Tidak ada yang rumit di sini, jika sebuah posisi pada petak adalah solid, kita atur menjadi 1, jika tidak, kita atur menjadi 0.

Sekarang kita buat fungsi Init, yang akan melakukan semua penyimpanan data yang kita butuhkan terhadap bidang miring.

1	public static void Init()
2	{
3	}

Kita buat array penyimpanannya di sini.

public static void Init()
{
    slopesHeights = new sbyte[(int)TileCollisionType.Count][];
    slopesExtended = new sbyte[(int)TileCollisionType.Count][][];
}

Sekarang kita buat setiap tipe tabrakan petak merujuk pada data simpanan yang sesuai.

for (int i = 0; i < (int)TileCollisionType.Count; ++i)
{
    switch ((TileCollisionType)i)
    {
        case TileCollisionType.Empty:
            slopesHeights[i] = empty;
            slopesExtended[i] = Extend(slopesHeights[i]);
            break;

        case TileCollisionType.Full:
            slopesHeights[i] = full;
            slopesExtended[i] = Extend(slopesHeights[i]);
            break;

        case TileCollisionType.Slope45:
            slopesHeights[i] = slope45;
            slopesExtended[i] = Extend(slopesHeights[i]);
            break;
        case TileCollisionType.Slope45FX:
        case TileCollisionType.Slope45FY:
        case TileCollisionType.Slope45FXY:
        case TileCollisionType.Slope45F90:
        case TileCollisionType.Slope45F90X:
        case TileCollisionType.Slope45F90XY:
        case TileCollisionType.Slope45F90Y:
            slopesHeights[i] = slopesHeights[(int)TileCollisionType.Slope45];
            slopesExtended[i] = slopesExtended[(int)TileCollisionType.Slope45];
            break;

        case TileCollisionType.SlopeMid1:
            slopesHeights[i] = slopeMid1;
            slopesExtended[i] = Extend(slopesHeights[i]);
            break;
        case TileCollisionType.SlopeMid1FX:
        case TileCollisionType.SlopeMid1FY:
        case TileCollisionType.SlopeMid1FXY:
        case TileCollisionType.SlopeMid1F90:
        case TileCollisionType.SlopeMid1F90X:
        case TileCollisionType.SlopeMid1F90XY:
        case TileCollisionType.SlopeMid1F90Y:
            slopesHeights[i] = slopesHeights[(int)TileCollisionType.SlopeMid1];
            slopesExtended[i] = slopesExtended[(int)TileCollisionType.SlopeMid1];
            break;
    }
}

Struktur Offset

Sekarang kita bisa mendefinisikan struktur offset kita.

public struct SlopeOffsetSB
{
    public sbyte freeLeft, freeRight, freeDown, freeUp, collidingLeft, collidingRight, collidingBottom, collidingTop;

    public SlopeOffsetSB(sbyte _freeLeft, sbyte _freeRight, sbyte _freeDown, sbyte _freeUp, sbyte _collidingLeft, sbyte _collidingRight, sbyte _collidingBottom, sbyte _collidingTop)
    {
        freeLeft = _freeLeft;
        freeRight = _freeRight;
        freeDown = _freeDown;
        freeUp = _freeUp;

        collidingLeft = _collidingLeft;
        collidingRight = _collidingRight;
        collidingBottom = _collidingBottom;
        collidingTop = _collidingTop;
    }
}

Seperti dijelaskan sebelumnya, variabel freeLeft, freeRight, freeDown, dan freeUp merujuk pada offset yang perlu diterapkan agar objek tidak bertabrakan dengan bidang miring, sedangkan collidingLeft, collidingRight, collidingTop, dan collidingBottom adalah jarak objek perlu digeser untuk menyentuh bidang miring tanpa tumpang tindih.

Saatnya untuk membuat fungsi penyimpanan yang rumit, tapi sebelumnya, kita buat tempat penyimpanan yang akan menyimpan semua data.

1	public static sbyte[][] slopesHeights;
2	public static sbyte[][][] slopesExtended;
3	public static SlopeOffsetSB[][][][][] slopeOffsets;

Dan buat array pada fungsi Init.

1	slopesHeights = new sbyte[(int)TileCollisionType.Count][];
2	slopesExtended = new sbyte[(int)TileCollisionType.Count][][];
3	slopeOffsets = new SlopeOffsetSB[(int)TileCollisionType.Count][][][][];

Masalah Memory

Seperti bisa kamu lihat, array ini memiliki banyak dimensi, dan masing-masing itpe petak baru akan membutuhkan banyak memory. Untuk setiap posisi X pada petak, untuk setiap posisi Y pada petak, untuk setiap lebar yang mungkin pada petak, dan untuk setiap tinggi yang mungkin, akan ada perhitungan nilai offset yang berbeda.

Karena petak yang kita gunakan adalah 16x16, artinya data yang diperlukan untuk setiap tipe petak adalah 16*16*16*16*8 byte, yang sama dengan 512 kB. Ini adalah data yang sangat banyak, tapi masih bisa dikelola, dan jika menyimpan banyak informasi tidak memungkinkan, kita perlu beralih ke menghitung offset secara real time, misalnya menggunakan metode yang lebih efisien dibanding yang kita gunakan untuk penyimpanan data, atau mengoptimasi data kita.

Sekarang, jika ukuran petak dalam game kita lebih besar, misalnya 32x32, setiap petak akan membutuhkan 8 MB, dan jika kita gunakan 64x64, ukurannya menjadi 128MB. Ukuran ini terlihat terlalu besar, terutama jika kita ingin menggunakan beberapa jenis bidang miring dalam game. Solusi yang masuk akal adalah membagi petak yang besar menjadi lebih kecil. Ingatlah bahwa hanya bidang miring baru didefinisikan yang membutuhkan ruang penyimpanan, transformasi akan menggunakan data yang sudah ada.

Memeriksa tabrakan di dalam petak

Sebelum kita mulai menghitung offset, kita perlu tahu jika objek di suatu posisi akan bertabrakan dengan bagian solid dari petak. Kita buat fungsi ini terlebih dahulu.

public static bool Collides(sbyte[][] slopeExtended, sbyte posX, sbyte posY, sbyte w, sbyte h)
{
    for (int x = posX; x <= posX + w && x < Map.cTileSize; ++x)
    {
        for (int y = posY; y <= posY + h && y < Map.cTileSize; ++y)
        {
            if (slopeExtended[x][y] == 1)
                return true;
        }
    }

    return false;
}

Fungsi ini menerima bitmap collision, posisi tumpang tindih, dan ukuran tumpang tindih. Posisi adalah piksel kiri bawah pada objek, dan ukuran adalah lebar dan tinggi objek berbasis 0. Berbasis 0 maksudnya jika bernilai 0 artinya lebar objek sebenarnya 1 piksel, dan lebar 15 artinya lebar objek 16 piksel. Fungsi ini sangat sederhana, jika ada piksel objek yang tumpang tindih dengan bidang miring, kita kembalikan true, jika tidak kita kembalikan false.

Menghitung Offset

Sekarang kita mulai hitung offset.

1	public static SlopeOffsetSB GetOffset(sbyte[][] slopeExtended, sbyte posX, sbyte posY, sbyte w, sbyte h)
2	{
3	}

Sekali lagi, untuk menghitung offset kita perlu bitmap collision, posisi, dan ukuran tumpang tindih. Kita mulai dengan deklarasi nilai offset.

public static SlopeOffsetSB GetOffset(sbyte[][] slopeExtended, sbyte posX, sbyte posY, sbyte w, sbyte h)
{
    sbyte freeUp = 0, freeDown = 0, collidingTop = 0, collidingBottom = 0;
    sbyte freeLeft = 0, freeRight = 0, collidingLeft = 0, collidingRight = 0;
}

Sekarang kita hitung seberapa banyak kita perlu menggeser objek agar tidak bertabrakan dengan bidang miring. Untuk itu, selama objek bertabrakan dengan bidang miring, kita perlu terus menggesernya ke atas dan memeriksa tabrakan sampai tidak ada tumpang tindih dengan bagian solid dari petak.

Gambar di atas adalah ilustrasi bagaimana kita menghitung offset. Pada kasus pertama, karena objek menyentuh bagian atas dari petak, bukan hanya kita geser ke atas, kita perlu kurangi tingginya. Itu karena jika ada bagian dari AABB bergerak ke luar batas petak, kita tidak tertarik lagi dengannya. Begitu pula, offset dihitung untuk semua arah, jadi pada contoh di tas, offsetnya:

4 untuk offset atas
-4 untuk offset kiri
-16 untuk offset bawah, yang merupakan jarak maksimum karena jika kita gerakkan objek ke bawah, kita perlu menggerakkannya sampai batas untuk menghentikan tabrakan dengan bidang miring
16 untuk offset kanan

Kita mulai dengan deklarasi variabel sementara untuk tinggi objek. Seperti disebutkan di atas, ini akan berubah tergantung seberapa tinggi kita menggerakkan objek.

1	sbyte movH = h;

Sekarang untuk kondisi utama. Selama objek belum keluar dari batas petak dan bertabrakan dengan bagian solid dari petak, kita perlu meningkatkan offsetUp.

sbyte movH = h;
while (movH >= 0 && posY + freeUp < Map.cTileSize && Collides(slopeExtended, posX, (sbyte)(posY + freeUp), w, movH))
{
    ++freeUp;
}

Lalu, atur ukuran area tumpang tindih petak-objek jika objek bergerak keluar batas petak.

sbyte movH = h;
while (movH >= 0 && posY + freeUp < Map.cTileSize && Collides(slopeExtended, posX, (sbyte)(posY + freeUp), w, movH))
{
    if (posY + freeUp == Map.cTileSize)
        --movH;
        
    ++freeUp;
}

Sekarang kita lakukan hal yang sama untuk offset kiri. Ingatlah bahwa saat kita menggerakkan objek ke kiri dan objek sedang bergerak keluar batas petak, kita tidak perlu mengubah posisinya, melainkan kita ubah lebar dari tumpang tindih. Hal ini digambarkan di sisi kanan animasi perhitungan offset.

movW = w;
while (movW >= 0 && posX + freeLeft >= 0 && Collides(slopeExtended, (sbyte)(posX + freeLeft), posY,  movW, h))
{
    if (posX + freeLeft == 0)
        --movW;
    else
        --freeLeft;
}

Di sini, karena saat mengurangi lebar kita tidak menggerakkan offset freeLeft, kita perlu mengubah nilai yang berkurang menjadi offset.

movW = w;
while (movW >= 0 && posX + freeLeft >= 0 && Collides(slopeExtended, (sbyte)(posX + freeLeft), posY,  movW, h))
{
    if (posX + freeLeft == 0)
        --movW;
    else
        --freeLeft;
}
freeLeft -= (sbyte)(w - movW);

Sekarang lakukan hal yang sama untuk offset bawah dan kanan.

movH = h;
while (movH >= 0 && posY + freeDown >= 0 && Collides(slopeExtended, posX, (sbyte)(posY + freeDown), w, movH))
{
    if (posY + freeDown == 0)
        --movH;
    else
        --freeDown;
}

freeDown -= (sbyte)(h - movH);

sbyte movW = w;
while (movW >= 0 && posY + freeRight < Map.cTileSize && Collides(slopeExtended, (sbyte)(posX + freeRight), posY, movW, h))
{
    if (posX + freeRight == Map.cTileSize)
        --movW;

    ++freeRight;
}

Kita sudah menghitung bagian pertama dari offset, yaitu seberapa jauh kita perlu menggeser objek untuk menghentikannya tabrakan dengan bidang miring. Sekarang waktunya menghitung offset untuk menggeser objek tepat ke sebelah bagian solid dari petak.

Perhatikan jika kita perlu menggeser objek keluar dari tabrakan, kita sudah melakukannya, karena kita berhenti tepat ketika tidak terjadi tabrakan.

Pada kasus di kanan, offset atas bernilai 4, tapi itu juga nilai offset yang kita perlukan untuk menggeser objek agar bagian bawahnya berada pada piksel solid. Hal yang sama terjadi pada sisi satunya.

if (freeUp == 0)
{

}
else
    collidingBottom = freeUp;

Kita perlu menghitung offset pada kasus di kiri. Jika kita ingin menemukan offset collidingBottom, kita perlu menggeser objek 3 piksel ke bawah. Perhitungan yang dibutuhkan di sini sama dengan sebelumnya, tapi kali ini kita mencari saat objek tabrakan dengan bidang miring, lalu menggesernya sembari mengurangi offset dengan satu, jadi objek menyentuh piksel solid, bukan menimpanya.

if (freeUp == 0)
{
    while ( posY + collidingBottom >= 0 && !Collides(slopeExtended, posX, (sbyte)(posY + collidingBottom), w, h))
        --collidingBottom;

    collidingBottom += 1;
}
else
{
    collidingBottom = freeUp;
}

Jika freeUp bernilai 0, freeDown pasti bernilai 0 juga, jadi kita bisa memasukkan perhitungan collidingTop pada blok kode yang sama. Perhitungan ini mirip dengan yang sudah kita buat sejauh ini.

if (freeUp == 0)
{
    while (posY + h + collidingTop < Map.cTileSize && !Collides(slopeExtended, posX, (sbyte)(posY + collidingTop), w, h))
        ++collidingTop;

    collidingTop -= 1;

    while ( posY + collidingBottom >= 0 && !Collides(slopeExtended, posX, (sbyte)(posY + collidingBottom), w, h))
        --collidingBottom;

    collidingBottom += 1;
}
else
{
    collidingBottom = freeUp;
    collidingTop = freeDown;
}

Kita lakukan hal yang sama untuk offset kiri dan kanan.

if (freeRight == 0)
{
    while (posX + w + collidingRight < Map.cTileSize && !Collides(slopeExtended, (sbyte)(posX + collidingRight), posY, w, h))
        ++collidingRight;

    collidingRight -= 1;

    while (posX + collidingLeft >= 0 && !Collides(slopeExtended, (sbyte)(posX + collidingLeft), posY , w, h))
        --collidingLeft;

    collidingLeft += 1;
}
else
{
    collidingLeft = freeRight;
    collidingRight = freeLeft;
}

Menyimpan data

Sekarang semua offset sudah diperhitungkan, kita bisa mengembalikan offset untuk set data ini.

1	return new SlopeOffsetSB(freeLeft, freeRight, freeDown, freeUp, collidingLeft, collidingRight, collidingBottom, collidingTop);

Kita buat tempat penyimpanan untuk data kita.

1	public static sbyte[][] slopesHeights;
2	public static sbyte[][][] slopesExtended;
3	public static SlopeOffsetSB[][][][][] slopeOffsets;

Menginisialisasi array

1	slopesHeights = new sbyte[(int)TileCollisionType.Count][];
2	slopesExtended = new sbyte[(int)TileCollisionType.Count][][];
3	slopeOffsets = new SlopeOffsetSB[(int)TileCollisionType.Count][][][][];

Dan akhirnya, buat fungsi penyimpanan data.

public static SlopeOffsetSB[][][][] CacheSlopeOffsets(sbyte[][] slopeExtended)
{
    var offsetCache = new SlopeOffsetSB[Map.cTileSize][][][];

    for (int x = 0; x < Map.cTileSize; ++x)
    {
        offsetCache[x] = new SlopeOffsetSB[Map.cTileSize][][];
        
        for (int y = 0; y < Map.cTileSize; ++y)
        {
            offsetCache[x][y] = new SlopeOffsetSB[Map.cTileSize][];

            for (int w = 0; w < Map.cTileSize; ++w)
            {
                offsetCache[x][y][w] = new SlopeOffsetSB[Map.cTileSize];

                for (int h = 0; h < Map.cTileSize; ++h)
                {
                    offsetCache[x][y][w][h] = GetOffset(slopeExtended, (sbyte)x, (sbyte)y, (sbyte)w, (sbyte)h);
                }
            }
        }
    }

    return offsetCache;
}

Fungsi tersebut sangat sederhana, jadi cukup mudah untuk melihat bagaimana data sebanyak itu disimpan sesuai dengan untuk kebutuhan kita.

Sekarang pastikan untuk menyimpan semua offset untuk setiap jenis petak collision.

case TileCollisionType.Slope45:
    slopesHeights[i] = slope45;
    slopesExtended[i] = Extend(slopesHeights[i]);
    slopeOffsets[i] = CacheSlopeOffsets(slopesExtended[i]);
    break;
case TileCollisionType.Slope45FX:
case TileCollisionType.Slope45FY:
case TileCollisionType.Slope45FXY:
case TileCollisionType.Slope45F90:
case TileCollisionType.Slope45F90X:
case TileCollisionType.Slope45F90XY:
case TileCollisionType.Slope45F90Y:
    slopesHeights[i] = slopesHeights[(int)TileCollisionType.Slope45];
    slopesExtended[i] = slopesExtended[(int)TileCollisionType.Slope45];
    slopeOffsets[i] = slopeOffsets[(int)TileCollisionType.Slope45];
    break;

Dan dengan begitu fungsi penyimpanan data kita selesai.

Menghitung offset ruang dunia (World Space)

Sekarang kita gunakan data yang sudah kita simpan untuk membuat fungsi yang akan mengembalikan offset untuk karakter yang berada pada ruang dunia pemainan.

1	public static SlopeOffsetI GetOffset(Vector2 tileCenter, float leftX, float rightX, float bottomY, float topY, TileCollisionType tileCollisionType)
2	{
3	}

Offset yang akan kita kembalikan tidak sama dengan struktur yang kita gunakan pada data yang disimpan, karena offset ruang dunia bisa lebih besar dari batasan satu byte. Struktur ini kurang lebih sama, tapi menggunakan integer.

Parameternya adalah sebagai berikut:

posisi titik tengah petak dalam ruang dunia
sisi kiri, kanan, bawah, dan atas dari AABB yang kita cari nilai offsetnya
jenis perak yang ingin kita cari offsetnya

Pertama, kita perlu mencari tahu bagaimana AABB tumpang tindih dengan petak bidang miring. Kita perlu tahu di mana tumpang tindih dimulai (pojok kiri bawah), dan sebesar apa tumpang tindih pada petak tersebut.

Untuk menghitung ini, pertama kita deklarasi variabel yang dibutuhkan.

public static SlopeOffsetI GetOffset(Vector2 tileCenter, float leftX, float rightX, float bottomY, float topY, TileCollisionType tileCollisionType)
{
    int posX, posY, sizeX, sizeY;
    SlopeOffsetI offset;
}

Sekarang kita hitung sisi-sisi pada petak dalam ruang dunia.

1	float leftTileEdge = tileCenter.x - Map.cTileSize / 2;
2	float rightTileEdge = leftTileEdge + Map.cTileSize;
3	float bottomTileEdge = tileCenter.y - Map.cTileSize / 2;
4	float topTileEdge = bottomTileEdge + Map.cTileSize;

Bagian ini akan cukup mudah. Ada dua kategori utama kasus yang bisa kita temukan. Pertama adalah tumpang tindih di dalam batasan petak.

Piksel biru gelap adalah posisi tumpang tindih, lalu tinggi dan lebar ditandai dengan petak biru. Berikutnya akan cukup sederhana, menghitung posisi dan ukuran tumpang tindih tidak perlu aksi tambahan.

Kasus kategori kedua adalah seperti berikut, dan dalam game kita akan lebih banyak menemui kasus seperti ini:

Kita lihat contoh pada gambar di atas. Seperti yang kamu bisa lihat, AABB menembus batas petak, tapi yang perlu kita cari tahu adalahah posisi dan ukuran tumpang tindih di dalam petak tersebut, agar kita bisa mendapat nilai offset yang kita simpan. Sekarang kita tidak peduli tentang apapun di luar batas petak. Hal ini memerlukan kita untuk membatasi posisi tumpang tindih dan ukurannya ke batas petak.

Posisi x sama dengan offset antara sisi kiri AABB dan sisi kiri petak. Jika AABB ada di kiri batas kisi petak, posisi perlu dibatasi menjadi 0. Untuk mendapatkan lebar tumpang tindih, kita perlu mengurangi riri kanan AABB dari posisi x tumpang tindih, yang sudah kita hitung sebelumnya.

Nilai sumbu Y dihitung dengan cara yang sama.

posX = (int)Mathf.Clamp(leftX - leftTileEdge, 0.0f, Map.cTileSize - 1);
sizeX = (int)Mathf.Clamp(rightX - (leftTileEdge + posX), 0.0f, Map.cTileSize - 1);

posY = (int)Mathf.Clamp(bottomY - bottomTileEdge, 0.0f, Map.cTileSize - 1);
sizeY = (int)Mathf.Clamp(topY - (bottomTileEdge + posY), 0.0f, Map.cTileSize - 1);

Sekarang kita bisa mengambil offset yang sudah disimpan untuk tumpang tindih tersebut.

1	offset = new SlopeOffsetI(slopeOffsets[(int)tileCollisionType][posX][posY][sizeX][sizeY]);

Mengatur Offset

Sebelum kita kembalikan offset, kita mungkin perlu mengaturnya. Pertimbangkan situasi berikut.

Kita lihat bagaimana offset yang kita simpan untuk tumpang tindih tersebut terlihat. Saat menyimpan data, kita hanya memedulikan tumpang tindih di dalam batas petak, dalam kasus ini, offset akan bernilai 9. Kamu bisa lihat jika kita menggeser area tumpang tindih di dalam petak 9 piksel ke atas, objek akan berhenti tabrakan dengan bidang miring, tapi jika kita geser keseluruhan AABB, maka area di bawah batas petak akan masuk ke dalam tabrakan.

Pada dasarnya, kita perlu mengatur offset atas sejumlah piksel AABB di bawah batas petak.

if (bottomTileEdge > bottomY)
{
    if (offset.freeUp > 0)
        offset.freeUp += (int)bottomTileEdge - (int)bottomY;
    offset.collidingBottom = offset.freeUp;
}

Hal yang sama perlu dilakukan untuk offset lainnya, kiri, kanan, dan bawah, kecuali saat ini kita lewati penanganan offset kiri dan kanan karena tidak diperlukan saat ini.

if (topTileEdge < topY)
{
    if (offset.freeDown < 0)
        offset.freeDown -= (int)(topY - topTileEdge);
    offset.collidingTop = offset.freeDown;
}
if (bottomTileEdge > bottomY)
{
    if (offset.freeUp > 0)
        offset.freeUp += (int)bottomTileEdge - (int)bottomY;
    offset.collidingBottom = offset.freeUp;
}

Begitu kita selesai, kita bisa mengembalikan offset yang sudah diatur. Fungsi yang sudah selesai akan terlihat seperti ini.

public static SlopeOffsetI GetOffset(Vector2 tileCenter, float leftX, float rightX, float bottomY, float topY, TileCollisionType tileCollisionType)
{
    int posX, posY, sizeX, sizeY;

    float leftTileEdge = tileCenter.x - Map.cTileSize / 2;
    float rightTileEdge = leftTileEdge + Map.cTileSize;
    float bottomTileEdge = tileCenter.y - Map.cTileSize / 2;
    float topTileEdge = bottomTileEdge + Map.cTileSize;
    SlopeOffsetI offset;

    posX = (int)Mathf.Clamp(leftX - leftTileEdge, 0.0f, Map.cTileSize - 1);
    sizeX = (int)Mathf.Clamp(rightX - (leftTileEdge + posX), 0.0f, Map.cTileSize - 1);

    posY = (int)Mathf.Clamp(bottomY - bottomTileEdge, 0.0f, Map.cTileSize - 1);
    sizeY = (int)Mathf.Clamp(topY - (bottomTileEdge + posY), 0.0f, Map.cTileSize - 1);

    offset = new SlopeOffsetI(slopeOffsets[(int)tileCollisionType][posX][posY][sizeX][sizeY]);

    if (topTileEdge < topY)
    {
        if (offset.freeDown < 0)
            offset.freeDown -= (int)(topY - topTileEdge);
        offset.collidingTop = offset.freeDown;
    }
    if (bottomTileEdge > bottomY)
    {
        if (offset.freeUp > 0)
            offset.freeUp += Mathf.RoundToInt(bottomTileEdge - bottomY);
        offset.collidingBottom = offset.freeUp;
    }

    return offset;
}

Tentu saja, fungsi tersebut tidak sepenuhnya selesai. Nanti kita erlu untuk menangani transformasi petak di sini, jadi offset yang dikembalikan tergantung apakah petak tersebut sudah dicerminkan pada sumbu XY atau diputar 90 derajat. Kali ini, kita hanya menggunakan petak yang tidak ditransformasi.

Mengimplementasi Langkah Physics satu piksel.

Gambaran Umum

Menggerakkan objek satu piksel akan memudahkan kita untuk menangani berbagai hal, terutama tabrakan terhadap bidang miring untuk objek yang cepat. Walaupun kita akan memeriksa tabrakan untuk setiap piksel gerakan kita, kita perlu bergerak dengan pola tertentu untuk memastikan akurasi. Pola ini tidak akan tergantung pada kecepatan objek,

Pada gambar di atas, kamu bisa lihat jika kita gerakkan objek sejumlah piksel yang dibutuhkan secara horizontal lalu vetikal, panah bisa berakhir menabrak dengan tanah yang tidak benar-benar berada pada jalur geraknya. Urutan pergerakkan harus berdasarkan rasio kecepatan vertikal terhadap horizontal; dengan begini kita tahu berapa banyak pikel kita perlu menggeser objek vertikal untuk setiap piksel objek bergerak horizontal.

Definisikan datanya

Kita lanjut ke kelas objek bergerak dan mendefinisikan beberapa variabel baru.

Pertama, variabel mPosition akan hanya menyimpan bilangan bulat, dan kita akan menyimpan variabel bernama mRemainder untuk menyimpan nilai di belakang koma.

1	public Vector2 mPosition;
2	public Vector2 mRemainder;

Berikutnya, kita tambahkan beberapa variabel status posisi untuk menunjukkan apakah karakter berada pada bidang miring. Di titik ini, lebih baik jika kita mengelompokkan semua status posisi dalam sebuah struktur.

[Serializable]
public struct PositionState
{
    public bool pushesRight;
    public bool pushesLeft;
    public bool pushesBottom;
    public bool pushesTop;

    public bool pushedTop;
    public bool pushedBottom;
    public bool pushedRight;
    public bool pushedLeft;

    public bool pushedLeftObject;
    public bool pushedRightObject;
    public bool pushedBottomObject;
    public bool pushedTopObject;

    public bool pushesLeftObject;
    public bool pushesRightObject;
    public bool pushesBottomObject;
    public bool pushesTopObject;

    public bool pushedLeftTile;
    public bool pushedRightTile;
    public bool pushedBottomTile;
    public bool pushedTopTile;

    public bool pushesLeftTile;
    public bool pushesRightTile;
    public bool pushesBottomTile;
    public bool pushesTopTile;

    public bool onOneWayPlatform;

    public Vector2i leftTile;
    public Vector2i rightTile;
    public Vector2i topTile;
    public Vector2i bottomTile;

    public void Reset()
    {
        leftTile = rightTile = topTile = bottomTile = new Vector2i(-1, -1);

        pushesRight = false;
        pushesLeft = false;
        pushesBottom = false;
        pushesTop = false;

        pushedTop = false;
        pushedBottom = false;
        pushedRight = false;
        pushedLeft = false;

        pushedLeftObject = false;
        pushedRightObject = false;
        pushedBottomObject = false;
        pushedTopObject = false;

        pushesLeftObject = false;
        pushesRightObject = false;
        pushesBottomObject = false;
        pushesTopObject = false;

        pushedLeftTile = false;
        pushedRightTile = false;
        pushedBottomTile = false;
        pushedTopTile = false;

        pushesLeftTile = false;
        pushesRightTile = false;
        pushesBottomTile = false;
        pushesTopTile = false;

        onOneWayPlatform = false;
    }
}

Sekarang deklarasikan instans dari struktur tersebut.

1	public PositionState mPS;

Variabel berikutnya yang akan kita butuhkan adalah status menempel pada bidang miring.

1	public bool mSticksToSlope;

Implementasi dasar

Kita mulai dengan membuat fungsi pengecekan tabrakan dasar; saat ini belum menangani bidang miring.

Pemeriksaan Tabrakan

Kita mulai dengan sisi kanan.

1	public bool CollidesWithTileRight(ref Vector2 position, ref Vector2 topRight, ref Vector2 bottomLeft, ref PositionState stat)
2	{
3	}

Parameter yang digunakan di sini adalah posisi objek saat ini, pojok kanan atas dan kiri bawah, dan status posisinya. Pertama kita perhitungkan pojok kanan atas dan kiri bawah petak untuk objek kita.

Vector2i topRightTile = mMap.GetMapTileAtPoint(new Vector2(topRight.x + 0.5f, topRight.y - 0.5f));

Vector2i bottomLeftTile = mMap.GetMapTileAtPoint(new Vector2(bottomLeft.x + 0.5f, bottomLeft.y + 0.5f));

Sekarang kita iterasi semua petak pada sisi kanan objek.

1	for (int y = bottomLeftTile.y; y <= topRightTile.y; ++y)
2	{
3	var tileCollisionType = mMap.GetCollisionType(topRightTile.x, y);
4	}

Lalu, tergantung dari petak collision, kita atur langkah berikutnya.

switch (tileCollisionType)
{
    default://slope
        break;
    case TileCollisionType.Empty:
        break;
    case TileCollisionType.Full:
        state.pushesRightTile = true;
        state.rightTile = new Vector2i(topRightTile.x, y);
        return true;
}

Seperti yang bisa kamu lihat, saat ini kita melewati menangani bidang miring, kita hanya ingin menyelesaikan pengaturan dasar sebelum kita masuk ke bidang miring.

Keseluruhan, fungsi kita seharusnya terlihat seperti ini:

public bool CollidesWithTileRight(ref Vector2 position, ref Vector2 topRight, ref Vector2 bottomLeft, ref PositionState stat)
{
    Vector2i topRightTile = mMap.GetMapTileAtPoint(new Vector2(topRight.x + 0.5f, topRight.y - 0.5f));
    Vector2i bottomLeftTile = mMap.GetMapTileAtPoint(new Vector2(bottomLeft.x + 0.5f, bottomLeft.y + 0.5f));

    for (int y = bottomLeftTile.y; y <= topRightTile.y; ++y)
    {
        var tileCollisionType = mMap.GetCollisionType(topRightTile.x, y);
    
        switch (tileCollisionType)
        {
            default://slope
                break;
            case TileCollisionType.Empty:
                break;
            case TileCollisionType.Full:
                state.pushesRightTile = true;
                state.rightTile = new Vector2i(topRightTile.x, y);
                return true;
        }
    }
    
    return false;
}

Kita lakukan yang sama untuk tiga arah lainnya: kiri, atas, dan bawah.

public bool CollidesWithTileLeft(ref Vector2 position, ref Vector2 topRight, ref Vector2 bottomLeft, ref PositionState stat)
{
    Vector2i topRightTile = mMap.GetMapTileAtPoint(new Vector2(topRight.x - 0.5f, topRight.y - 0.5f));
    Vector2i bottomLeftTile = mMap.GetMapTileAtPoint(new Vector2(bottomLeft.x - 0.5f, bottomLeft.y + 0.5f));

    for (int y = bottomLeftTile.y; y <= topRightTile.y; ++y)
    {
        var tileCollisionType = mMap.GetCollisionType(bottomLeftTile.x, y);
    
        switch (tileCollisionType)
        {
            default://slope
                break;
            case TileCollisionType.Empty:
                break;
            case TileCollisionType.Full:
                state.pushesLeftTile = true;
                state.leftTile = new Vector2i(bottomLeftTile.x, y);
                return true;
        }
    }
    
    return false;
}

public bool CollidesWithTileTop(ref Vector2 position, ref Vector2 topRight, ref Vector2 bottomLeft, ref PositionState stat)
{
    Vector2i topRightTile = mMap.GetMapTileAtPoint(new Vector2(topRight.x - 0.5f, topRight.y + 0.5f));
    Vector2i bottomleftTile = mMap.GetMapTileAtPoint(new Vector2(bottomLeft.x + 0.5f, bottomLeft.y + 0.5f));

    for (int x = bottomleftTile.x; x <= topRightTile.x; ++x)
    {
        var tileCollisionType = mMap.GetCollisionType(x, topRightTile.y);
    
        switch (tileCollisionType)
        {
            default://slope
                break;
            case TileCollisionType.Empty:
                break;
            case TileCollisionType.Full:
                state.pushesTopTile = true;
                state.topTile = new Vector2i(x, topRightTile.y);
                return true;
        }
    }
    
    return false;
}

public bool CollidesWithTileBottom(ref Vector2 position, ref Vector2 topRight, ref Vector2 bottomLeft, ref PositionState stat)
{
    Vector2i topRightTile = mMap.GetMapTileAtPoint(new Vector2(topRight.x - 0.5f, topRight.y - 0.5f));
    Vector2i bottomleftTile = mMap.GetMapTileAtPoint(new Vector2(bottomLeft.x + 0.5f, bottomLeft.y - 0.5f));

    for (int x = bottomleftTile.x; x <= topRightTile.x; ++x)
    {
        var tileCollisionType = mMap.GetCollisionType(x, bottomleftTile.y);
    
        switch (tileCollisionType)
        {
            default://slope
                break;
            case TileCollisionType.Empty:
                break;
            case TileCollisionType.Full:
                state.onOneWayPlatform = false;
                state.pushesBottomTile = true;
                state.bottomTile = new Vector2i(x, bottomleftTile.y);
                return true;
        }
    }
    
    return false;
}

Fungsi pergerakan

Setelah menangani hal tersebut, kita bisa mulai membuat dua fungsi untuk pergerakan objek. Satu akan menangani gerakan horizontal, dan fungsi lainnya akan menangani pergerakan vertikal.

1	public void MoveX(ref Vector2 position, ref bool foundObstacleX, float offset, float step, ref Vector2 topRight, ref Vector2 bottomLeft, ref PositionState state)
2	{
3	}

Parameter yang akan kita gunakan pada fungsi ini adalah posisi saat ini, boolean yang menunjukkan apakah kita menemukan rintangan sepanjang jalan atau tidak, sebuah offset yang menunjukkan seberapa banyak kira perlu bergerak, step yaitu jarak objek harus digerakkan setiap iterasi, titik kiri bawah dan kanan atas dari AABB, dan status posisi.

Pada dasarnya, yang kita ingin lakukan adalah menggerakkan objek sejauh step beberapa kali,sampai akhirnya total step mencapai offset. Tentu saja jika kita menemui rintangan, kita perlu berhenti bergerak.

1	while (!foundObstacleX && offset != 0.0f)
2	{
3	}

Pada setiap iterasi, kita kurangi step dari offset, jadi offset akhirnya menjadi nol, dan kita tahu kita bergerak sesuai dengan jumlah piksel yang seharusnya.

1	while (!foundObstacleX && offset != 0.0f)
2	{
3	offset -= step;
4	}

Di setiap step, kita ingin memeriksa apakah kita bertabrakan dengan sebuah petak. Jika kita bergerak ke kanan, kita ingin memeriksa apakah kita bertabrakan dengan tembok di kanan, jika kita bergerak ke kiri, kita ingin memeriksa rintangan di sebelah kiri.

while (!foundObstacleX && offset != 0.0f)
{
    offset -= step;
    
    if (step > 0.0f)
        foundObstacleX = CollidesWithTileRight(ref position, ref topRight, ref bottomLeft, ref state, true);
    else
        foundObstacleX = CollidesWithTileLeft(ref position, ref topRight, ref bottomLeft, ref state, true);
}

Jika kita tidak menemukan rintangan, kita bisa menggeser objek.

while (!foundObstacleX && offset != 0.0f)
{
    offset -= step;
    
    if (step > 0.0f)
        foundObstacleX = CollidesWithTileRight(ref position, ref topRight, ref bottomLeft, ref state, true);
    else
        foundObstacleX = CollidesWithTileLeft(ref position, ref topRight, ref bottomLeft, ref state, true);
        
    if (!foundObstacleX)
    {
        position.x += step;
        topRight.x += step;
        bottomLeft.x += step;
    }
}

Akhirnya, setelah kita bergerak, kita periksa tabrakan atas dan bawah, karena kita bisa saja melewati bagian bawah atau atas sebuah blok. Ini hanya untuk memperbarui status poisisi agar tetap akurat.

public void MoveX(ref Vector2 position, ref bool foundObstacleX, float offset, float step, ref Vector2 topRight, ref Vector2 bottomLeft, ref PositionState state)
{
    while (!foundObstacleX && offset != 0.0f)
    {
        offset -= step;

        if (step > 0.0f)
            foundObstacleX = CollidesWithTileRight(ref position, ref topRight, ref bottomLeft, ref state, true);
        else
            foundObstacleX = CollidesWithTileLeft(ref position, ref topRight, ref bottomLeft, ref state, true);

        if (!foundObstacleX)
        {
            position.x += step;
            topRight.x += step;
            bottomLeft.x += step;

            CollidesWithTileTop(ref position, ref topRight, ref bottomLeft, ref state);
            CollidesWithTileBottom(ref position, ref topRight, ref bottomLeft, ref state);
        }
    }
}

Fungsi MoveY bekerja dengan cara yang kurang lebih sama.

public void MoveY(ref Vector2 position, ref bool foundObstacleY, float offset, float step, ref Vector2 topRight, ref Vector2 bottomLeft, ref PositionState state)
{
    while (!foundObstacleY && offset != 0.0f)
    {
        offset -= step;

        if (step > 0.0f)
            foundObstacleY = CollidesWithTileTop(ref position, ref topRight, ref bottomLeft, ref state);
        else
            foundObstacleY = CollidesWithTileBottom(ref position, ref topRight, ref bottomLeft, ref state);

        if (!foundObstacleY)
        {
            position.y += step;
            topRight.y += step;
            bottomLeft.y += step;

            CollidesWithTileLeft(ref position, ref topRight, ref bottomLeft, ref state);
            CollidesWithTileRight(ref position, ref topRight, ref bottomLeft, ref state);
        }
    }
}

Menggabungkan gerakan

Sekarang kita memiliki fungsi yang bertanggung jawab pada gerakan vertikal dan horizontal, kita bisa membuat fungsi utama untuk pergerakan objek.

1	public void Move(Vector2 offset, Vector2 speed, ref Vector2 position, ref Vector2 remainder, AABB aabb, ref PositionState state)
2	{
3	}

Fungsi akan menerima nilai seberapa jauh objek bergerak, kecepatan objek saat ini, posisi dan sisa dari posisi saat ini, AABB objek, dan status posisi.

Pertama kita perlu menambahkan offset ke nilai sisa, jadi kita memiliki nilai keseluruhan seberapa banyak karakter perlu bergerak.

1	remainder += offset;

Karena kita akan memanggil fungsi MoveX dan MoveY di dalam fungsi ini, kita perlu mengirim nilai pojok kanan atas dan kiri bawah AABB, kita perhitungkan sekarang.

1	Vector2 topRight = aabb.Max();
2	Vector2 bottomLeft = aabb.Min();

Kita juga perlu mengambil vektor step. Ini akan digunakan sebagai arah gerakan objek.

1	var step = new Vector2(Mathf.Sign(offset.x), Mathf.Sign(offset.y));

Sekarang kita lihat berapa banyak piksel kita perlu bergerak. kita hanya perlu membulatkan nilai sisa, karena kita akan selalu bergerak dalam bilangan bulat, lalu kita perlu menguranginya dari nilai sisa tersebut.

1	var move = new Vector2(Mathf.Round(remainder.x), Mathf.Round(remainder.y));
2	remainder -= move;

Sekarang kita bagi gerakan menjadi empat kasus, tergantung dari nilai vektor gerakan kita. Jika nilai x dan y pada vektor gerakan adalah 0, tidak ada gerakan yang perlu dilakukan, jadi kita cukup keluar dari fungsi.

1	if (move.x == 0.0f && move.y == 0.0f)
2	return;

Jika hanya nilai Y yang 0, kita hanya akan bergerak secara horizontal.

1	if (move.x == 0.0f && move.y == 0.0f)
2	return;
3	else if (move.x != 0.0f && move.y == 0.0f)
4	MoveX(ref position, ref foundObstacleX, move.x, step.x, ref topRight, ref bottomLeft, ref state);

Jika hanya nilai x yang bernilai 0, kita hanya akan bergerak secara vertikal.

if (move.x == 0.0f && move.y == 0.0f)
    return;
else if (move.x != 0.0f && move.y == 0.0f)
    MoveX(ref position, ref foundObstacleX, move.x, step.x, ref topRight, ref bottomLeft, ref state);
else if (move.y != 0.0f && move.x == 0.0f)
    MoveY(ref position, ref foundObstacleY, move.y, step.y, ref topRight, ref bottomLeft, ref state);
else
{
}

Jika kita perlu bergerak pada sumbu X dan Y, kita perlu bergerak sesuai dengan pola yang dijelaskan sebelumnya. Pertama kita hitung rasio kecepatan objek.

1	float speedRatio = Mathf.Abs(speed.y) / Mathf.Abs(speed.x);

Kita buat juga akumulasi vertikal yang akan menyimpan berapa banyak piksel kita perlu bergerak vertikal dalam setiap pengulangan.

1	float speedRatio = Mathf.Abs(speed.y) / Mathf.Abs(speed.x);
2	float vertAccum = 0.0f;

Kondisi untuk berhenti bergerak adalah jika kita bertemu rintangan di sumbu apa saja, atau objek sudah digerakkan sesuai dengan vektor gerak secara penuh.

float speedRatio = Mathf.Abs(speed.y) / Mathf.Abs(speed.x);
float vertAccum = 0.0f;

while (!foundObstacleX && !foundObstacleY && (move.x != 0.0f || move.y != 0.0f))
{
}

Sekarang kita hitung seberapa banyak piksel kita perlu gerakkan objek secara vertikal.

1	while (!foundObstacleX && !foundObstacleY && (move.x != 0.0f \|\| move.y != 0.0f))
2	{
3	vertAccum += Mathf.Sign(step.y) * speedRatio;
4	}

Untuk gerakannya, kita perlu begerak satu step secara horizontal.

while (!foundObstacleX && !foundObstacleY && (move.x != 0.0f || move.y != 0.0f))
{
    vertAccum += Mathf.Sign(step.y) * speedRatio;
    
    MoveX(ref position, ref foundObstacleX, step.x, step.x, ref topRight, ref bottomLeft, ref state);
    move.x -= step.x;
}


Setelah ini kita bisa bergerak vertikal. Di sini kita tahu bahwa kita perlu menggeser objek sesuai nilai dalam vertAccum, tapi jika tidak akurat, jika kita bergerak sepenuhnya pada sumbu X, kita perlu bergerak sepenuhnya juga pada sumbu Y.

while (!foundObstacleX && !foundObstacleY && (move.x != 0.0f || move.y != 0.0f))
{
    vertAccum += Mathf.Sign(step.y) * speedRatio;
    
    MoveX(ref position, ref foundObstacleX, step.x, step.x, ref topRight, ref bottomLeft, ref state);
    move.x -= step.x;
    
    while (!foundObstacleY && move.y != 0.0f && (Mathf.Abs(vertAccum) >= 1.0f || move.x == 0.0f))
    {
        move.y -= step.y;
        vertAccum -= step.y;
    
        MoveY(ref position, ref foundObstacleX, step.y, step.y, ref topRight, ref bottomLeft, ref state);
    }
}


Lengkapnya, fungsi tersebut akan terlihat seperti ini:

public void Move(Vector2 offset, Vector2 speed, ref Vector2 position, ref Vector2 remainder, AABB aabb, ref PositionState state)
{
    remainder += offset;

    Vector2 topRight = aabb.Max();
    Vector2 bottomLeft = aabb.Min();
    
    bool foundObstacleX = false, foundObstacleY = false;

    var step = new Vector2(Mathf.Sign(offset.x), Mathf.Sign(offset.y));
    var move = new Vector2(Mathf.Round(remainder.x), Mathf.Round(remainder.y));
    remainder -= move;

    if (move.x == 0.0f && move.y == 0.0f)
        return;
    else if (move.x != 0.0f && move.y == 0.0f)
        MoveX(ref position, ref foundObstacleX, move.x, step.x, ref topRight, ref bottomLeft, ref state);
    else if (move.y != 0.0f && move.x == 0.0f)
        MoveY(ref position, ref foundObstacleY, move.y, step.y, ref topRight, ref bottomLeft, ref state);
    else
    {
        float speedRatio = Mathf.Abs(speed.y) / Mathf.Abs(speed.x);
        float vertAccum = 0.0f;

        while (!foundObstacleX && !foundObstacleY && (move.x != 0.0f || move.y != 0.0f))
        {
            vertAccum += Mathf.Sign(step.y) * speedRatio;

            MoveX(ref position, ref foundObstacleX, step.x, step.x, ref topRight, ref bottomLeft, ref state);
            move.x -= step.x;

            while (!foundObstacleY && move.y != 0.0f && (Mathf.Abs(vertAccum) >= 1.0f || move.x == 0.0f))
            {
                move.y -= step.y;
                vertAccum -= step.y;

                MoveY(ref position, ref foundObstacleX, step.y, step.y, ref topRight, ref bottomLeft, ref state);
            }
        }
    }
}

Sekarang kita bisa menggunakan fungsi yang kita buat untuk menyusun fungsi UpdatePhysics.

Membuat fungsi memperbarui Physics

Pertama, kita perlu memperbarui status posisi, jadi semua data frame sebelumnya disimpan ke variabel yang sesuai, dan data frame ini diatur ulang.

public void UpdatePhysics()
{
    mPS.pushedBottom = mPS.pushesBottom;
    mPS.pushedRight = mPS.pushesRight;
    mPS.pushedLeft = mPS.pushesLeft;
    mPS.pushedTop = mPS.pushesTop;

    mPS.pushedBottomTile = mPS.pushesBottomTile;
    mPS.pushedLeftTile = mPS.pushesLeftTile;
    mPS.pushedRightTile = mPS.pushesRightTile;
    mPS.pushedTopTile = mPS.pushesTopTile;

    mPS.pushesBottom = mPS.pushesLeft = mPS.pushesRight = mPS.pushesTop = 
        mPS.pushesBottomTile = mPS.pushesLeftTile = mPS.pushesRightTile = mPS.pushesTopTile = 
        mPS.pushesBottomObject = mPS.pushesLeftObject = mPS.pushesRightObject = mPS.pushesTopObject = mPS.onOneWay = false;
}

Sekarang kita perbarui status tabrakan objek kita. Kita lakukan sebelum menggeser objek agar kita punya data terbaru apakah objek ada di atas tanah atau sedang mendorong petak lain. Biasanya data frame sebelumnya akan tetap terbarui jika tanah tidak bisa dimodifikasi dan objek lain tidak bisa bergerak, tapi kita asumsikan hal-hal tersebut bisa terjadi.

1	Vector2 topRight = mAABB.Max();
2	Vector2 bottomLeft = mAABB.Min();
3
4	CollidesWithTiles(ref mPosition, ref topRight, ref bottomLeft, ref mPS);

CollidesWithTiles hanya memanggil semua fungsi tabrakan yang sudah kita tulis.

public void CollidesWithTiles(ref Vector2 position, ref Vector2 topRight, ref Vector2 bottomLeft, ref PositionState state)
{
    CollidesWithTileTop(ref position, ref topRight, ref bottomLeft, ref state);
    CollidesWithTileBottom(ref position, ref topRight, ref bottomLeft, ref state);
    CollidesWithTileLeft(ref position, ref topRight, ref bottomLeft, ref state);
    CollidesWithTileRight(ref position, ref topRight, ref bottomLeft, ref state);
}

Lalu perbarui kecepatannya.

mOldSpeed = mSpeed;

if (mPS.pushesBottomTile)
    mSpeed.y = Mathf.Max(0.0f, mSpeed.y);
if (mPS.pushesTopTile)
    mSpeed.y = Mathf.Min(0.0f, mSpeed.y);
if (mPS.pushesLeftTile)
    mSpeed.x = Mathf.Max(0.0f, mSpeed.x);
if (mPS.pushesRightTile)
    mSpeed.x = Mathf.Min(0.0f, mSpeed.x);

Dan perbarui posisi. Pertama, kita simpan posisi lama.

1	mOldPosition = mPosition;

Hitung posisi baru.

1	Vector2 newPosition = mPosition + mSpeed * Time.deltaTime;

Hitung offset antara dua posisi tersebut.

1	Vector2 offset = newPosition - mPosition;

Jika offset tersebut bukan nol, kita bisa panggil fungsi Move.

1	if (offset != Vector2.zero)
2	Move(offset, mSpeed, ref mPosition, ref mRemainder, mAABB, ref mPS);

Akhirnya, perbarui AABB objek dan status posisi.

mAABB.Center = mPosition;

mPS.pushesBottom = mPS.pushesBottomTile;
mPS.pushesRight = mPS.pushesRightTile;
mPS.pushesLeft = mPS.pushesLeftTile;
mPS.pushesTop = mPS.pushesTopTile;

Sekian! Sistem ini sekarang menggantikan yang lama, hasilnya akan sama walau cara kita melakukannya berbeda.

Ringkasan

Dengan begitu kita sudah menyiapkan dasar untuk bidang miring, yang tersisa adalah mengisi celah pada pengecekan tabrakan. Kita sudah menyelesaikan penyimpanan data di sini dan menghilangkan banyak kompleksitas geometri dengan mengimplementasi integrasi gerakan satu piksel.

Ini akan membuat implementasi bidang miring lebih mudah dibandingkan yang kita perlu lakukan sebelumnya. Kita akan menyelesaikan pekerjaan itu pada bagian berikutnya dari seri tutorial ini.

Terima kasih sudah membaca!