Cara Mengatur Permainan Komputer (dengan Gambar)

2024 Pengarang: Robert Blare | [email protected]. Diubah suai terakhir: 2024-01-31 12:18

Adakah anda mempunyai idea untuk permainan komputer dan mahu menjadikannya nyata? Atau pernahkah anda terfikir bagaimana permainan komputer ditulis? WikiHow ini mengajar anda cara menulis tiga permainan komputer asas di Python. Anda memerlukan pemahaman asas mengenai konsep Python dan pengaturcaraan umum untuk mengembangkan permainan pertama anda.

Langkah-langkah

Bahagian 1 dari 3: Membuat Permainan Berasaskan Teks

Langkah 1. Pilih bahasa pengaturcaraan

Semua bahasa pengaturcaraan berbeza, jadi anda harus memutuskan mana yang akan digunakan untuk menulis permainan anda. Setiap bahasa pengaturcaraan utama menyokong input teks, output teks dan if-konstruksi (perkara utama yang anda perlukan untuk permainan berasaskan teks sederhana), jadi terokai pilihan dan tentukan mana yang paling anda selesa dan dedikasikan untuk belajar. Berikut adalah beberapa faktor yang perlu dipertimbangkan:

Untuk apa bahasa itu digunakan?

Beberapa bahasa pengaturcaraan, seperti JavaScript, dirancang untuk digunakan untuk web, sementara yang lain, seperti Python, C, atau C ++, dirancang untuk menjalankan program komputer. Untuk permainan anda, bertujuan untuk bahasa dengan penggunaan yang lebih luas, seperti Python, C, C ++, atau JavaScript.
Seberapa sukar untuk belajar?

Walaupun menulis program semestinya cukup mudah setelah berlatih dalam bahasa pengaturcaraan biasa (iaitu, tidak satu yang dirancang khusus untuk membingungkan seperti Malbolge), ada yang lebih ramah kepada pemula daripada yang lain. Java dan C, misalnya, memerlukan anda memahami konsep pengaturcaraan yang lebih mendalam daripada sesuatu seperti Python, yang terkenal dengan sintaks yang lebih mudah diakses dan lurus ke hadapan.
Di mana saya boleh menggunakannya?

Anda mungkin mahu semua pengguna di sistem yang berbeza, seperti Linux, Mac atau Windows, dapat memainkan permainan anda. Oleh itu, anda tidak boleh menggunakan bahasa yang hanya disokong pada beberapa sistem, seperti Visual Basic, yang hanya disokong pada Windows.

Artikel ini akan menggunakan Python untuk contoh permainan berasaskan teks, tetapi anda dapat melihat bagaimana konsep dilakukan dalam bahasa pengaturcaraan lain.

Langkah 2. Siapkan komputer anda

Dua komponen utama yang anda perlukan adalah penyunting teks, di mana anda akan menulis kod anda, dan penyusun, yang akan anda gunakan untuk mengubahnya menjadi permainan. Sekiranya anda ingin mengikuti contoh dalam artikel ini, anda harus memasang Python dan belajar bagaimana menjalankan program. Sekiranya anda mahu, anda boleh menyiapkan IDE (Integrated Desktop Environment), yang menggabungkan pengeditan, penyusunan, dan debugging ke dalam satu program. Python IDE dipanggil IDLE. Tetapi anda juga boleh menggunakan penyunting teks yang menyokong teks biasa, seperti Notepad untuk Windows, TextEdit untuk macOS, atau Vim untuk Linux.

Langkah 3. Tulis beberapa kod untuk menyambut pemain

Pemain ingin mengetahui apa yang sedang berlaku dan apa yang harus mereka lakukan, jadi anda harus mencetak beberapa teks untuk mereka.

Ini dilakukan dengan fungsi print () di Python. Untuk mencubanya, buka fail baru dengan sambungan.py, masukkan kod berikut ke dalamnya, simpan dan jalankan:
```
cetak ("Selamat datang ke permainan meneka nombor!") cetak ("Masukkan nombor bulat antara 1 hingga 1000:")
```

Langkah 4. Hasilkan nombor rawak

Mari buat permainan berasaskan teks yang meminta pemain meneka nombor yang betul. Perkara pertama yang perlu kita lakukan ialah menjana nombor rawak pada awal permainan sehingga pemain tidak akan selalu meneka nombor yang sama. Oleh kerana nombor akan tetap sama sepanjang program ini, anda pasti ingin menyimpan nombor rawak dalam pemboleh ubah.

Python tidak mempunyai fungsi nombor rawak bawaan, tetapi ia mempunyai perpustakaan standard (ini bermaksud pengguna tidak perlu memasang apa-apa tambahan) yang ada. Oleh itu, pergi ke permulaan kod anda (sebelum fungsi cetak ()) dan taipkan baris import secara rawak.
Gunakan fungsi rawak. Ini disebut randint (), ada di perpustakaan rawak yang baru saja anda impor, dan mengambil nilai minimum dan maksimum yang dapat dimiliki oleh nombor sebagai argumen. Oleh itu, kembali ke hujung kod anda dan masukkan baris berikut:
```
rightNum = random.randint (0, 1000)
```

Langkah 5. Dapatkan input dari pemain

Dalam permainan, pemain mahu melakukan sesuatu atau berinteraksi dengan sesuatu. Dalam permainan berasaskan teks, ini dimungkinkan dengan memasukkan teks. Sekarang kita mempunyai nombor rawak, baris kod seterusnya kita harus meminta pemain memasukkan tekaan terbaik mereka.

Oleh kerana kod yang anda masukkan mencetak arahan untuk memasukkan nombor ke pemain, ia juga harus membaca nombor yang mereka masukkan. Ini dilakukan dengan input () dalam Python 3, dan raw_input () dalam Python 2. Anda harus menulis dalam Python 3, kerana Python 2 akan menjadi usang tidak lama lagi. Tambahkan baris berikut ke kod anda untuk menyimpan input pemain dalam pemboleh ubah yang disebut nombor:
```
userNum = input ()
```

Langkah 6. Ubah input pemain menjadi jenis data yang boleh digunakan

Pemain telah memasukkan nombor-sekarang apa?

