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

A * Pathfinding untuk Platformer Berbasis 2D Grid: Ledge Grabbing

by
Difficulty:IntermediateLength:LongLanguages:
This post is part of a series called How to Adapt A* Pathfinding to a 2D Grid-Based Platformer.
A* Pathfinding for 2D Grid-Based Platformers: Making a Bot Follow the Path

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

Dalam bahagian ini kami menyesuaikan algoritma A * pathfinding kepada platformer, kami akan memperkenalkan mekanik baru kepada watak: merebut langkan. Kami juga akan membuat perubahan yang sesuai untuk kedua-dua algoritma pathfinding dan bot AI, supaya mereka dapat memanfaatkan mobiliti yang lebih baik.

Demo

Anda boleh memainkan demo Unity, atau versi WebGL (16MB), untuk melihat keputusan akhir dalam tindakan. Gunakan WASD untuk menggerakkan watak, klik kiri di tempat untuk mencari laluan yang boleh anda ikuti untuk sampai ke sana, klik kanan sel untuk bertukar-tukar tanah pada titik itu, klik tengah untuk meletakkan platform sehala, dan klik -dan seret slider untuk menukar nilai mereka.

Mekanik Grabbing Ledge

Gambaran Keseluruhan Kawalan

Mari kita lihat dulu cara kerja mekanik meraih tangan dalam demo untuk mendapatkan sedikit pemahaman mengenai bagaimana kita perlu mengubah algoritma laluan laluan untuk mengambil mekanik baru ini.

Kawalan untuk meraih tebing cukup sederhana: jika wataknya betul-betul bersebelahan tebing sementara jatuh, dan pemain menekan kekunci arah kiri atau kanan untuk bergerak ke arah tebing itu, maka apabila watak berada di kedudukan yang betul, ia akan merebut tebing.

Setelah wataknya meraih langkan, pemain mempunyai dua pilihan: mereka boleh melompat atau turun. Melompat berfungsi seperti biasa; pemain menekan kekunci melompat dan daya melompat adalah sama dengan gaya yang digunakan apabila melompat dari tanah. Turunkan dilakukan dengan menekan butang bawah (S), atau kunci arah yang menunjuk dari sudut.

Melaksanakan Kawalan

Mari kita lihat bagaimana kawalan mercu baja berfungsi dalam kod. Perkara pertama di sini adalah untuk mengesan sama ada tongkat di sebelah kiri atau di sebelah kanan watak:

Kita boleh menggunakan maklumat itu untuk menentukan sama ada watak itu sepatutnya melepaskan langkan. Seperti yang dapat anda lihat, untuk menurunkan, pemain perlu sama ada:

  • tekan butang bawah,
  • tekan butang kiri apabila kita meraih langkan di sebelah kanan, atau
  • tekan butang kanan apabila kita meraih langkan di sebelah kiri.

Terdapat bantahan kecil di sini. Pertimbangkan keadaan apabila kita memegang butang bawah dan butang yang betul, apabila wataknya memegang bujur di sebelah kanan. Ini akan mengakibatkan keadaan berikut:

Masalahnya di sini ialah watak merebut langkan dengan serta-merta selepas ia melepaskannya.

Satu penyelesaian mudah ini adalah untuk mengunci pergerakan ke arah bingkai untuk beberapa bingkai selepas kami menurunkan tebing. Inilah coretan berikut:

Selepas ini, kita menukar keadaan watak untuk Lompat, yang akan mengendalikan fizik lompat:

Akhir sekali, jika watak itu tidak jatuh dari langkan, kita periksa sama ada kunci melompat telah ditekan; jika ya, kami menetapkan kelajuan menegak lompat dan menukar keadaan:

Mengesan Titik Grub Ledge

Mari lihat bagaimana kita menentukan sama ada langkan boleh ditangkap. Kami menggunakan beberapa hotspot di sekitar tepi watak:

Kontur kuning mewakili batas karakter. Segmen merah mewakili sensor dinding; ini digunakan untuk mengendalikan fizik watak. Segmen biru mewakili di mana watak kita boleh merebut langkan.

Untuk menentukan watak itu boleh merebut langkan, kod kami sentiasa memeriksa sisi yang sedang bergerak ke arahnya. Ia mencari jubin kosong di bahagian atas segmen biru, dan kemudian sebuah jubin pepejal di bawahnya yang mana watak itu boleh dimakan.

