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

Menggunakan Corak Reka Bentuk Komposit untuk Sistem Atribut RPG

by
Difficulty:IntermediateLength:LongLanguages:

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

Perisikan, Tenaga Kerja, Karisma, Kebijaksanaan: selain menjadi kualiti penting yang perlu anda miliki sebagai pemaju permainan, ini juga merupakan ciri umum yang digunakan dalam RPG. Mengira nilai atribut tersebut -- menggunakan bonus masa dan mengambil kira kesan barangan yang dilengkapi -- boleh menjadi rumit. Dalam tutorial ini, saya akan menunjukkan kepada anda cara menggunakan Corak Komposit yang diubahsuai sedikit untuk mengendalikan ini dengan cepat.

Nota: Walaupun tutorial ini ditulis menggunakan Flash dan AS3, anda harus menggunakan teknik dan konsep yang sama dalam hampir semua persekitaran pembangunan permainan.


Pengenalan

Sistem atribut sangat biasa digunakan dalam RPG untuk mengukur kekuatan, kelemahan, dan kebolehan watak-watak. Jika anda tidak kenal dengan mereka, skim halaman Wikipedia untuk gambaran yang baik.

Untuk menjadikannya lebih dinamik dan menarik, pemaju sering memperbaiki sistem ini dengan menambah kemahiran, item dan perkara lain yang mempengaruhi sifat. Jika anda ingin melakukan ini, anda memerlukan sistem yang baik yang boleh mengira atribut akhir (mengambil kira setiap kesan lain) dan mengendalikan penambahan atau penghapusan pelbagai jenis bonus.

Dalam tutorial ini, kami akan meneroka penyelesaian untuk masalah ini dengan menggunakan versi yang sedikit diubahsuai dari corak reka bentuk Komposit. Penyelesaian kami akan dapat mengendalikan bonus, dan akan mengendalikan setiap set ciri yang anda tentukan.


Apa itu Corak Komposit?

Bahagian ini merupakan gambaran keseluruhan corak reka bentuk Komposit. Jika anda sudah biasa dengannya, anda mungkin mahu melangkau ke Pemodelan Masalah Kami.

Corak Komposit adalah corak rekabentuk (template reka bentuk umum yang boleh digunakan, boleh diguna semula) untuk membahagi sesuatu yang besar ke objek yang lebih kecil, untuk menghasilkan kumpulan yang lebih besar dengan mengendalikan objek kecil sahaja. Ia memudahkan untuk memecahkan ketulan besar maklumat ke dalam lebih kecil, lebih mudah dirawat, ketulan. Pada dasarnya, ia merupakan templat untuk menggunakan sekumpulan objek tertentu seolah-olah ia satu objek itu sendiri.

Kami akan menggunakan contoh yang banyak digunakan untuk menggambarkan ini: fikirkan aplikasi lukisan mudah. Anda mahu membiarkan anda membuat segitiga, dataran dan bulatan, dan merawatnya secara berbeza. Tetapi anda juga mahu ia dapat mengendalikan kumpulan lukisan. Bagaimanakah kita dapat dengan mudah melakukannya?

Corak Komposit adalah calon yang sempurna untuk tugas ini. Dengan merawat "kumpulan lukisan" sebagai lukisan itu sendiri, seseorang boleh dengan mudah menambah apa-apa lukisan di dalam kumpulan ini, dan kumpulan secara keseluruhannya akan tetap dilihat sebagai lukisan tunggal.

Dari segi pengaturcaraan, kita akan mempunyai satu kelas asas, Lukisan, yang mempunyai tingkah laku lalai lukisan (anda boleh memindahkannya, menukar lapisan, memutarnya, dan sebagainya), dan empat subkelas, Segitiga, Square, Lingkaran dan Kumpulan.

Dalam kes ini, tiga kelas pertama akan mempunyai tingkah laku yang mudah, hanya memerlukan input pengguna bagi atribut asas setiap bentuk. Kelas Grup, bagaimanapun, akan memiliki metode untuk menambah dan menghapus bentuk, serta melakukan operasi pada semua dari mereka (misalnya, mengubah warna semua bentuk dalam kelompok sekaligus). Semua empat subclass akan tetap dianggap sebagai Drawing, jadi anda tidak perlu bimbang tentang menambahkan kod tertentu untuk apabila anda ingin beroperasi pada kumpulan.

Untuk mengambil ini sebagai representasi yang lebih baik, kita boleh melihat setiap lukisan sebagai nod dalam pokok. Setiap nod adalah daun, kecuali kumpulan nod, yang boleh mempunyai anak-anak -- yang kemudiannya dilukis dalam kumpulan itu.


Perwakilan Visual Corak

