Unlimited WordPress themes, graphics, videos & courses! Unlimited asset downloads! From $16.50/m
Advertisement
  1. Game Development
  2. Platformer
Gamedevelopment

Asz 2D Pelantar Fizik, Bahagian 7: Cerun Groundwork

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

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

Final product image
What You'll Be Creating

Demo

Demo menunjukkan hasil akhir pelaksanaan cerun. Gunakan WASD untuk menggerakkan watak. Butang tetikus kanan membuat jubin. Anda boleh menggunakan roda skrol atau kekunci anak panah untuk memilih jubin yang anda mahu letakkan. Slider menukar saiz watak pemain.

Demo telah diterbitkan di bawah Unity 5.5.2f1, dan kod sumber juga serasi dengan versi Perpaduan ini.

Lereng

Lereng menambah banyak fleksibiliti untuk permainan, baik dari segi interaksi yang mungkin dengan medan permainan dan dalam varians visual, tetapi pelaksanaannya dapat sangat rumit, terutama jika kami ingin menyokong sejumlah besar jenis cerun.

Sebagaimana yang berlaku untuk bahagian-bahagian sebelumnya dalam siri ini, kami akan meneruskan kerja kami dari saat kami meninggalkan bahagian terakhir, walaupun kami akan mengolah semula sebahagian besar kod yang telah kami tulis. Apa yang kita perlukan dari permulaan adalah watak bergerak dan tilemap.

Anda boleh memuat turun fail projek dari bahagian sebelumnya dan menulis kod itu bersama-sama dengan tutorial ini.

Perubahan dalam Integrasi Pergerakan

Sejak membuat kerja-kerja cerun agak sukar, ia akan menjadi lebih baik jika kita boleh membuat lebih mudah dalam beberapa aspek. Beberapa waktu yang lalu saya terjumpa satu jawatan blog tentang bagaimana Matt Thorson mengendalikan fizik dalam permainannya. Pada dasarnya, dalam kaedah ini pergerakan sentiasa dibuat dalam selang 1px. Jika gerakan untuk bingkai tertentu lebih besar daripada satu piksel, maka vektor pergerakan dibahagikan kepada banyak pergerakan 1px, dan selepas masing-masing syarat-syarat untuk perlanggaran dengan rupa bumi disemak.

Ini menyelamatkan kita sakit kepala yang cuba mencari halangan-halangan di sepanjang garis pergeraan sekaligus, dan sebaliknya, kita boleh melakukannya secara berulang-ulang. Ini menjadikan pelaksanaan lebih mudah, tetapi malangnya ia juga meningkatkan bilangan pemeriksaan perlanggaran yang dilakukan, jadi mungkin tidak sesuai untuk permainan di mana terdapat banyak objek bergerak, terutama permainan resolusi tinggi di mana secara semula jadi kecepatan di mana objek bergerak lebih tinggi. Sisi campur adalah bahawa walaupun terdapat lebih banyak cek perlanggaran, setiap pemeriksaan akan lebih mudah kerana ia tahu bahawa watak bergerak oleh piksel tunggal setiap kali.

Data Lereng

Mari kita mula menentukan data yang kita perlukan untuk mewakili cerun. Pertama sekali, kami memerlukan peta ketinggian cerun, yang akan menentukan bentuknya. Mari kita mulakan dengan cerun klasik 45 darjah.

Slopes Data

Mari kita juga menentukan bentuk cerun lain; yang ini akan menjadi lebih banyak benjolan di atas tanah daripada apa-apa lagi.

Another slope shape

Sudah tentu kami akan menggunakan variasi cerun ini, bergantung di mana kami mahu meletakkannya. Sebagai contoh, dalam kes cerun 45 darjah yang ditetapkan, ia akan sesuai dengan baik jika terdapat blok padu di sebelah kanannya, tetapi jika blok pepejal berada di sebelah kiri maka kami ingin menggunakan versi jubin kami ditakrifkan. Kita perlu dapat mengalihkan lereng pada paksi X dan paksi Y serta memutarkannya dengan 90 darjah untuk dapat mengakses semua varian cerun yang telah ditetapkan.