Nota: merebut langkan akan terkunci rapat jika aksaranya melompat. Ini boleh dilihat dengan mudah dalam demo dan dalam animasi di bahagian Gambaran Keseluruhan Kawalan.

Masalah utama dengan kaedah ini ialah jika watak kita jatuh pada kelajuan tinggi, akan mudah melepaskan tetingkap di mana ia boleh meraih sebatang tebing. Kita boleh menyelesaikannya dengan melihat semua jubin bermula dari kedudukan bingkai sebelumnya ke bingkai semasa mencari mana-mana jubin kosong di atas yang padat. Sekiranya satu jubin tersebut dijumpai, maka ia boleh diambil.

Sekarang kita telah membaik pulih bagaimana kerja merengkuh mekanik, mari kita lihat cara untuk memasukkannya ke dalam algoritma pathfinding kita.

Perubahan Pathfinder

Jadikan Ia Kemungkinan untuk Menghidupkan Ledge Merebut dan Mati

Pertama sekali, mari kita tambahkan parameter baru ke fungsi FindPath kami yang menunjukkan sama ada penanda laluan itu harus mempertimbangkan tajuk meraih. Kami akan namakannya menggunakanLedges:

Mengesan Ledge Grab Nodes

Keadaan

Sekarang kita perlu mengubah suai fungsi untuk mengesan sama ada nod tertentu boleh digunakan untuk meraih langkan. Kita boleh lakukannya setelah memeriksa sama ada nod adalah nod "di atas tanah" atau nod "di siling", kerana dalam kedua-dua kes ia tidak boleh digunakan untuk meraih tebing.

Baiklah: sekarang kita perlu tahu apabila nod harus dianggap nod meraih langkan. Untuk kejayaan, inilah gambarajah yang menunjukkan beberapa contoh jawatan:

... dan inilah caranya bagaimana terlihat di dalam game:

Ciri-ciri watak sprite adalah diregangkan untuk menunjukkan bagaimana ini kelihatan dengan watak-watak yang berbeza.

Sel merah mewakili nod yang diperiksa; bersama-sama dengan sel hijau, mereka mewakili watak dalam algoritma kami. Dua keadaan teratas menunjukkan watak 2x2 menangkap huruf di kiri dan kanan masing-masing. Bahagian bawah menunjukkan perkara yang sama, tetapi saiz watak di sini ialah 1x3 dan bukannya 2x2.

Seperti yang anda lihat, ia haruslah mudah untuk mengesan kes-kes ini dalam algoritma. Keadaan untuk nod merebut bijirin adalah seperti berikut:

  1. Terdapat jubin pepejal bersebelahan dengan jubin watak kanan atas/kanan kiri.
  2. Terdapat jubin kosong di atas jubin pepejal yang dijumpai.
  3. Tiada jubin pepejal di bawah watak (tidak perlu merebut tiang jika di atas tanah).

Perhatikan bahawa keadaan ketiga sudah dijaga, kerana kita periksa nikel merebut langkan hanya jika wataknya tidak di tanah.

Pertama sekali, mari kita semak sama ada kita sebenarnya mahu mengesan langkan baja:

Sekarang mari kita semak ada terdapat jubin di sebelah kanan nod aksara yang paling kanan:

Dan kemudian, jika di atas jubin terdapat ruang kosong:

Sekarang kita perlu melakukan perkara yang sama untuk sebelah kiri:

Terdapat satu lagi perkara yang kita boleh lakukan secara pilihan, yang melumpuhkan mencari nod meraih langkan jika kelajuan jatuh terlalu tinggi, maka jalan itu tidak mengembalikan beberapa posisi meraih tebal ekstrem yang sukar untuk diikuti oleh bot:

Setelah semua ini, kami dapat memastikan bahawa nod yang dijumpai adalah nod merebut langkan.

Menambah Nod Istimewa

Apa yang kita dapat apabila kita mencari simpul meraih langsir? Kita perlu menetapkan nilai lompatnya.

Ingat, nilai lompat adalah nombor yang mewakili fasa lompat watak itu, jika ia mencapai sel ini. Sekiranya anda memerlukan rekap bagaimana algoritma berfungsi, lihat lagi artikel teori.