Melekat dengan contoh apl lukisan, ini merupakan gambaran visual dari "aplikasi lukisan" yang kami fikirkan. Perhatikan bahawa terdapat tiga lukisan dalam imej: segitiga, persegi dan kumpulan yang terdiri daripada bulatan dan persegi:

Using the Composite Design Pattern for an RPG Attributes System

Dan ini adalah perwakilan pokok adegan semasa (akar adalah peringkat permohonan lukisan):

Using the Composite Design Pattern for an RPG Attributes System

Bagaimana jika kita mahu menambah lukisan lain, iaitu kumpulan segitiga dan bulatan, di dalam kumpulan yang kita ada sekarang? Kami hanya akan menambahnya kerana kami akan menambah apa-apa lukisan dalam kumpulan. Inilah gambaran visual seperti:

Using the Composite Design Pattern for an RPG Attributes System

Dan inilah pokok yang akan menjadi:

Using the Composite Design Pattern for an RPG Attributes System

Sekarang, bayangkan kita akan membina penyelesaian kepada masalah atribut yang kita ada. Jelas sekali, kita tidak akan mempunyai perwakilan visual langsung (kita hanya dapat melihat hasil akhir, iaitu atribut yang dikira berdasarkan nilai mentah dan bonus), jadi kita akan mula berfikir dalam Corak Komposit dengan perwakilan pokok .


Pemodelan Masalah Kita

Untuk memungkinkan untuk memodelkan ciri-ciri kita di dalam pokok, kita perlu memecahkan setiap sifat ke bahagian terkecil yang kita boleh.

Kami tahu kami mempunyai bonus, yang boleh menambahkan nilai mentah kepada atribut, atau meningkatkannya dengan peratusan. Terdapat bonus yang menambah sifat, dan yang lain dikira setelah semua bonus pertama digunakan (bonus dari kemahiran, sebagai contoh).

Oleh itu, kita boleh:

  • Boneka mentah (ditambah kepada nilai mentah atribut)
  • Bonus akhir (ditambah kepada atribut selepas semua yang telah dikira)

Anda mungkin punya perasan bahawa kami tidak memisahkan bonus yang menambah nilai kepada atribut dari bonus yang meningkatkan sifat dengan peratusan. Ini kerana kami memodelkan setiap bonus untuk dapat menukar sama ada pada masa yang sama. Ini bermakna kita boleh mempunyai bonus yang menambah 5 nilai dan meningkatkan atribut sebanyak 10%. Ini semua akan ditangani dalam kod.

Kedua-dua jenis bonus ini hanya daun pokok kita. Mereka sama seperti kelas Segitiga, Square dan Circle dalam contoh kami dari sebelumnya.

Kami masih belum membuat entiti yang akan berfungsi sebagai satu kumpulan. Entiti-entiti ini akan menjadi sifat mereka sendiri! Kelas Kumpulan dalam contoh kami hanya akan menjadi atribut itu sendiri. Jadi kami akan mempunyai kelas Atribut yang akan berkelakuan seperti mana-mana atribut.

Inilah bagaimana pokok atribut boleh dilihat:

Using the Composite Design Pattern for an RPG Attributes System

Sekarang segala-galanya diputuskan, adakah kita akan memulakan kod kami?


Mewujudkan Kelas Asas

Kami akan menggunakan ActionScript 3.0 sebagai bahasa untuk kod dalam tutorial ini, tetapi jangan bimbang! Kod ini akan diberi ulasan sepenuhnya selepas itu, dan semua yang unik untuk bahasa (dan platform Flash) akan dijelaskan dan alternatif akan disediakan  -- jadi jika anda sudah biasa dengan bahasa OOP, anda akan dapat mengikuti ini tutorial tanpa masalah.

Kelas pertama yang perlu kita buat adalah kelas asas untuk sebarang atribut dan bonus. Fail itu akan dipanggil BaseAttribute.as, dan menciptanya sangat mudah. Berikut ialah kod tersebut, dengan ulasan selepas itu:

Seperti yang anda dapat lihat, perkara-perkara yang sangat mudah di kelas asas ini. Kami hanya mencipta medan _value dan _multiplier, menyerahkannya dalam pembina, dan membuat dua kaedah pengambilalihan, satu untuk setiap medan.

Sekarang kita perlu membuat kelas RawBonus dan FinalBonus. Ini hanya subclass of BaseAttribute, dengan tiada tambah. Anda boleh mengembangkannya sebanyak yang anda mahu, tetapi buat masa ini kami hanya akan membuat dua subclass kosong BaseAttribute:

RawBonus.as:

FinalBonus.as:

Seperti yang anda dapat lihat, kelas-kelas ini tidak mempunyai apa-apa di dalamnya tetapi pembina.


Kelas Atribut

