Advertisement
  1. Game Development
  2. Platformer
Gamedevelopment

Dasar Physics Platformer 2D, Bagian 7: Bidang Miring

by
Difficulty:IntermediateLength:LongLanguages:
This post is part of a series called Basic 2D Platformer Physics .
Basic 2D Platformer Physics, Part 6: Object vs. Object Collision Response

Indonesian (Bahasa Indonesia) translation by Aditia Dwiperdana (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.

Slopes Data

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

Another slope shape

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.

Transformations of the 45 degree slope

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.

Rotating slopes

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
Calculating Offsets

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.

Animation of moving down a slope

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.

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

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

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.

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

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.

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

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.

Kita buat array penyimpanannya di sini.

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

Struktur Offset

Sekarang kita bisa mendefinisikan struktur offset kita.

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.

Dan buat array pada fungsi Init.

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.

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.

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

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.

No overlaps

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.

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

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

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.

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

Sekarang lakukan hal yang sama untuk offset bawah dan kanan.

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.

Move the object out of collision

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.

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.

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.

Kita lakukan hal yang sama untuk offset kiri dan kanan.

Menyimpan data

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

Kita buat tempat penyimpanan untuk data kita.

Menginisialisasi array

Dan akhirnya, buat fungsi penyimpanan data.

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.

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.

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.

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

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.

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

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.

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.

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

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,

Checking 1-pixel collisions

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.

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.

Sekarang deklarasikan instans dari struktur tersebut.

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

Implementasi dasar

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

Pemeriksaan Tabrakan

Kita mulai dengan sisi kanan.

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.

Sekarang kita iterasi semua petak pada sisi kanan objek.

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

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:

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

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.

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.

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

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.

Jika kita tidak menemukan rintangan, kita bisa menggeser objek.

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.

Fungsi MoveY bekerja dengan cara yang kurang lebih sama.

Menggabungkan gerakan

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

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.

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.

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

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.

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.

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

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

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

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

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

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

Untuk gerakannya, kita perlu begerak satu step secara horizontal.

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.

Lengkapnya, fungsi tersebut akan terlihat seperti ini:

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.

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.

CollidesWithTiles hanya memanggil semua fungsi tabrakan yang sudah kita tulis.

Lalu perbarui kecepatannya.

Dan perbarui posisi. Pertama, kita simpan posisi lama.

Hitung posisi baru.

Hitung offset antara dua posisi tersebut.

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

Akhirnya, perbarui AABB objek dan status posisi.

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!

Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.