Jadikan input pemain sebagai nombor. Sekarang, ini mungkin membingungkan kerana mereka baru saja memasukkan nombor. Tetapi ada alasan yang baik: Python menganggap bahawa semua input adalah teks, atau "string", seperti yang disebut dalam pengaturcaraan. Teks ini mengandungi nombor yang ingin anda dapatkan. Python mempunyai fungsi yang menukar rentetan yang hanya mengandungi nombor menjadi nombor di dalamnya. Jenis:
```
userNum = int (userNum)
```

Langkah 7. Bandingkan nombor pemain dengan nombor yang betul

Setelah pemain memasukkan nombor mereka, anda perlu membandingkannya dengan pemain yang dihasilkan secara rawak. Sekiranya nombor tidak sama, permainan anda boleh membuat pemain mencuba nombor lain. Sekiranya nombor sesuai, anda mungkin memberitahu pemain yang mereka teka dengan betul, dan berhenti dari program ini. Ini dilakukan dengan kod berikut:

sementara userNum! = rightNum: userNum = int (input ())

Langkah 8. Beri maklum balas pemain

Walaupun anda sudah memproses inputnya, pemain tidak akan melihatnya. Anda mesti benar-benar mencetak hasilnya kepada pemain supaya mereka memahami apa yang berlaku.