Kelas Atribut akan sama dengan kumpulan dalam Corak Komposit. Ia boleh memegang apa-apa bonus mentah atau akhir, dan akan mempunyai kaedah untuk mengira nilai akhir atribut. Oleh kerana ia adalah subclass BaseAttribute, medan _baseValue kelas akan menjadi nilai permulaan atribut.

Apabila mencipta kelas, kita akan menghadapi masalah apabila mengira nilai akhir atribut: kerana kita tidak memisahkan bonus mentah dari bonus akhir, tidak ada cara kita boleh mengira nilai akhir, kerana kita tidak tahu kapan memohon setiap bonus.

Ini boleh diselesaikan dengan membuat sedikit pengubahsuaian kepada Corak Komposit asas. Daripada menambah kanak-kanak ke "bekas" yang sama dalam kumpulan, kami akan membuat dua "bekas", satu untuk bonus mentah dan lain-lain untuk bonus akhir. Setiap bonus masih akan menjadi kanak-kanak Atribut, tetapi akan berada di tempat yang berbeza untuk membolehkan pengiraan nilai akhir atribut.

Dengan menerangkannya, mari kita dapatkan kod!

Kaedah addRawBonus(), addFinalBonus(), removeRawBonus() dan removeFinalBonus() sangat jelas. Apa yang mereka lakukan ialah menambahkan atau mengalih keluar jenis bonus khusus mereka ke atau dari array yang mengandungi semua bonus jenis itu.

Bahagian yang rumit adalah kaedah calculateValue (). Pertama, ia merangkumi semua nilai yang bonus mentah menambah sifat, dan juga merangkum semua pengganda. Selepas itu, ia menambahkan jumlah semua nilai bonus mentah kepada atribut permulaan, dan kemudian menggunakan pengganda. Kemudian, ia melakukan langkah yang sama untuk bonus akhir, tetapi kali ini memohon nilai-nilai dan pengganda kepada nilai atribut terakhir yang dikira setengah nilai.

Dan kita sudah selesai dengan struktur! Semak langkah seterusnya untuk melihat bagaimana anda akan menggunakan dan memanjangkannya.


Kelakuan Tambahan: Bonus Berkala

Dalam struktur semasa kami, kami hanya mempunyai bonus mentah dan muktamad yang sederhana, yang pada masa ini tidak mempunyai perbezaan sama sekali. Dalam langkah ini, kami akan menambah tingkah laku tambahan kepada kelas FinalBonus, untuk menjadikannya kelihatan seperti bonus yang akan diterapkan melalui kemahiran aktif dalam permainan.

Oleh kerana, seperti namanya, kemahiran tersebut hanya aktif untuk jangka waktu tertentu, kami akan menambah tingkah laku masa pada bonus akhir. Bonus mentah boleh digunakan, sebagai contoh, untuk bonus ditambah melalui peralatan.

Untuk melakukan ini, kami akan menggunakan kelas Timer. Kelas ini berasal dari ActionScript 3.0, dan semua itu berlaku seperti pemasa, bermula pada 0 saat dan kemudian memanggil fungsi tertentu selepas masa yang ditetapkan, menetapkan semula kepada 0 dan memulakan kiraan semula, sehingga ia mencapai yang dinyatakan bilangan tuduhan lagi. Jika anda tidak menyatakannya, Timer akan terus berlari sehingga anda menghentikannya. Anda boleh memilih apabila pemasa bermula dan apabila ia berhenti. Anda boleh meniru kelakuannya dengan menggunakan sistem waktu bahasa anda dengan kod tambahan yang sesuai, jika diperlukan.

Mari melompat ke kod!

Dalam pembina, perbezaan pertama adalah bahawa bonus akhir kini memerlukan parameter time, yang akan menunjukkan berapa lama mereka bertahan. Di dalam pembina, kami membuat Timer untuk jumlah masa tersebut (dengan mengandaikan masa dalam milisaat), dan menambah pendengar acara itu.

(Pendengar acara pada dasarnya adalah apa yang akan menjadikan pemasa memanggil fungsi yang betul apabila ia mencapai tempoh waktu tertentu - dalam kes ini, fungsi yang dipanggil adalah onTimerEnd().)

Perhatikan bahawa kami belum memulakan pemasa lagi. Ini dilakukan dalam kaedah startTimer(), yang juga memerlukan parameter, ibu bapa, yang mesti menjadi Atribut. Fungsi ini memerlukan atribut yang menambah bonus untuk memanggil fungsi itu untuk mengaktifkannya; Sebaliknya, ini memulakan pemasa dan memberitahu bonus yang mana contohnya untuk meminta untuk mengeluarkan bonus apabila pemasa telah mencapai hadnya.