Mari kita lihat apa perubahan rupa cerun 45 darjah.

Transformations of the 45 degree slope

Seperti yang anda dapat lihat, dalam kes ini kita boleh mendapatkan semua varian yang menggunakan lambungan. Kami tidak semestinya perlu memutarkan cerun dengan 90 darjah, tetapi mari kita melihat bagaimana keadaan mencari cerun kedua yang kami jelaskan sebelumnya.

Rotating slopes

Dalam kes ini, transformasi putaran 90 darjah memungkinkan untuk meletakkan cerun di dinding.

Kira Offset

Mari kita gunakan data yang ditentukan untuk mengira offset yang perlu diterapkan pada objek yang bertindih dengan jubin. Offset akan membawa maklumat mengenai:

  • berapa banyak objek perlu bergerak naik / turun / kiri / kanan agar tidak bertembung dengan jubin
  • berapa banyak objek perlu bergerak tepat di sebelah permukaan atas/bawah/kiri/kanan cerun
Calculating Offsets

Bahagian hijau dari gambar di atas adalah bahagian di mana objek bertindih dengan bahagian kosong jubin, dan petak kuning menunjukkan kawasan di mana objek bertindih dengan cerun.

Kini, mari kita mula melihat bagaimana kita akan mengira offset untuk nombor kes 1.

Objek tidak bertembung dengan mana-mana bahagian cerun. Ini bermakna kita tidak perlu bergerak dari perlanggaran, jadi bahagian pertama dari offset kami akan ditetapkan kepada 0.

Untuk bahagian kedua offset, jika kita ingin bahagian bawah objek menyentuh lereng, kita perlu memindahkannya 3 piksel ke bawah. Sekiranya kita mahu sebelah kanan objek menyentuh cerun, kita perlu memindahkannya 3 piksel ke kanan. Untuk sisi kiri objek untuk menyentuh pinggir kanan cerun, kita perlu memindahkannya 16 piksel ke kanan. Begitu juga, jika kita mahu bahagian atas objek untuk menyentuh cerun, kita perlu memindahkan objek ke bawah 16 piksel.

Sekarang, mengapa kita memerlukan maklumat sejauh mana jarak di antara kelebihan objek dan cerun? Data ini akan sangat berguna kepada kita apabila kita mahu sesuatu objek melekat pada cerun.

Jadi, sebagai contoh, katakan objek bergerak ke kiri pada cerun 45 darjah. Jika ia bergerak pantas, ia akan berakhir di udara, dan akhirnya ia akan jatuh di lereng lagi, dan sebagainya. Sekiranya kita mahu terus berada di lereng, setiap kali ia bergerak ke kiri, kita akan mahu menolaknya supaya ia tetap bersentuhan dengan cerun. Animasi di bawah menunjukkan perbezaan di antara yang mempunyai lancaran cerun didayakan atau dilumpuhkan untuk watak.

Animation of moving down a slope

Kami akan caching banyak data di sini-pada asasnya, kami ingin mengira offset untuk setiap kemungkinan bertindih dengan jubin. Ini bermakna bahawa bagi setiap kedudukan dan bagi setiap saiz yang bertindih, kita akan mempunyai rujukan cepat tentang berapa banyak untuk memindahkan objek. Perhatikan bahawa kita tidak boleh menyembunyikan offset akhir kerana kita tidak boleh menyembunyikan offset untuk setiap AABB yang mungkin, tetapi mudah untuk menyesuaikan offset mengetahui pertindihan AABB dengan jubin cerun.

Menetapkan jubin

Kami akan mendefinisikan semua data cerun dalam kelas Slope statik.

Pertama sekali, mari kita mengendalikan ketinggian tinggi. Mari kita tentukan beberapa daripada mereka untuk memproses kemudiannya.

Mari tambahkan jenis jubin ujian untuk cerun yang ditetapkan.