Nampaknya semua yang perlu kita lakukan adalah untuk menetapkan nilai lompatan nod ke 0, kerana dari sudut meraih titik watak itu dapat menetapkan semula lompatan secara berkesan, seolah-olah ia berada di tanah-tetapi ada beberapa pasang untuk dipertimbangkan di sini.

  • Pertama, lebih baik jika kita dapat melihat sepintas lalu sama ada nod adalah simpul merebut simpang atau tidak: ini akan sangat berguna apabila membuat tingkah laku bot dan juga apabila menapis nod.
  • Kedua, biasanya melompat dari tanah boleh dilaksanakan dari mana-mana titik yang paling sesuai untuk jubin tertentu, tetapi apabila melompat dari merebut langkan, watak itu terjebak ke kedudukan tertentu dan tidak dapat melakukan apa-apa tetapi mula jatuh atau melompat ke atas.

Memandangkan kaveat tersebut, kami akan menambah nilai lompat khas untuk nod merebut bijirin. Tidak semestinya nilai ini, tetapi ia adalah idea yang baik untuk menjadikannya negatif, kerana itu akan mengurangkan peluang kita untuk menyalah tafsir nod tersebut.

Sekarang mari kita tetapkan nilai ini apabila kita mengesan simpul merebut nod:

Membuat cLedgeGrabJumpValue negatif akan memberi kesan ke atas pengiraan kos nod-ia akan membuat algoritma lebih suka menggunakan langkan daripada melangkau mereka. Terdapat dua perkara yang perlu diperhatikan di sini:

  1. Titik lekuk tongkang menawarkan kemungkinan pergerakan yang lebih besar daripada sebarang nod dalam udara lain, kerana watak itu boleh melompat semula dengan menggunakannya; dari sudut pandangan ini, adalah perkara yang baik bahawa nod ini akan lebih murah daripada yang lain.
  2. Mengambil terlalu banyak bumbung seringkali membawa kepada pergerakan yang tidak wajar, kerana biasanya pemain tidak menggunakan cengkaman langsir melainkan jika mereka perlu untuk sampai ke suatu tempat.

Dalam animasi di atas, anda dapat melihat perbezaan antara bergerak naik apabila tiang lebih disukai dan apabila ia tidak.

Buat masa ini kita akan meninggalkan pengiraan kos seperti itu, tetapi agak mudah untuk mengubahnya, untuk menjadikan nod langsir lebih mahal.

Ubah Nilai Lompat Apabila Melompat atau Menurun Daripada Ledge

Sekarang kita perlu menyesuaikan nilai lompatan untuk nod yang bermula dari titik merebut langkan. Kita perlu melakukan ini kerana melompat dari kedudukan merebut langkan agak berbeza daripada melompat dari tanah. Terdapat kebebasan yang sangat sedikit apabila melompat dari tebing, kerana watak itu tetap pada titik tertentu.

Ketika di lapangan, watak itu boleh bergerak dengan bebas ke kiri atau kanan dan melompat pada momen yang paling sesuai.

Pertama, mari kita tetapkan kes apabila watak itu turun dari merebut langkan:

Seperti yang anda dapat lihat, panjang lompat baru sedikit lebih besar jika watak itu jatuh dari tebing: dengan cara ini kita mengimbangi kekurangan kebolehlaksanaan ketika meraih benteng, yang akan menghasilkan kelajuan penegak lebih tinggi sebelum pemain dapat mencapai nod lain .

Berikut adalah kes di mana watak jatuh ke satu pihak dari meraih sebatang langsir:

Apa yang perlu kita lakukan ialah menetapkan nilai lompat kepada nilai jatuh.

Abaikan Lebih banyak Nod

Kita perlu menambah beberapa syarat tambahan apabila kita perlu mengabaikan nod.

Pertama sekali, apabila kita melompat dari kedudukan merebut langkan, kita perlu naik, tidak ke sebelah. Ini berfungsi sama dengan hanya melompat dari tanah. Kelajuan menegak adalah jauh lebih tinggi daripada kelajuan mendatar yang mungkin pada masa ini, dan kita perlu model fakta ini dalam algoritma:

Sekiranya kita mahu membenarkan jatuh dari tebing ke seberang seperti ini:

Kemudian kita perlu mengedit keadaan yang tidak membenarkan pergerakan mendatar ketika nilai lompat ganjil. Itulah sebabnya, pada saat ini, nilai grabbed khas kami bersamaan dengan -9, jadi hanya sesuai untuk mengecualikan semua nombor negatif dari keadaan ini.