Bahagian penyingkiran dilakukan dalam kaedah onTimerEnd(), yang hanya akan meminta ibu bapa yang ditetapkan untuk mengalih keluarnya dan menghentikan pemasa.

Sekarang, kita boleh menggunakan bonus akhir sebagai bonus masa, menunjukkan bahawa ia akan bertahan hanya untuk masa tertentu.


Kelakuan Tambahan: Atribut Tergantung

Satu perkara yang biasa dilihat dalam permainan RPG adalah sifat yang bergantung pada orang lain. Sebagai contohnya, kita ambil atribut "kelajuan serangan". Ia bukan hanya bergantung pada jenis senjata yang anda gunakan, tetapi hampir selalu pada ketangkasan karakter juga.

Dalam sistem semasa kami, kami hanya membenarkan bonus untuk menjadi anak-anak dari keadaan Attribut. Tetapi dalam contoh kami, kami perlu membiarkan atribut menjadi anak dari atribut yang lain. Bagaimana kita boleh melakukannya? Kita boleh membuat subclass Atribut, dipanggil DependantAttribute, dan memberikan subclass ini semua tingkah laku yang kita perlukan.

Menambah atribut sebagai kanak-kanak adalah sangat mudah: semua yang perlu kita lakukan ialah mewujudkan satu lagi array untuk memegang atribut, dan menambah kod tertentu untuk mengira atribut akhir. Oleh kerana kita tidak tahu sama ada setiap atribut akan dikira dengan cara yang sama (anda mungkin mahu terlebih dahulu menggunakan ketangkasan untuk menukar kelajuan serangan, dan kemudian menyemak bonus, tetapi menggunakan bonus pertama untuk mengubah serangan ajaib dan kemudian gunakan, contohnya, kecerdasan), kami juga perlu memisahkan pengiraan atribut akhir dalam kelas Atribut dalam pelbagai fungsi. Mari buat yang pertama.

Di Attribute.as:

Seperti yang anda dapat lihat dengan baris yang diserlahkan, semua yang kami lakukan adalah mencipta applyRawBonuses() dan menerapkanFinalBonuses() dan memanggil mereka semasa mengira atribut akhir dalam mengiraValue(). Kami juga membuat _finalValue dilindungi, jadi kita boleh mengubahnya dalam subclass.

Sekarang, semuanya telah ditetapkan untuk kami membuat kelas DependantAttribute! Inilah kodanya:

Di dalam kelas ini, fungsi addAttribute() dan removeAttribute() perlu diketahui oleh anda. Anda perlu memberi perhatian kepada fungsi calculumValue() yang overriden. Di sini, kita tidak menggunakan atribut untuk mengira nilai akhir - anda perlu melakukannya untuk setiap atribut yang bergantung!

Ini adalah contoh bagaimana anda akan melakukannya untuk mengira kelajuan serangan:

Di dalam kelas ini, kami menganggap bahawa anda telah menambahkan sifat ketangkasan yang sudah ada sebagai anak AttackSpeed, dan ia adalah yang pertama dalam array _otherAttributes (itu banyak andaian untuk membuat, semak kesimpulan untuk maklumat lanjut). Setelah mengambil ketangkasan, kami hanya menggunakannya untuk menambah nilai akhir kelajuan serangan.


Kesimpulan

Dengan semuanya selesai, bagaimana anda akan menggunakan struktur ini dalam permainan? Ia sangat mudah: semua yang perlu anda lakukan ialah mencipta atribut yang berbeza dan menetapkan masing-masing contoh Atribut. Selepas itu, semuanya mengenai menambah dan mengeluarkan bonus kepadanya melalui kaedah yang sudah dibuat.

Apabila sesuatu barang dilengkapkan atau digunakan dan ia menambahkan bonus kepada sebarang atribut, anda perlu membuat contoh bonus bagi jenis yang sepadan dan kemudian tambahnya pada atribut watak itu. Selepas itu, hanya mengira semula nilai atribut akhir.

Anda juga boleh mengembangkan pelbagai jenis bonus yang tersedia. Sebagai contoh, anda boleh mempunyai bonus yang mengubah nilai tambah atau pengganda dari masa ke masa. Anda juga boleh menggunakan bonus negatif (yang mana kod semasa boleh dikendalikan).

Dengan mana-mana sistem, selalu ada lagi yang anda boleh tambah. Berikut adalah beberapa peningkatan yang dicadangkan yang anda boleh buat:

  • Kenal pasti atribut mengikut nama
  • Buat sistem "berpusat" untuk menguruskan atribut
  • Optimalkan prestasi (petunjuk: anda tidak perlu mengira nilai akhir sepenuhnya)
  • Jadikan beberapa bonus untuk melemahkan atau menguatkan bonus lain

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.