Mari kita buat lagi penghitungan untuk jenis perlanggaran jubin. Ini berguna untuk memberikan jenis perlanggaran yang sama kepada jubin yang berbeza, contohnya cerun 45 derajat berumput atau cerun 45 derajat batu.

Sekarang mari kita buat pelbagai yang akan memegang semua tallmaps jubin. Arahan ini akan diindeks oleh penghitungan TileCollisionType.

Memproses Lereng

Sebelum kita mula mengira offset, kita akan mahu membuka ketinggian kita ke bitmaps perlanggaran penuh. Ini akan memudahkan untuk menentukan sama ada AABB bertembung dengan jubin dan juga akan membolehkan bentuk jubin yang lebih rumit jika itu yang kita perlukan. Mari kita buat pelbagai untuk bitmap itu.

Sekarang mari kita buat fungsi yang akan memanjangkan heightmap ke dalam bitmap.

Tidak ada yang rumit di sini-jika kedudukan tertentu pada jubin adalah pepejal, kami menetapkannya kepada 1; jika tidak, ia ditetapkan kepada 0.

Sekarang mari kita buat fungsi Init kita, yang akhirnya akan melakukan semua kerja caching yang perlu kita lakukan di lereng.

Mari kita buat array kontena di sini.

Sekarang mari kita buat setiap jenis jurang perlanggaran jubin ke data cache yang sama.

Struktur Offset

Sekarang kita dapat menentukan struktur offset kita.

Seperti yang dijelaskan sebelumnya, pembolehubah freeLeft, freeRight, freeDown, dan freeUp sesuai dengan offset yang perlu digunakan supaya objek tidak lagi bertembung dengan cerun, manakala collidingLeft, collidingRight, collidingTop, dan collidingBottom adalah jarak objek tersebut perlu dialihkan untuk menyentuh cerun sementara tidak bertindih.

Sudah tiba masanya untuk mewujudkan tugas caching tugas berat kita, tetapi sebelum kita melakukannya, mari kita buat satu bekas yang akan memegang semua data itu.

Dan buat array dalam fungsi Init.

Isu Memori

Seperti yang anda lihat, array ini mempunyai banyak dimensi, dan setiap jenis jubin baru sebenarnya memerlukan banyak ingatan. Untuk setiap kedudukan X di jubin, untuk setiap kedudukan Y di jubin, untuk setiap Lebar yang mungkin di jubin dan untuk setiap Ketinggian yang mungkin, terdapat pengiraan nilai offset yang berasingan.

Oleh kerana jubin yang kita gunakan adalah 16x16, ini bermakna jumlah data yang diperlukan untuk setiap jenis jubin akan menjadi 16*16*16*16*8 bait, yang sama dengan 512 kB. Ini adalah banyak data, tetapi masih boleh diurus, dan tentu saja jika caching jumlah maklumat ini tidak dapat dilaksanakan, kita perlu sama ada menukar untuk mengira offset dalam masa nyata, mungkin menggunakan kaedah yang lebih efisien daripada yang kita menggunakan caching, atau mengoptimumkan data kami.

Sekarang, jika saiz jubin dalam permainan kami lebih besar, katakan 32x32, setiap jenis jubin akan menduduki 8 MB, dan jika kami menggunakan 64x64, maka ia akan menjadi 128MB. Jumlah ini kelihatan terlalu besar untuk digunakan, terutamanya jika kita ingin mempunyai beberapa jenis cerun dalam permainan. Penyelesaian yang masuk akal untuk ini seolah-olah memecah jubin perlanggaran besar menjadi yang lebih kecil. Perhatikan bahawa ia hanya setiap cerun yang baru ditakrifkan yang memerlukan lebih banyak ruang-transformasi menggunakan data yang sama.

Memeriksa Perlanggaran Dalam Jubin

Sebelum kita mula mengira offset, kita perlu tahu sama ada objek pada kedudukan tertentu akan bertembung dengan bahagian pepejal jubin. Mari buat fungsi ini terlebih dahulu.