Pasti, anda boleh memberitahu pemain sama ada nombor mereka betul atau salah. Tetapi dengan pendekatan itu, pemain mungkin perlu meneka 1000 kali dalam keadaan terburuk, yang akan sangat membosankan.
Oleh itu, beritahu pemain sama ada bilangan mereka terlalu kecil atau terlalu besar. Ini akan mengurangkan bilangan tekaan mereka dengan ketara. Jika, misalnya, pemain meneka 500 terlebih dahulu, dan permainan menjawab "Terlalu besar. Cuba lagi," hanya akan ada 500 kemungkinan nombor dan bukan 1000. Ini dilakukan dengan konstruksi if, jadi ganti cetakan ("Salah." Cuba lagi. ") Dengan satu.
Ketahui bahawa memeriksa sama ada dua nombor sama dilakukan dengan ==, bukan dengan =. = memberikan nilai kanannya ke pemboleh ubah di sebelah kiri!

if userNum <rightNum: print ("Terlalu kecil. Cuba lagi:") jika userNum> rightNum: print ("Terlalu besar. Cuba lagi:")

Langkah 9. Uji kod anda

Sebagai pengaturcara, anda harus memastikan bahawa kod anda berfungsi sebelum mempertimbangkannya selesai.

Semasa memprogram di python, pastikan anda mendapat lekukan dengan betul. Kod anda akan kelihatan seperti ini:

import cetak rawak ("Selamat datang ke permainan meneka nombor!") cetak ("Masukkan nombor bulat antara 1 dan 1000:") rightNum = random.randint (0, 1000) userNum = input () userNum = int (userNum) sementara userNum! = rightNum: if userNum <rightNum: print ("Terlalu kecil. Cuba lagi:") jika userNum> rightNum: print ("Terlalu besar. Cuba lagi:") userNum = int (input ()) cetak ("Anda meneka dengan betul. ")

Langkah 10. Sahkan input

Pemain tidak boleh mematahkan permainan anda dengan memasukkan perkara yang salah. "Mengesahkan input" bermaksud memastikan pemain memasukkan perkara yang betul sebelum memprosesnya.

Buka permainan sekali lagi dan cuba masukkan apa sahaja yang bukan nombor. Permainan akan keluar dengan ValueError. Untuk mengelakkan ini, anda dapat menerapkan cara untuk memeriksa apakah inputnya adalah angka.
Tentukan fungsi. Oleh kerana mengesahkan input cukup lama, dan anda harus melakukannya berkali-kali, anda harus menentukan fungsi. Tidak akan ada hujah dan mengembalikan nombor. Pertama, tulis def numInput (): di bahagian atas kod anda, tepat di bawah rawak import.
Dapatkan input pemain sekali. Gunakan fungsi input () dan tetapkan hasilnya ke inp pemboleh ubah.
Apabila input pemain bukan nombor, minta mereka memasukkan nombor. Untuk memeriksa sama ada rentetan adalah nombor, gunakan fungsi isdigit (), yang hanya membenarkan bilangan bulat, jadi anda tidak perlu memeriksanya secara berasingan.
Sekiranya inputnya adalah nombor, ubah dari rentetan menjadi nombor dan kembalikan hasilnya. Gunakan fungsi int () untuk menukar rentetan menjadi bilangan bulat. Ini akan menjadikan penukaran dalam kod utama tidak perlu, dan anda harus membuangnya dari sana.
Ganti semua panggilan ke input () dalam kod utama dengan panggilan ke numInput ().
Kod fungsi numInput () akan kelihatan seperti ini:

def numInput (): inp = input () sementara tidak inp.isdigit (): print ("Anda diberitahu untuk memasukkan nombor bulat! Masukkan nombor bulat:") inp = input () return int (inp)

Langkah 11. Uji permainan sekali lagi

Masukkan perkara yang salah dengan sengaja untuk melihat apa yang berlaku, dan kemudian perbaiki sebarang kesalahan semasa ia berlaku.

Cuba masukkan beberapa teks semasa program meminta nombor. Sekarang, daripada keluar dengan mesej ralat, program akan meminta nombor lagi

Langkah 12. Cadangkan untuk memulakan semula permainan apabila ia selesai

Dengan cara ini, pemain dapat memainkan permainan anda lebih lama tanpa perlu menghidupkannya semula secara berterusan.

Masukkan semua kod kecuali import dan definisi fungsi ke dalam loop sementara. Tetapkan Benar sebagai syarat: ini akan selalu berlaku, jadi gelung itu akan berterusan selamanya.
Tanya pemain adakah mereka mahu bermain lagi setelah mereka meneka nombor dengan betul. Gunakan fungsi cetak ().
Sekiranya mereka menjawab "Tidak", lepaskan pandangan. Sekiranya mereka menjawab apa-apa lagi, teruskan. Breaking out of loop dilakukan dengan pernyataan break.
Gerakkan "Selamat datang ke permainan meneka nombor" di luar gelung sementara. Pemain mungkin tidak mahu disambut setiap kali mereka bermain. Pindahkan cetakan arahan ("Selamat datang ke permainan meneka angka!" Di atas sementara Benar:, jadi ia akan dicetak hanya sekali, ketika pengguna memulakan permainan pertama.

Langkah 13. Uji permainan

Anda perlu menguji permainan anda setiap kali anda menggunakan ciri baru.

Pastikan untuk menjawab "Ya" dan "Tidak" sekurang-kurangnya sekali untuk memastikan bahawa kedua-dua pilihan berfungsi. Inilah rupa kod anda:

import def def numInput (): inp = input () sementara tidak inp.isdigit (): print ("Anda diberitahu untuk memasukkan nombor bulat! Masukkan nombor bulat:") inp = input () return int (inp) print ("Selamat datang ke permainan meneka nombor!") Sementara True: print ("Masukkan nombor bulat antara 1 dan 1000:") rightNum = random.randint (0, 1000) userNum = numInput () while userNum! = RightNum: if userNum <rightNum: print ("Terlalu kecil. Cuba lagi:") jika userNum> rightNum: print ("Terlalu besar. Cuba lagi:") userNum = numInput () cetak ("Anda meneka dengan betul.") cetak ("Adakah anda mahu bermain lagi? Masukkan Tidak untuk berhenti. ") jika input () ==" Tidak ": rehat

Langkah 14. Tulis permainan berasaskan teks yang lain

Bagaimana dengan menulis petualangan teks seterusnya? Atau permainan kuiz? Jadilah kreatif.

Petua: Kadang-kadang berguna untuk melihat dokumentasi jika anda tidak pasti bagaimana sesuatu dilakukan atau bagaimana fungsi digunakan. Dokumentasi Python 3 terdapat di https://docs.python.org/3/. Kadang-kadang mencari apa sahaja yang anda mahu lakukan di internet juga memberikan hasil yang baik.

Bahagian 2 dari 3: Membuat Permainan dengan Grafik 2D

Langkah 1. Pilih perpustakaan grafik

Membuat grafik sangat rumit, dan kebanyakan bahasa pengaturcaraan (termasuk Python, C ++, C, JavaScript) hanya menyediakan sokongan minimum atau bahkan tidak ada grafik untuk inti atau perpustakaan standard. Oleh itu, anda mesti menggunakan perpustakaan luaran untuk dapat membuat grafik, contohnya Pygame untuk Python.

Walaupun dengan perpustakaan grafik, anda pasti perlu bimbang tentang cara memaparkan menu, cara memeriksa apa yang diklik pemain, cara memaparkan jubin, dan sebagainya. Sekiranya anda lebih suka menumpukan pada pengembangan permainan yang sebenarnya, anda boleh menggunakan perpustakaan mesin permainan seperti Unity, yang melaksanakan perkara-perkara ini dengan mudah

Artikel ini akan menggunakan Python dengan Cocos2D untuk menunjukkan cara membuat platformer 2D yang mudah. Beberapa konsep yang disebutkan mungkin tidak ada pada mesin permainan lain. Rujuk dokumentasi mereka untuk maklumat lebih lanjut.

Langkah 2. Pasang pustaka grafik yang anda pilih

Cocos2D untuk Python mudah dipasang. Anda boleh mendapatkannya dari https://python.cocos2d.org/index.html, atau dengan menjalankan sudo pip3 pasang cocos2d jika anda menggunakan Linux.

Langkah 3. Buat direktori baru untuk permainan dan media anda

Anda akan menggunakan perkara seperti gambar dan suara dalam permainan anda. Simpan perkara ini dalam direktori yang sama dengan program. Direktori ini tidak boleh mengandungi perkara lain sehingga anda dapat dengan mudah melihat aset apa yang anda miliki dalam permainan.

Langkah 4. Buat fail kod baru di direktori baru

Panggil ia utama, dengan peluasan fail untuk bahasa pengaturcaraan anda. Sekiranya anda menulis program besar dan kompleks di mana masuk akal untuk mempunyai banyak fail program, ini akan menunjukkan kepada anda yang merupakan fail utama.

Dalam contoh ini, kami akan membuat fail bernama main.py yang akan mengandungi semua kod kami

Langkah 5. Buat tetingkap permainan

Ini adalah prasyarat asas untuk permainan dengan grafik.

Import sub-modul cocos2d yang diperlukan: cocos.director, cocos.scene dan cocos.layer. Ini dilakukan dengan dari subModuleName import *, di mana sub-Module name adalah submodule yang ingin anda import. Perbezaan antara dari… import * dan import… adalah anda tidak perlu meletakkan nama modul di hadapan semua yang anda gunakan dari modul tersebut dengan yang sebelumnya.
Tentukan subkelas MainMenuBgr dari ColorLayer. Ini pada dasarnya bermaksud bahawa latar belakang menu utama yang anda buat akan berkelakuan seperti lapisan warna dengan beberapa perubahan yang anda buat.
Mulakan pengarah cocos. Ini akan memberi anda tetingkap baru. Sekiranya anda tidak menetapkan kapsyen, tetingkap akan mempunyai kapsyen yang sama dengan nama fail (main.py), yang tidak akan kelihatan profesional. Benarkan tetingkap diubah saiznya dengan menetapkan ukuran semula ke True.
Tentukan fungsi showMainMenu. Anda harus memasukkan kod untuk menunjukkan menu utama ke dalam fungsi kerana ini akan membolehkan anda dengan mudah kembali ke menu utama dengan memanggil fungsi itu lagi.
Buat pemandangan. Adegan ini terdiri daripada satu lapisan buat masa ini, yang merupakan objek kelas MainMenuBgr yang anda tentukan.
Jalankan pemandangan ini di tingkap.

dari cocos.director import * dari cocos.scene import * dari cocos.layer import * class MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenu, self)._ init _ (0, 200, 255, 255) def showMainMenu (): menuSc = Scene (MainMenuBgr ()) director.run (menuSc) director.init (caption = "IcyPlat - platformer sederhana", boleh diubah saiz = Betul) showMainMenu ()

Langkah 6. Tambahkan menu utama ke tetingkap

Selain permainan yang sebenarnya, anda perlu menambahkan menu yang boleh digunakan pemain untuk menutup tetingkap, antara elemen lain yang boleh anda tambahkan kemudian.

Import cocos.menu (sekali lagi dengan arahan dari) dan pyglet.app (kali ini dengan import).
Tentukan MainMenu sebagai subkelas Menu.
Tetapkan penjajaran menu utama. Anda harus menetapkan penjajaran menegak dan mendatar secara berasingan.
Buat senarai item menu dan tambahkan ke menu. Anda harus mempunyai item menu "Start Game" dan "Quit" sekurang-kurangnya. Setiap item menu hendaklah diletakkan di dalam kurungan. Setiap item mesti mempunyai label dan fungsi panggilan balik yang menentukan apa yang berlaku apabila pemain mengkliknya. Untuk item "Start Game", gunakan fungsi startGame (anda akan menulisnya tidak lama lagi), untuk item "Quit", gunakan "pyglet.app.exit" (sudah ada). Buat menu sebenar dengan memanggil self.create_menu (menuItems).
Tentukan startGame (). Cukup masukkan definisi buat masa ini, anda akan menggantinya ketika anda menulis permainan sebenar.
Pergi ke tempat dalam kod anda di mana anda membuat pemandangan menuSc, dan tambahkan objek MainMenu ke dalamnya.

Seluruh kod anda kini kelihatan seperti berikut:

dari cocos.director import * dari cocos.menu import * dari cocos.scene import * dari cocos.layer import * import pyglet.app class MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) kelas MainMenu (Menu): def _init _ (diri): super (MainMenu, diri)._ init _ ("") self.menu_valign = CENTRE self.menu_halign = CENTRE menuItems = [(MenuItem ("Start Game" ", startGame)), (MenuItem (" Quit ", pyglet.app.exit))] self.create_menu (menuItems) def startGame (): pass def showMainMenu (): menuSc = Scene (MainMenuBgr ()) menuSc.add (MainMenu ()) director.run (menuSc) director.init (caption = "IcyPlat - platformer sederhana", boleh diubah saiznya = True) showMainMenu ()

Langkah 7. Uji kod anda

Uji kodnya lebih awal, walaupun masih pendek dan agak mudah. Kemudian anda dapat mengenal pasti dan membetulkan sebarang kesalahan dalam struktur asas sebelum perkara menjadi terlalu rumit.

Kod dari arahan harus membuka tetingkap bertuliskan "IcyPlat - platformer sederhana." Latar belakang berwarna biru muda dan anda boleh mengubah saiz tetingkap. Apabila anda mengklik "Mula Permainan" pada menu, tidak ada yang berlaku (belum). Apabila anda mengklik "Keluar", tetingkap akan ditutup

Langkah 8. Buat sprite

Sprite adalah "objek permainan", atau gambar 2 dimensi. Sprite boleh menjadi objek dalam permainan, ikon, hiasan latar, watak, dan apa sahaja yang dapat anda wakili dengan gambar dalam permainan. Kita akan mulakan dengan membuat sprite untuk watak yang boleh berinteraksi dengan pemain.

Import submodule cocos.sprite dengan ungkapan dari-import.
Cari gambar untuk mewakili sprite. Anda tidak dapat memaparkan sprite jika anda tidak mempunyai gambar untuknya. Anda boleh menariknya, atau mendapatkannya dari internet (berhati-hatilah untuk mendapatkan lesen, sekiranya anda merancang untuk menerbitkan permainan anda). Untuk contoh ini, pergi ke https://opengameart.org/content/tux-classic-hero-style dan simpan gambar-p.webp" />
Buat lapisan sebagai objek baru dari kelas ScrollableLayer. Kemudian, buat sprite sebagai objek Sprite dan tetapkan posisinya ke (8, 250). Sebagai rujukan, titik (0, 0) berada di sudut kiri bawah. Ini cukup tinggi, tetapi akan memastikan bahawa penguin tidak terjebak di dalam es.
Tambahkan sprite ke lapisan sprite.
Buat pemandangan baru dari lapisan sprite dan jalankan.

def startGame (): figLayer = ScrollableLayer () fig = Sprite ('pingu.png') fig.position = (75, 100) figLayer.add (fig) # gameSc = Scene (figLayer) director.run (gameSc)

Jalankan kod. Anda mesti melihat gambar penguin kecil (atau apa sahaja yang anda gambar) pada latar belakang hitam setelah anda mengklik Mula permainan.

Langkah 9. Mimpi pemandangan anda

Dalam kebanyakan permainan, sprite anda tidak boleh melayang dalam kekosongan. Mereka semestinya berdiri di permukaan, dengan sesuatu di sekelilingnya. Dalam permainan 2D, ini sering dilakukan dengan set jubin dan peta jubin. Set jubin pada dasarnya mengatakan jenis kotak permukaan dan kotak latar belakang yang ada, dan bentuknya.

Buat set jubin. Set jubin untuk permainan ini akan sangat asas: satu jubin untuk ais dan satu jubin untuk langit. Jubin ais yang digunakan dalam contoh ini adalah dari sini, di bawah CC-BY-SA 3.0.
Buat gambar set jubin. Itulah gambar semua jubin, yang semuanya harus sama ukuran (edit jika tidak) dan mempunyai ukuran yang anda ingin lihat dalam permainan, di sebelah satu sama lain. Simpan gambar anda sebagai icyTiles.png.
Buat keterangan set jubin. Itu fail XML. Fail XML mengandungi maklumat mengenai seberapa besar jubin dalam gambar set jubin, gambar mana yang akan digunakan, dan di mana untuk mencari jubin mana di sana. Buat fail XML bernama icyTiles.xml dengan kod di bawah:
```
     
```

Langkah 10. Buat peta jubin untuk landskap anda

Peta jubin adalah peta yang menentukan jubin mana yang berada pada kedudukan di tahap anda. Sebagai contoh, anda harus menentukan fungsi untuk menghasilkan peta jubin kerana merancang peta jubin dengan tangan sangat membosankan. Permainan yang lebih maju biasanya mempunyai semacam editor tingkat, tetapi untuk membiasakan diri dengan pengembangan permainan 2D, algoritma dapat memberikan level yang cukup baik.

Ketahui berapa baris dan lajur yang diperlukan. Untuk ini, bahagikan ukuran skrin dengan ukuran jubin secara mendatar (lajur) dan menegak (baris). Bundarkan nombor ke atas; anda memerlukan fungsi modul matematik untuk itu, jadi tambah dari siling import matematik ke import di bahagian atas kod anda.
Buka fail untuk menulis. Ini akan menghapus semua kandungan fail sebelumnya, jadi pilih nama yang belum ada fail dalam direktori, seperti levelMap.xml.
Tuliskan tag pembuka ke dalam fail.
Hasilkan peta jubin mengikut algoritma. Anda menggunakan yang ada dalam kod di bawah ini, atau anda boleh membuatnya sendiri. Pastikan untuk mengimport fungsi randint dari modul secara rawak: diperlukan kod di bawah untuk berfungsi, dan apa sahaja yang anda buat mungkin juga memerlukan bilangan bulat rawak. Juga, pastikan meletakkan jubin langit dan jubin ais dalam lapisan yang berlainan: ais padat, langit tidak.
Tuliskan tag penutup ke dalam fail dan tutup fail tersebut.

def createTilemap (): colAmount = ceil (800/16) * 3 # (lebar skrin / saiz jubin) * 3 barisAmount = siling (600/16) # ketinggian skrin / ukuran jubinFile = terbuka ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) untuk i dalam julat (0, colAmount): tileFile.write ('') makeHole = Salah jika randint (0, 50) == 10 dan i! = 0: # jangan biarkan lubang di spawnpoint makeHole = True for j in range (0, rowAmount): if makeHole: tileFile.write ('\ n') other: if j <= iceHeight: tileFile.write ('\ n') other: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight + 5) jika iceHeight <0: # hadkan jubin agar tidak terlalu rendah aisHeight = randint (1, 5) if iceHeight> rowAmount: # hadkan jubin agar tidak terlalu tinggi aisHeight = randint (int (rowAmount / 2) -5, int (rowAmount / 2) +5) tileFile.write ('\ n') tileFile.write ('\ n / n') untuk i dalam jarak (0, colAmount): tileFile.write ('') untuk j dalam julat (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()

Langkah 11. Paparkan peta jubin

Import semua dari cocos.tiles dan kemudian masuk ke fungsi startGame untuk itu.

Pada permulaan fungsi startGame anda, buat peta jubin menggunakan fungsi yang anda tetapkan untuk itu.
Buat pengurus tatal baru. Lakukan ini secara langsung di bawah garis di mana anda menambahkan sprite ke lapisannya.
Buat lapisan baru yang mengandungi jubin, yang akan dimuat dari peta jubin levelMap.xml yang dihasilkan fungsi menghasilkanTilemap anda.
Tambahkan lapisan tidak padat, lapisan pepejal dan lapisan sprite ke pengurus tatal, tepat dalam urutan ini. Anda boleh menambah kedudukan-z jika anda mahu.
Daripada membuat pemandangan dari lapisan sprite, buatlah dari pengurus tatal.

Fungsi startGame anda kini kelihatan seperti ini:

def startGame (): createTilemap () # fig = Sprite ('pingu.png') fig.position = (8, 500) figLayer = ScrollableLayer () figLayer.add (fig) # tileLayer = load ('levelMap.xml') solidTiles = tileLayer ['solid'] nsoliTiles = tileLayer ['not_solid'] # scrMang = ScrollingManager () scrMang.add (nsoliTiles, z = -1) scrMang.add (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Scene (scrMang) pengarah. Jalankan (gameSc)

Langkah 12. Uji kod anda

Anda harus kerap menguji kod anda untuk memastikan bahawa ciri baru yang anda laksanakan benar-benar berfungsi.

Kod dalam contoh sekarang harus menunjukkan beberapa pemandangan sejuk di belakang penguin. Sekiranya penguin itu kelihatan berada di atas ais, anda tidak melakukan kesalahan, dan ia akan diperbaiki pada langkah seterusnya

Langkah 13. Tambahkan kawalan

Pemain mempunyai lebih banyak cara untuk berinteraksi dengan program dalam permainan 2D daripada permainan berasaskan teks. Yang biasa termasuk menggerakkan angka mereka apabila kekunci yang betul ditekan.

Import semua dari cocos.mapcolliders dan dari cocos.actions. Import juga kunci dari pyglet.window.
"Nyatakan" beberapa pemboleh ubah global. Pemboleh ubah global dikongsi antara fungsi. Anda tidak boleh benar-benar menyatakan pemboleh ubah dalam Python, tetapi anda harus mengatakan bahawa pemboleh ubah global ada dalam kod utama sebelum menggunakannya. Anda boleh menetapkan 0 sebagai nilai kerana fungsi akan mengurus memberikan nilai yang betul kemudian. Oleh itu, tambahkan di bawah ungkapan import:
```
# "menyatakan" papan kekunci pembolehubah global = 0 scrMang = 0
```

Laraskan fungsi startGame anda:

Katakan bahawa anda menggunakan papan kekunci pembolehubah global dan scrMang. Lakukan ini dengan menulis papan kekunci global, scrMang di bahagian atas fungsi.
Jadikan tetingkap mendengar acara papan kekunci.
Beritahu tokoh untuk bertindak berdasarkan PlatformerController. Anda akan melaksanakan PlatformerController itu tidak lama lagi.
Buat collider peta untuk menangani perlanggaran antara jubin pepejal dan gambar.

def startGame (): papan kekunci global, scrMang menghasilkanTilemap () # fig = Sprite ('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer () figLayer.add (fig) # tileLayer = load ('levelMap).xml ') solidTiles = tileLayer [' solid '] nsoliTiles = tileLayer [' not_solid '] # keyboard = key. KeyStateHandler () director.window.push_handlers (keyboard) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on_b = 'slaid') fig.collision_handler = make_collision_handler (mapcollider, solidTiles) # scrMang = ScrollingManager () scrMang.add (nsoliTiles, z = -1) scrMang.add (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Scene (scrMang) pengarah. Jalankan (gameSc)

Buat pengawal platformer. Inilah yang akan menggerakkan angka mengikut tekanan kekunci anda.
- Tentukan pengawal platformer sebagai subkelas Action.
- Tentukan kelajuan bergerak, kelajuan lompatan dan graviti.
- Tentukan fungsi permulaan. Fungsi ini dipanggil sekali, apabila pengawal platformer dihubungkan ke angka. Ia harus menetapkan kelajuannya ke 0 dalam arah x dan arah y.
- Tentukan fungsi langkah. Ia akan berulang ketika pemandangan berjalan.
- Beritahu fungsi langkah untuk menggunakan papan kekunci pembolehubah global dan scrMang.
- Dapatkan dan ubah halaju. Simpan halaju x dan y dalam pemboleh ubah berasingan. Tetapkan halaju x ke 1 atau -1 (bergantung pada apakah tombol kiri atau kanan ditekan) didarab dengan kelajuan bergerak. Tambahkan graviti pada halaju y. Gandakannya dengan waktu henti sehingga berfungsi dengan cara yang sama pada peranti yang lebih perlahan. Sekiranya kekunci ruang ditekan dan angka berdiri di atas tanah, lompat dengan menukar kelajuan y ke laju lompat.
- Kira ke mana tokoh itu harus bergerak. Kemudian biarkan pengendali perlanggaran menyesuaikan kedudukannya jika berada di dalam jubin yang kukuh. Akhirnya, pindahkan angka ke kedudukan laras baru.
- Tetapkan fokus pengurus tatal pada gambar. Ini menyebabkan kamera bergerak dengan cara yang wajar ketika gambar bergerak.
```
class PlatformerController (Action): keyboard global, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) langkah def (self, dt): keyboard global, scroller jika dt> 0.1: # jangan buat apa-apa semasa downtime ke pulangan besar vx, vy = self.target.velocity vx = (keyboard [key. RIGHT] - keyboard [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt if self.on_ground dan keyboard [key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt terakhir = self.target.get_rect () baru = terakhir.copy () baru.x + = dx new.y + = dy self.target.velocity = self.target.collision_handler (terakhir, baru, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (* new.center)
```

Langkah 14. Uji kod anda

Sekiranya anda mengikuti contohnya, kini anda seharusnya dapat menggerakkan penguin dengan kekunci anak panah dan melompat dengan menekan spasi. Juga, penguin sekarang harus jatuh bukannya melayang di atas tanah.

Langkah 15. Buat penamat untuk permainan

Malah permainan yang boleh berlangsung tanpa henti harus mempunyai kemungkinan kalah. Oleh kerana tahap yang anda buat dalam contoh dengan fungsi sudah berakhir, anda juga harus memungkinkan untuk menang dengan mencapai tujuan tersebut. Jika tidak, pemain hanya akan melompat-lompat di blok-blok ais di sana, yang akan menjadi membosankan.

Di dalam pengawal platformer, setelah fokus ditetapkan, dapatkan kedudukan x dan y angka tersebut. Sekiranya kedudukan y kurang dari 0, panggil fungsi finishGame () (anda akan menulisnya kemudian) dengan "Game Over" sebagai argumen. Sekiranya kedudukan x lebih besar daripada ukuran layar dikalikan dengan 3 (anda telah menetapkannya sebagai ukuran tahap sebelumnya).
```
posX, posY = self.target.position if posY <0: finishGame ("Game Over") kembali jika posX> 800 * 3: # level level finishGame ("Level Selesai") kembali
```
Tentukan penamat kelasMenu. Ia seperti kelas menu utama yang anda tentukan sebelumnya, tetapi bukannya mempunyai rentetan kosong sebagai tajuk, ia harus menggunakan teks pemboleh ubah yang fungsi _init_ diambil sebagai argumen. Item menu harus diberi label "Cuba lagi" dan "Keluar" sekarang, tetapi fungsi yang mereka sebut tetap sama.
```
kelas FinishMenu (Menu): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTRE self.menu_halign = CENTRE menuItems = [(MenuItem ("Cuba lagi", startGame)), (MenuItem ("Keluar", pyglet.app.exit))] self.create_menu (menuItems)
```
Tentukan fungsi finishGame (). Ia harus mengambil teks sebagai hujah. Ia harus membuat pemandangan dari latar belakang menu utama, FinishMenu dengan argumen teks diteruskan ke menu ini. Maka perlu menjalankan adegan ini.
```
def finishGame (teks): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (text)) director.run (menuSc)
```

Langkah 16. Tambahkan kredit

Di sinilah anda mendapat penghargaan atas kod hebat anda, serta memberi penghargaan kepada orang lain yang membantu anda sepanjang perjalanan. Sekiranya anda menggunakan gambar dari laman web lain (dengan izin), pastikan untuk mengaitkan gambar tersebut kepada penciptanya.

Buat fail KREDIT dan masukkan semua kredit anda di sana, seperti ini:

Penguin: Kelvin Shadewing, di bawah CC0 Ice block: Michał Banas digit1024 di opengameart.org di bawah CC-BY-SA 3.0

Kembali ke kod Python anda dan import Label dari cocos.text.

Tentukan Kredit Layer subkelas. Dalam fungsi _init_, baca fail KREDIT dan buat label teks pada kedudukan yang betul dari setiap baris di dalamnya.

kelas Kredit (Lapisan): def _init _ (diri): super (Kredit, diri)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n ") untuk i dalam julat (0, len (creds)): credLabel = Label (creds , font_size = 32, anchor_x =" left ", anchor_y =" top ") credLabel.position = 25, 500- (i +1) * 40 diri. Tambah (label Label)

Pergi ke kelas menu utama anda dan tambahkan item menu berlabel "Kredit" yang memanggil fungsi showCredits ketika diklik.
Tentukan subkelas BackToMainMenuButton Menu. Jadikan ini menu dengan satu item, berlabel "Kembali", yang memanggil fungsi showMainMenu. "Menu" ini, yang lebih seperti butang, harus sejajar secara menegak ke bawah dan mendatar ke atas.
```
kelas BackToMainMenuButton (Menu): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Back", showMainMen) create_menu (menuItems)
```

Tentukan fungsi showCredits. Ia harus membuat pemandangan dari lapisan MainMenuBgr dan lapisan Kredit dan menjalankan pemandangan itu.

def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc)

Langkah 17. Periksa kod anda

Apabila anda fikir anda telah menyelesaikan kod anda, anda harus melihatnya semula. Ini dapat membantu anda melihat jika sesuatu dapat dioptimumkan, atau adakah baris yang tidak perlu anda lupakan. Sekiranya anda mengikuti contohnya, keseluruhan kod anda kini akan kelihatan seperti berikut:

dari cocos.director import * dari cocos.menu import * dari cocos.scene import * dari cocos.layer import * dari cocos.sprite import * dari cocos.tiles import * dari cocos.mapcolliders import * dari cocos.actions import * dari cocos.text import Label import pyglet.app dari pyglet.window import key dari math import ceil dari randint import rawak # "menyatakan" keyboard pemboleh ubah global = 0 scrMang = 0 kelas MainMenuBgr (ColorLayer): def _init _ (diri): super (MainMenuBgr, diri)._ init _ (0, 200, 255, 255) kelas MainMenu (Menu): def _init _ (diri): super (MainMenu, diri)._ init _ ("") self.menu_valign = CENTRE self.menu_halign = CENTER menuItems = [(MenuItem ("Start Game", startGame)), (MenuItem ("Credits", showCredits)), (MenuItem ("Quit", pyglet.app.exit))] self.create_menu (menuItems) Kredit kelas (Lapisan): def _init _ (diri): super (Kredit, diri)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n") untuk i dalam jarak (0, len (creds)): credLabel = Label (kredit , font_size = 32, anchor_x = "left", anchor_y = "top") credLabel.position = 25, 500- (i + 1) * 40 self.add (credLabel) class BackToMainMenuButton (Menu): def _init _ (diri): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Back", showMainMenu))] self.create_menu (menuItems) kelas FinishMenu (Menu) self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTRE self.menu_halign = CENTRE menuItems = [(MenuItem ("Cuba lagi", startGame)), (MenuItem ("Quit", pyglet). app.exit))] self.create_menu (menuItems) class PlatformerController (Action): keyboard global, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) langkah def (self, dt): papan kekunci global, scroller jika dt> 0.1: # jangan buat apa-apa semasa downtime pulangan terlalu besar vx, vy = self.target.velocity vx = (keyboard [key. RIGHT] - papan kekunci [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt jika self.on _ground dan keyboard [key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect () baru = terakhir.copy () baru.x + = dx baru.y + = dy self.target.velocity = self.target.collision_handler (terakhir, baru, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (* new.center) posX, posY = self.target.position if posY <0: finishGame ("Game Over") kembali jika posX> 800 * 3: # level level finishGame ("Level Selesai") return def finishGame (teks): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (text)) director.run (menuSc) def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Kredit ()) credSc.add (BackToMainMenuButton (BackToMainMenuButton)). Director.run (credSc) def createTilemap (): colAmount = ceil (800/16) * 3 # (lebar skrin / ukuran jubin) * 3 barisAmount = siling (600/16) # ketinggian skrin / ukuran jubinFile = terbuka ("levelMap.xml", "w") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) untuk i dalam julat (0, colAmount): tileFile.write ('') makeHole = Salah jika rand int (0, 50) == 10 dan i! = 0: # jangan biarkan lubang di spawnpoint makeHole = True for j in range (0, rowAmount): if makeHole: tileFile.write ('\ n') lain: if j <= iceHeight: tileFile.write ('\ n') other: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight + 5) jika iceHeight <0: # hadkan jubin agar tidak terlalu banyak low iceHeight = randint (1, 5) if iceHeight> rowAmount: # hadkan jubin agar tidak terlalu tinggi aisHeight = randint (int (rowAmount / 2) -5, int (rowAmount / 2) +5) tileFile.write ('\ n tileFile.write ('\ n / n') untuk i dalam julat (0, colAmount): tileFile.write ('') untuk j dalam julat (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n') tileFile.write ('\ n / n') tileFile.close () def startGame (): papan kekunci global, scrMang menghasilkanTilemap () # fig = Sprite ('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer () figLayer.add (fig) # tileLayer = load ('levelMap.xml') solidTiles = tileLayer ['solid'] nsoliTiles = tileLayer ['not_solid'] # keyboard = key. KeyStateHandler () director.window.push_handlers (keyboard) ard) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on_bump = 'slide') fig.collision_handler = make_collision_handler (mapcollider, solidTiles) # scrMang = ScrollingManager () scrMang.add (nsoliTiles, nsoliTiles) tambah (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Scene (scrMang) director.run (gameSc) def showMainMenu (): menuSc = Scene (MainMenuBgr ()) menuSc.add (MainMenu (). Director.run (menuSc) window = director.init (caption = "IcyPlat - platformer sederhana", boleh diubah saiznya = True) showMainMenu ()

Itu adalah 168 garis keseluruhan, dan 152 baris jika anda hanya mengira kodnya. Ini kelihatan seperti banyak, tetapi untuk permainan yang begitu kompleks, ini sebenarnya sedikit.

Langkah 18. Selesai

Sekarang uji permainan. Semasa anda memprogram sesuatu, anda harus memeriksa sama ada ia berfungsi setiap kali anda melaksanakan sesuatu yang baru. Anda juga mungkin mahu bermain permainan yang anda tulis untuk beberapa waktu.

Bahagian 3 dari 3: Menerbitkan Permainan

Langkah 1. Tuliskan kebergantungan

Sesiapa yang menggunakan komputer lain tidak akan memasang perisian dan perpustakaan yang sama seperti anda. Oleh itu, anda perlu memastikan semua orang yang memasang permainan anda mengetahui dengan tepat apa yang mereka perlukan untuk menjalankannya. Anda tidak perlu menuliskan semua kebergantungan dari semua kebergantungan dari semua kebergantungan dan sebagainya, tetapi sekurang-kurangnya anda harus menulis pergantungan pakej anda dan kebergantungannya.

Langkah 2. Pastikan anda mempunyai kebenaran untuk menggunakan semua media

Ini berlaku untuk semua grafik, termasuk model 3D, musik, dialog, musik, perpustakaan, dan kerangka kerja yang Anda gunakan untuk permainan Anda. Apa sahaja yang anda tidak tulis sendiri.

Selalunya terdapat beberapa syarat, seperti harus memberi penghargaan kepada pengarang atau berkongsi pengubahsuaian media di bawah lesen yang sama. Kadang kala anda dapat menggunakan grafik tanpa mengaitkan penciptanya selagi anda tidak mengenakan bayaran untuk permainan. Sekiranya anda harus memberi penghargaan kepada pengarang, lakukanlah di tempat yang kelihatan dengan baik, seperti tab "Kredit" dalam permainan anda.
Ada juga media dengan hak cipta yang dituntut dan tidak ada lesen yang ditentukan, kadang-kadang dengan beberapa teks seperti "All rights reserved". Sekiranya demikian, anda mesti mendapat kebenaran jelas dari pengarang sebelum memasukkannya ke dalam permainan anda.
Perpustakaan biasanya dikeluarkan dengan lesen yang membolehkannya digunakan sebagai perpustakaan. Pengecualian yang ketara ialah GPL tanpa mengaitkan pengecualian: Lesen semacam itu hanya memungkinkan untuk menggunakannya dalam program dengan lesen tertentu. Dan anda harus selalu membaca sekurang-kurangnya perkara asas lesen untuk memastikan apa sahaja yang anda lakukan dengan media atau perpustakaan dibenarkan.

Amaran: Menggunakan media atau perpustakaan dengan cara yang tidak diizinkan oleh lesen dalam permainan yang anda terbitkan dapat membuat anda menghadapi masalah hukum yang serius. Oleh itu, tanyakan kepada pengarang atau hindari media sama sekali jika anda tidak pasti sama ada penggunaan anda dibenarkan.

Langkah 3. Tentukan syarat yang anda mahu terbitkan permainan anda

Adakah anda akan menjual permainan anda? Adakah anda mahu membenarkan orang lain menggunakan gambar dan idea anda? Walaupun anda harus berhati-hati dengan media yang anda gunakan dalam projek anda, anda biasanya dapat memutuskan bagaimana anda ingin membiarkan orang lain menggunakan permainan anda. Anda boleh menggunakan lesen Creative Commons CC0 untuk melepaskan permainan anda di domain awam.. Untuk membenarkan pengedaran dan pengubahsuaian dalam beberapa keadaan sambil mengekalkan beberapa hak, cubalah lesen Gnu General Public License (GPL) atau Berkeley Software Distribution (BSD). Atau, anda boleh menjadikan perisian anda proprietari, yang bermaksud bahawa tidak ada yang dibenarkan menyebarkan atau mengubahnya tanpa kebenaran anda.

Walaupun dapat menjana wang dengan menjual permainan, tidak mungkin orang akan membeli permainan pertama anda yang biasanya mempunyai sedikit ciri dan tidak ada yang istimewa. Juga, jika program percuma tidak berfungsi, orang yang memuat turunnya akan kecewa. Sekiranya mereka membayarnya, mereka akan menuntut wang mereka kembali, menyebabkan lebih banyak masalah bagi anda dan pengguna. Oleh itu, pertimbangkan untuk menyediakan beberapa program pertama anda secara percuma

Langkah 4. Tentukan bagaimana anda mahu menerbitkan permainan anda

Setiap kaedah mempunyai beberapa kelebihan dan kekurangan, jadi anda harus memutuskan sendiri.

Menerbitkannya di laman web:

Sekiranya anda mempunyai laman web, anda boleh memuat naik permainan anda untuk membuatnya dimuat turun. Pastikan untuk memberikan arahan yang jelas mengenai cara memasang perisian, serta semua pergantungan yang diperlukan. Kelemahan ini ialah pemain perlu memasang pergantungan secara manual, yang mungkin sukar bagi sesetengah orang.
Membuat pakej untuk pengurus pakej:

Terdapat pengurus pakej yang berbeza, seperti apt, Yum, dan Homebrew, yang memudahkan orang memasang aplikasi di persekitaran berasaskan Linux dan Linux. Kesemuanya mempunyai format pakej yang berbeza. Perkara yang baik mengenai pakej ialah mereka memasang semua kebergantungan secara automatik (jika anda mengkonfigurasinya dengan betul). Oleh itu pemain hanya perlu memasang pakej anda dan kemudian dapat memainkan permainan. Masalahnya ialah terdapat banyak pengurus pakej yang berlainan di platform yang berbeza, jadi anda harus berusaha menyediakan pakej untuk semua yang paling biasa.

Langkah 5. Perhatikan program anda

Pertimbangkan untuk memuat naik program anda ke repositori pakej utama, seperti yang dijaga oleh Ubuntu dan Debian, untuk memudahkan pemasangan. Juga, hantarkan di forum yang sesuai, seperti bahagian projek GameDev atau bahagian tigSource. Tetapi jangan kecewa jika permainan pertama anda tidak menjadi terkenal. Sekiranya anda mempunyai idea bahawa ramai orang menyukainya, permainan anda boleh menjadi terkenal.

Petua

Bersabar dan bersedia belajar. Pengaturcaraan kadangkala mengecewakan!
Sekiranya anda tertanya-tanya bagaimana sesuatu dilakukan dalam permainan lain, dan permainan itu sumber terbuka, anda boleh melihat kod sumbernya.
Semasa mencari media, cuba cari kandungan yang berada di domain awam. Cari gambar dan muzik "Creative Commons" atau "Domain Awam", dan gunakan laman web seperti https://opengameart.org atau
Jangan menyalin sebahagian besar kod tanpa memeriksa lesen. Selalunya dilarang, dan jika tidak, biasanya memerlukan atribusi.
Jangan membuat spam atau menghantar di tempat yang tidak sesuai semasa mempromosikan permainan anda. Ini mungkin membuat anda tersekat dari halaman, hanya mengganggu, dan akan merosakkan reputasi anda.