Kemas kini Penapis Nod

Akhirnya, mari beralih kepada penapisan nod. Apa yang perlu kita lakukan di sini adalah untuk menambah syarat untuk menangkap nod merangsang, supaya kita tidak menyaringnya. Kami hanya perlu menyemak sama ada nilai lompat nod adalah sama dengan cLedgeGrabJumpValue:

Seluruh penapisan kelihatan seperti ini sekarang:

Itu sahaja-ini adalah semua perubahan yang perlu kita buat untuk mengemas kini algoritma pathfinding.

Bot Perubahan

Sekarang jalan kami menunjukkan tempat di mana watak boleh merebut langkan, mari kita mengubah suai tingkah laku bot supaya ia menggunakan data ini.

Berhenti Mengira semula mencapaiX dan mencapaiY

Pertama sekali, untuk membuat perkara yang lebih jelas dalam bot, mari kita kemas kini fungsi GetContext(). Masalah semasa dengannya ialah nilai mencapaiX dan mencapaiY nilai-nilai yang sentiasa dikira semula, yang menghilangkan beberapa maklumat mengenai konteksnya. Nilai-nilai ini digunakan untuk melihat sama ada bot telah mencapai sasaran nod pada x-dan y-paksi, masing-masing. (Jika anda memerlukan penyegar semula tentang cara kerja ini, lihat tutorial saya mengenai pengekodan bot.)

Mari kita tukar ini supaya jika watak mencapai nod pada paksi x- atau y-, maka nilai-nilai ini tetap benar selagi kita tidak bergerak ke nod seterusnya.

Untuk membuat ini mungkin, kami perlu mengisytiharkan mencapaiX dan mencapaiY SAYA sebagai ahli kelas:

Ini bermakna kita tidak lagi perlu menyampaikannya kepada fungsi GetContext():

Dengan perubahan ini, kita juga perlu menetapkan semula pembolehubah secara manual apabila kita mula bergerak ke arah nod seterusnya. Kemunculan pertama adalah ketika kita baru saja menemukan jalan dan akan bergerak ke arah node pertama:

Yang kedua adalah apabila kita telah mencapai nod sasaran semasa dan ingin bergerak ke arah seterusnya:

Untuk berhenti mengukur semula pembolehubah, kita perlu menggantikan baris berikut:

... dengan ini, yang akan mengesan sama ada kita telah mencapai nod pada paksi hanya jika kita belum mencapainya:

Sudah tentu, kita juga perlu mengganti setiap kejadian lain mencapaiX dan mencapaiY dengan versi baru yang diisytiharkan mReachedNodeX dan mReachedNodeY.

Lihat Jika Karakter Perlu Merebut Ledakan

Marilah kita mengisytiharkan pemboleh ubah beberapa yang akan kita gunakan untuk menentukan sama ada bot perlu merebut langkan, dan, jika ya, yang satu:

mGrabsLedges adalah bendera yang kita lulus ke algoritma untuk membiarkannya tahu sama ada ia harus mencari laluan termasuk merebut langkan. mMustGrabLeftLedge dan mMustGrabRightLedge akan digunakan untuk menentukan sama ada simpul seterusnya adalah tebing merebut, dan sama ada bot harus merebut langkan di sebelah kiri atau ke kanan.

Apa yang ingin kita lakukan sekarang ialah mencipta satu fungsi yang, berdasarkan nod, akan dapat mengesan sama ada watak pada nod itu akan dapat merebut langkan.

Kami akan memerlukan dua fungsi untuk ini: seseorang akan memeriksa sama ada watak itu boleh meraih langkan di sebelah kiri, dan yang lain akan memeriksa sama ada watak itu boleh merebut sebatang tebing di sebelah kanan. Fungsi-fungsi ini akan berfungsi dengan cara yang sama seperti kod laluan laluan untuk mengesan tiang:

Seperti yang dapat anda lihat, kami periksa sama ada terdapat jubin pepejal di sebelah watak kami dengan jubin kosong di atasnya.

Sekarang mari kita pergi ke fungsi GetContext(), dan tentukan nilai yang sesuai untuk mMustGrabRightLedge dan mMustGrabLeftLedge. Kita perlu menetapkannya kepada benar jika watak itu sepatutnya meraih langkan pada semua (iaitu, jika mGrabsLedges adalah benar) dan jika ada langkan untuk merebut ke atas.