Fungsi ini mengambil bitmap perlanggaran, kedudukan tumpang tindih, dan saiz tumpang tindih. Kedudukannya adalah piksel kiri bawah objek, dan saiz adalah 0-berasaskan  lebar dan ketinggian . Dengan 0, saya maksudkan bahawa lebar 0 bermakna objek itu sebenarnya 1 piksel lebar, dan lebar sama dengan 15 bermaksud objek itu adalah 16 piksel lebar. Fungsi ini sangat mudah-jika mana-mana piksel objek bertindih dengan cerun, maka kita kembali benar, kalau tidak kita kembali palsu.

Kira Offset

Sekarang mari kita mula mengira offset.

Sekali lagi, untuk mengira offset, kita memerlukan bitmap perlanggaran, kedudukan dan saiz pertindihan. Mari mulakan dengan mengisytiharkan nilai offset.

Sekarang mari kita hitung berapa banyak yang kita perlukan untuk menggerakkan objek supaya tidak bertembung dengan cerun. Untuk melakukan itu, manakala objek bertembung dengan cerun, kita perlu terus bergerak dan memeriksa perlanggaran sehingga tidak ada bertindih dengan bahagian pepejal jubin.

No overlaps

Di atas adalah ilustrasi bagaimana kita mengira offset tersebut. Dalam kes pertama, kerana objek itu menyentuh terikat atas jubin, bukan hanya memindahkannya, kita juga perlu mengurangkan ketinggiannya. Itu kerana jika mana-mana bahagian AABB bergerak di luar batas jubin, kami tidak lagi berminat dengannya. Begitu juga, offset dikira untuk semua arahan lain, jadi untuk contoh di atas, offset adalah:

  • 4 untuk mengimbangi
  • -4 untuk offset kiri
  • -16 untuk offset bawah - iaitu jarak maksimum kerana pada dasarnya jika kita memindahkan objek ke bawah, kita perlu memindahkannya keluar dari batas jubin untuk berhenti berlanggar dengan lereng
  • 16 untuk mengimbangi hak

Mari kita mulakan dengan mengisytiharkan pemboleh ubah sementara untuk ketinggian objek. Seperti yang disebutkan di atas, ini akan berubah bergantung pada berapa tinggi kita akan memindahkan objek tersebut.

Kini sudah tiba masanya untuk keadaan utama. Selagi objek tidak berpindah dari sempadan jubin dan bertembung dengan bahagian-bahagian padu jubin, kita perlu meningkatkan offsetUp.

Akhir sekali, mari kita menyesuaikan saiz jubin objek yang bertindih jika objek bergerak di luar batas jubin.

Sekarang mari kita lakukan perkara yang sama untuk offset kiri. Perhatikan bahawa apabila kita bergerak objek yang tersisa dan objek itu dipindahkan dari batas jubin, kita tidak semestinya perlu mengubah kedudukannya; Sebaliknya, kita hanya menukar lebar pertindihan itu. Ini digambarkan di sebelah kanan animasi yang menggambarkan pengiraan offset.

 Tetapi di sini, kerana kami tidak menggerakkan freeLeft offset di sepanjang jalan ketika kami menurunkan lebar, kami perlu menukar ukuran yang dikurangkan ke dalam offset.

Sekarang mari kita melakukan perkara yang sama untuk offsets turun dan kanan.

Baiklah, kami telah memperhitungkan bahagian pertama offset itu - iaitu berapa banyak kita perlu menggerakkan objek itu untuk berhenti berlanggar dengan cerun. Kini sudah tiba masanya untuk memikirkan offset yang sepatutnya menggerakkan objek di sebelah bahagian pepejal jubin.

Perhatikan bahawa jika kita perlu menggerakkan objek dari perlanggaran, kita sudah melakukan itu, kerana kita berhenti sejurus selepas perlanggaran tidak lagi.

Move the object out of collision

Dalam kes di sebelah kanan, upset adalah 4, tetapi ia juga mengimbangi bahawa kita perlu memindahkan objek untuk tepi bawahnya untuk duduk di atas piksel padat. Begitu juga dengan pihak lain.

Sekarang kes di sebelah kiri adalah di mana kita perlu mencari offset kita sendiri. Jika kita ingin mencari collidingBottom di luar sana, kita perlu memindahkan objek 3 piksel ke bawah. Pengiraan yang diperlukan di sini adalah sama dengan yang sebelumnya, tetapi kali ini kita akan mencari apabila objek akan bertembung dengan cerun, dan kemudian bergerak sambil mengurangkan offset oleh satu, jadi ia hampir tidak menyentuh piksel padat dan bukannya bertindih .

Jika freeUp adalah sama dengan 0, turun ke bawah mestilah sama dengan 0 juga, jadi kita boleh membuang pengiraan untuk collidingTop di bawah kurungan yang sama. Sekali lagi, pengiraan ini sama dengan apa yang telah kami lakukan setakat ini.

Mari buat perkara yang sama untuk offset kiri dan kanan.

Caching Data

Sekarang semua offset dikira, kita boleh mengembalikan offset untuk set data tertentu ini.

Mari buatkan bekas untuk semua data cache kami.

Inisialisasi array.

Dan akhirnya, buat fungsi caching.

Fungsi itu sendiri adalah sangat mudah, jadi sangat mudah untuk melihat berapa banyak data cache untuk memenuhi keperluan kami!

Sekarang pastikan untuk mengunci offset untuk setiap jenis perlanggaran jubin.

Dan itu sahaja, fungsi caching utama kami selesai!

Mengira Offset Space Dunia

Sekarang mari kita gunakan data cache untuk membuat fungsi yang akan mengembalikan suatu offset untuk watak yang wujud dalam ruang dunia.

Offset yang kami akan kembali bukanlah struct yang sama yang kami gunakan untuk data cache, oleh kerana offset ruang dunia dapat menjadi lebih besar dari batas byte tunggal. Struktur pada dasarnya adalah perkara yang sama, tetapi menggunakan integer.

Parameternya seperti berikut:

  • pusat ruang dunia jubin
  • tepi kiri, kanan, bawah dan atas AABB kita mahu menerima offset untuk
  • jenis jubin yang kita mahu menerima offset untuk

Pertama, kita perlu memikirkan bagaimana AABB bertindih dengan jubin cerun. Kita perlu tahu di mana tumpang tindih bermula (sudut kiri bawah), dan juga berapa banyak pertindihan yang meluas di atas jubin.

Untuk mengira ini, mari kita mengisytiharkan pembolehubah pertama.

Kini mari kita menghitung tepi jubin di ruang dunia.

Kini ini haruslah mudah. Terdapat dua kategori utama kes yang boleh kita dapati di sini. Pertama ialah tumpang tindih dalam batas jubin.

Pixel biru gelap adalah kedudukan tumpang tindih, dan ketinggian dan lebar ditandai dengan jubin biru. Di sini perkara-perkara yang cukup mudah, jadi mengira kedudukan dan saiz tumpang tindih tidak memerlukan sebarang tindakan tambahan.

Kategori kes kedua kelihatan seperti berikut, dan dalam permainan, kami akan kebanyakannya menangani perkara tersebut:

Mari kita lihat keadaan contoh yang digambarkan di atas. Seperti yang anda dapat lihat, AABB meluas jauh di luar jubin, tetapi apa yang perlu kita fikirkan ialah kedudukan dan saiz pertindihan dalam jubin itu sendiri, jadi kita dapat mengambil semula nilai offset cache kami. Sekarang kita tidak peduli apa-apa yang terletak di luar batas jubin. Ini akan memerlukan kita untuk mengepilkan kedudukan bertindih dan saiz ke batas jubin.