Perhatikan bahawa kami juga tidak mahu merapatkan tangkai jika nod destinasi berada di atas tanah.

Kemas kini Nilai Melompat

Seperti yang anda perhatikan, kedudukan watak apabila meraih langkan sedikit berbeza dengan kedudukannya apabila berdiri di bawahnya:

Kedudukan meraih langkanya sedikit lebih tinggi daripada kedudukan berdiri, walaupun watak-watak ini menduduki nod yang sama. Ini bermakna bahawa meraih tebing akan memerlukan lompatan sedikit lebih tinggi daripada hanya melompat di atas platform, dan kita perlu mengambil kira ini.

Mari lihat fungsi yang menentukan berapa lama butang lompat perlu ditekan:

Pertama sekali, kami akan mengubah keadaan awal. Bot itu sepatutnya dapat melompat, bukan hanya dari tanah, tetapi juga ketika ia meraih langkan:

Sekarang kita perlu menambah beberapa lagi bingkai jika ia melompat untuk merebut langkan. Pertama sekali, kita perlu tahu sama ada ia benar-benar boleh melakukan itu, jadi mari kita buat fungsi yang akan memberitahu kita ada watak itu boleh merebut langkan ada ke kiri atau kanan:

Sekarang mari kita tambahkan beberapa bingkai untuk melompat apabila bot perlu merebut langkan:

Seperti yang anda dapat lihat, kami memanjangkan lompatan dengan 4 bingkai, yang sepatutnya melakukan kerja dengan baik dalam kes kami.

Tetapi ada satu lagi perkara yang perlu kita ubah di sini, yang tidak banyak berkaitan dengan merebut langkan. Ia membetulkan kes apabila nod seterusnya adalah ketinggian yang sama dengan yang saat ini, tetapi tidak di atas tanah, dan nod selepas itu berada di atas yang lebih tinggi, bermakna lompatan diperlukan:

Melaksanakan Logik Pergerakan untuk Mengambil dan Mengeluarkan Lekapan

Kami akan memisahkan logik meraih langkanya ke dalam dua fasa: satu untuk ketika bot masih tidak cukup dekat dengan langkan untuk mula meraih, jadi kami hanya ingin meneruskan pergerakan seperti biasa, dan satu untuk ketika budak itu dapat dengan selamat mula bergerak ke arahnya untuk merebutnya.

Mari kita mulakan dengan mengisytiharkan Boolean yang akan menunjukkan sama ada kita sudah berpindah ke fasa kedua. Kami akan namakannya mCanGrabLedge:

Sekarang kita perlu menentukan keadaan yang akan membiarkan watak bergerak ke fasa kedua. Ini cukup mudah:

  • Bot telah mencapai nod matlamat pada paksi X.
  • Bot perlu merebut sudut kiri atau kanan.
  • Jika bot bergerak ke arah tebing, ia akan bertemu dengan dinding dan bukannya terus.

Baiklah, dua syarat pertama adalah sangat mudah untuk diperiksa sekarang kerana kami telah melakukan semua kerja yang diperlukan:

Sekarang, keadaan ketiga kita boleh berpecah menjadi dua bahagian. Yang pertama akan menjaga keadaan di mana watak bergerak ke arah tebing dari bawah, dan yang kedua dari atas. Keadaan yang kami ingin tetapkan untuk kes pertama ialah:

  • Kedudukan semasa bot lebih rendah daripada kedudukan sasaran (ia mendekati dari bawah).
  • Bahagian atas kotak sempadan karakter lebih tinggi daripada ketinggian jubin langkan.

Jika bot menghampiri dari atas, syarat-syaratnya adalah seperti berikut:

  • Kedudukan semasa bot lebih tinggi daripada kedudukan sasaran (ia mendekati dari atas).
  • Perbezaan di antara kedudukan watak dan kedudukan sasaran kurang daripada ketinggian watak.

Sekarang mari kita gabungkan semua ini dan tetapkan bendera yang menunjukkan bahawa kita dapat bergerak dengan selamat ke arah langkan:

Ada satu lagi perkara yang kita mahu lakukan di sini, dan itu adalah segera bergerak ke arah tebing:

OK, sekarang sebelum keadaan besar ini, mari buat yang lebih kecil. Ini pada asasnya akan menjadi versi yang mudah untuk pergerakan apabila bot hendak merebut langkan:

Itulah logik utama di belakang tebing, tetapi masih ada beberapa perkara yang harus dilakukan.