Kedudukan x adalah sama dengan mengimbangi antara kelebihan kiri AABB dan kelebihan kiri jubin. Sekiranya AABB berada di sebelah kiri tepi kiri jubin, kedudukan perlu dikunci ke 0. Untuk mendapatkan lebar pertindihan, kita perlu tolak kelebihan kanan AABB dari kedudukan x yang bertindih, yang telah kami dikira.

Nilai untuk paksi Y dikira dengan cara yang sama.

Sekarang kita dapat mengambil offset cache untuk pertindihan.

Laraskan Offset

Sebelum kita mengembalikan offset, kita mungkin perlu menyesuaikannya. Pertimbangkan keadaan berikut.

Mari lihat bagaimana cached kami untuk overlap seperti itu akan kelihatan. Apabila caching, kami hanya mengambil berat tentang tumpang tindih dalam batas jubin, jadi dalam kes ini, upset akan sama dengan 9. Anda dapat melihat bahawa jika kami memindahkan kawasan tumpang tindih dalam batas jubin 9 piksel, ia akan berhenti bertembung dengan cerun, tetapi jika kami memindahkan seluruh AABB, maka kawasan yang berada di bawah batas jubin akan bergerak ke dalam perlanggaran tersebut.

Pada asasnya, apa yang perlu kita lakukan di sini adalah menyesuaikan upset dengan bilangan piksel yang AABB memanjangkan di bawah batas jubin.

Hal yang sama perlu dilakukan untuk semua offset lain-kiri, kanan, dan bawah-kecuali untuk sekarang kita akan melangkau pengendalian offsets kiri dan kanan dengan cara ini kerana tidak perlu melakukannya.

Sebaik sahaja kami selesai, kami boleh mengembalikan offset yang diselaraskan. Fungsi selesai harus kelihatan seperti ini.

Sudah tentu, ia belum selesai sepenuhnya. Kemudian, kami juga akan mengendalikan transformasi jubin di sini, jadi offset dikembalikan dengan sewajarnya bergantung kepada sama ada jubin telah dibalik pada paksi XY atau berputar 90 darjah. Buat masa ini, kami akan bermain hanya dengan jubin yang tidak diubah.

Melaksanakan Fizik Langkah Satu Pixel

Gambaran keseluruhan

Memindahkan objek dengan satu piksel akan menjadikannya agak mudah untuk mengendalikan banyak perkara, terutamanya perlanggaran terhadap cerun untuk objek pantas, tetapi walaupun kita akan memeriksa perlanggaran setiap piksel yang kita bergerak, kita harus bergerak dalam corak tertentu untuk memastikan ketepatan. Corak ini bergantung kepada kelajuan objek.

Checking 1-pixel collisions

Pada gambar di atas, anda dapat melihat bahawa jika kita secara membuta tulak menggerakkan objek terlebih dahulu semua piksel itu perlu bergerak secara mendatar, dan selepas itu secara menegak, anak panah akan bertembung dengan blok pepejal yang tidak benar pada perjalanannya. Perintah pergerakan harus berdasarkan pada nisbah menegak hingga kelajuan mendatar; dengan cara ini kita akan tahu berapa piksel yang kita perlu bergerak secara menegak untuk setiap piksel bergerak mendatar.

Tentukan Data

Demo menunjukkan hasil akhir tutorial ini. Gunakan WASD untuk menggerakkan watak. Butang tetikus tengah menanam platform satu hala, butang kanan tetikus melancarkan jubin pepejal, dan bar ruang spawns menimbulkan klon aksara.

Pertama sekali, pembolehubah mPosition utama kami hanya akan memegang nombor integer, dan kami akan menyimpan pembolehubah lain yang dipanggil mRemainder untuk menyimpan nilai selepas titik terapung.

Seterusnya, kami akan menambah beberapa pembolehubah status kedudukan baru untuk menunjukkan sama ada watak itu sedang berada di cerun. Pada ketika ini, ia akan menjadi baik jika kita membungkus status kedudukan ke dalam satu struktur.

Sekarang mari kita mengisytiharkan contoh struct bagi objek itu.

Pembolehubah lain yang kami perlukan adalah melekat cerun.