Kita perlu mengubah keadaan di mana kita periksa sama ada OK untuk bergerak ke nod seterusnya. Pada masa ini, keadaan seperti ini:

Kini kita perlu juga berpindah ke nod seterusnya jika bot sudah bersedia untuk merebut langkan dan kemudian melakukannya:

Mengendalikan Melompat dan Menurun Daripada Ledge

Setelah bot berada di langkan, ia sepatutnya dapat melompat seperti biasa, jadi mari tambahkan syarat tambahan untuk rutin melompat:

Perkara seterusnya yang perlu dilakukan oleh bot adalah dengan menurunkan tebing. Dengan pelaksanaan semasa ia sangat mudah: jika kita merebut langkan dan kita tidak melompat, maka jelaslah kita perlu jatuh dari situ!

Itu sahaja! Sekarang watak itu dapat dengan lancar meninggalkan kedudukan merebut langkan, tidak kira sama ada ia perlu melompat atau hanya jatuh ke bawah.

Berhenti merapatkan ledges sepanjang masa!

Pada masa ini, bot meraih setiap tebing yang boleh, tanpa mengira sama ada masuk akal untuk berbuat demikian.

Satu penyelesaian untuk ini adalah untuk memberikan kos heuristik yang besar kepada merebut langkan, jadi algoritma mengutamakan penggunaannya jika tidak perlu-tetapi ini memerlukan bot kami untuk mendapatkan sedikit maklumat lebih lanjut tentang nod. Memandangkan semua yang kami lulus ke bot adalah senarai mata, kami tidak tahu sama ada algoritma itu bermakna nod tertentu menjadi meriam atau tidak; bot itu mengandaikan bahawa sekiranya tongkat boleh ditangkap, ia sepatutnya!

Kita boleh melaksanakan penyelesaian cepat untuk tingkah laku ini: kita akan memanggil fungsi laluan laluan dua kali. Kali pertama kami akan memanggilnya dengan parameter useLedges yang ditetapkan kepada palsu, dan kali kedua dengannya ditetapkan kepada benar.

Mari kita tetapkan jalan pertama sebagai jalan yang dijumpai tanpa menggunakan sebarang merebut langkan:

Sekarang, jika laluan ini tidak batal, kita perlu menyalin hasilnya ke senarai path1 kita, kerana apabila kita memanggil penapis pathfinder kali kedua, hasil dalam laluan akan ditimpa.

Sekarang mari kita panggil petak laluan itu sekali lagi, kali ini membolehkan merebut langkan:

Kami akan menganggap bahawa jalan akhir kita akan melewati laluan dengan merebut langkan:

Dan selepas ini, mari kita mengesahkan anggapan kita. Sekiranya kami mendapati jalan tanpa merebut langkan, dan laluan itu tidak lebih lama daripada jalan yang menggunakannya, maka kami akan membuat bot itu merebut langkan.

Perhatikan bahawa kita mengukur ''panjang'' laluan dalam kiraan nod, yang boleh sekiranya tidak tepat kerana proses penapisan simpul. Ia akan menjadi lebih tepat untuk mengira, sebagai contohnya, panjang laluan Manhattan (| x1 - x2 | + |y1 - y2| daripada setiap nod), tetapi kerana kaedah keseluruhan ini lebih banyak daripada hack daripada penyelesaian sebenar, ia adalah ok untuk menggunakan jenis heuristik semacam ini.

Selebihnya fungsi berikut; laluan itu disalin ke penanda contoh bot dan ia bermula mengikutinya.

Ringkasan

Itu sahaja untuk tutorial! Seperti yang anda dapat lihat, tidak begitu sukar untuk memperluaskan algoritma untuk menambah kemungkinan pergerakan tambahan, tetapi dengan pasti ia meningkatkan kerumitan dan menambah beberapa masalah yang menyusahkan.

Sekali lagi, kekurangan ketepatan dapat menggigit kita di sini lebih dari satu kali, terutamanya ketika datang ke pergerakan jatuh-ini adalah kawasan yang memerlukan peningkatan yang paling baik, tetapi saya telah berusaha membuat algoritma sesuai dengan fisika serta saya dapat dengan set nilai semasa.

Segala-galanya, bot boleh melewati tahap dengan cara yang akan menyaingi banyak pemain, dan saya sangat gembira dengan hasil itu!

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.