Pelaksanaan Asas

Mari bermula dengan mencipta fungsi pemeriksaan perlanggaran dasar; ini tidak akan mengendalikan lereng lagi.

Cek Collision

Mari bermula dengan sebelah kanan.

Parameter yang digunakan di sini adalah kedudukan semasa objek, sudut kanan atas dan bawah kiri, dan kedudukan kedudukan. Pertama sekali, mari kita kirakan bahagian atas dan kanan atas jubin untuk objek kita.

Sekarang mari kita meleleputi semua jubin di sepanjang tepi kanan objek.

Kini, bergantung kepada jurang perlanggaran, kita bertindak balas dengan sewajarnya.

Seperti yang dapat anda lihat, buat masa ini kami akan melangkaui pengendalian cerun; kita hanya mahu mendapatkan persediaan asas sebelum kita menyelidikinya.

Secara keseluruhan, fungsi untuk masa sekarang sepatutnya seperti ini:

Kami akan melakukan perkara yang sama untuk ketiga-tiga arahan yang lain: kiri, ke atas, dan ke bawah.

Memindahkan Fungsi

Sekarang bahawa kita telah dilindungi ini, kita boleh mula mewujudkan dua fungsi yang bertanggungjawab untuk pergerakan. Satu akan mengendalikan pergerakan secara mendatar, dan satu lagi akan mengendalikan pergerakan menegak.

Argumen-argumen yang akan kita gunakan dalam fungsi ini adalah kedudukan semasa, sebuah boolean yang menunjukkan sama ada kita menemui halangan di sepanjang jalan atau tidak, suatu offset yang menentukan berapa banyak yang kita perlu bergerak, satu langkah yang merupakan nilai yang kita pindahkan objek dengan setiap lelaran, bahagian kanan AABB yang lebih rendah dan kiri kanan, dan akhirnya keadaan kedudukannya.

Pada asasnya, apa yang ingin kita lakukan di sini adalah menggerakkan objek dengan langkah yang banyak kali, supaya langkah-langkahnya dapat diselesaikan. Sudah tentu, jika kita menghadapi halangan, kita perlu berhenti bergerak juga.

Dengan setiap lelaran, kita tolak langkah dari offset, jadi offset akhirnya menjadi sifar, dan kita tahu kita berpindah seberapa banyak piksel yang kita perlukan.

Dengan setiap langkah, kami ingin menyemak sama ada kami bertembung dengan jubin. Jika kami bergerak dengan betul, kami ingin memeriksa jika kami bertembung dengan dinding di sebelah kanan; jika kita bergerak ke kiri, kita mahu menyemak halangan di sebelah kiri.

Jika kita tidak menemui halangan, kita boleh menggerakkan objek itu.

Akhirnya, selepas kami bergerak, kami memeriksa perlanggaran atas dan ke bawah, kerana kami boleh meluncur tepat di bawah atau di atas blok. Ini hanya untuk mengemas kini kedudukan kedudukan tepat.

Fungsi MoveY berfungsi sama.

Menyatukan Pergerakan

Sekarang kita mempunyai fungsi yang bertanggungjawab untuk pergerakan menegak dan mendatar, kita boleh mewujudkan fungsi utama yang bertanggungjawab untuk pergerakan.

Fungsi ini mengambil nilai berapa banyak untuk menggerakkan objek, kelajuan semasa objek, kedudukan semasa bersama-sama dengan sisa terapung, objek AABB, dan kedudukan kedudukan.

Perkara pertama yang akan kami lakukan di sini ialah menambah nilai kepada selebihnya, sehingga dalam baki kita mempunyai nilai penuh tentang berapa banyak watak kita harus bergerak.

Oleh kerana kita akan memanggil fungsi MoveX dan MoveY dari yang satu ini, kita perlu lulus bahagian atas kanan dan bawah kiri AABB, jadi mari kita mengira mereka sekarang.

Kita juga perlu mendapatkan vektor langkah. Ia akan digunakan sebagai arah di mana kita akan memindahkan objek kita.

Sekarang mari kita lihat berapa piksel yang kita perlukan untuk bergerak. Kita perlu pusingan yang selebihnya, kerana kita akan sentiasa bergerak dengan nombor integer, dan kemudian kita perlu tolak nilai itu dari bakinya.

Sekarang mari kita berpecah pergerakan menjadi empat kes, bergantung pada nilai vektor bergerak kita. Jika nilai x dan y vektor bergerak adalah sama dengan 0, tidak ada pergerakan yang akan dibuat, jadi kita boleh kembali.

Jika hanya nilai y ialah 0, kita akan bergerak hanya mendatar.

Jika hanya nilai x ialah 0, kita akan bergerak hanya secara menegak.

Jika kita perlu memindahkan kedua-dua paksi x dan y, kita perlu bergerak dalam corak yang dijelaskan sebelum ini. Pertama, mari kita bandingkan nisbah laju.

Mari kita juga menyatakan penumpuk menegak yang akan memegang berapa piksel yang kita perlukan untuk bergerak secara menegak dengan setiap gelung.

Keadaan untuk berhenti bergerak adalah sama ada kita menghadapi halangan pada mana-mana paksi atau objek itu dipindahkan oleh vektor bergerak keseluruhan.

Kini mari kita mengira berapa piksel yang secara menegak kita harus menggerakkan objek.

Untuk pergerakan ini, kita mula-mula bergerak satu langkah mendatar.

Dan selepas ini kita boleh bergerak secara menegak. Di sini kita tahu bahawa kita perlu menggerakkan objek dengan nilai yang terdapat dalam vertAccum, tetapi jika terdapat sebarang ketidaktepatan, jika kita berpindah ke paksi X, kita juga perlu bergerak sepanjang paksi Y.

Semua dalam semua, fungsi sepatutnya seperti ini:

Sekarang kita boleh menggunakan fungsi yang telah kami bina untuk menyusun fungsi UpdatePhysics utama kami.

Membina Fungsi Kemaskini Fizik

Pertama sekali, kami ingin mengemas kini kedudukan kedudukan, jadi semua data bingkai sebelumnya pergi ke pembolehubah yang mencukupi, dan data bingkai semasa diset semula.

Sekarang mari kita kemas kini keadaan perlanggaran objek kita. Kami melakukan ini supaya sebelum kami memindahkan objek kami, kami telah mengemas kini data sama ada ia berada di atas tanah atau menolak mana-mana jubin lain. Biasanya data bingkai sebelumnya masih akan dikemas kini jika medan itu tidak dapat diubah dan objek lain tidak dapat bergerak yang ini, tetapi di sini kita mengandaikan bahawa mana-mana ini boleh berlaku.

CollidesWithTiles hanya memanggil semua fungsi perlanggaran yang telah kami tulis.

Kemudian kemas kini kelajuan.

Dan kemas kini kedudukan. Pertama, selamatkan yang lama.

Kira yang baru.

Kira offset antara kedua-dua.

Sekarang, sekiranya offset itu bukan sifar, kita boleh memanggil fungsi Pindah kami.

Akhirnya, kemas kini AABB objek dan keadaan kedudukannya.

Itu sahaja! Sistem ini kini menggantikan yang lebih tua, hasilnya harus sama, walaupun cara kita melakukannya agak berbeza.

Rangkuman

Itu sahaja untuk meletakkan dasar untuk cerun, jadi apa yang tersisa adalah untuk mengisi jurang dalam cek perlanggaran kami! Kami telah melakukan sebahagian besar kerja caching kami di sini dan menghapuskan banyak geometri yang kompleks dengan melaksanakan integrasi pergerakan satu pixel.

Ini akan menjadikan pelaksanaan cerun mudah, berbanding dengan apa yang perlu kita lakukan sebaliknya. Kami akan menyelesaikan kerja di bahagian seterusnya siri ini.

Terima kasih untuk membaca!

Advertisement
Advertisement
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.