Cara Memprogram Game Komputer (dengan Gambar)

2024 Pengarang: Robert Blare | [email protected]. Terakhir diubah: 2024-01-31 12:17

Apakah Anda memiliki ide untuk game komputer dan ingin mewujudkannya? Atau pernahkah Anda bertanya-tanya bagaimana game komputer ditulis? Artikel wikiHow ini akan mengajarkan kepada Anda cara menulis tiga permainan komputer dasar dengan Python. Anda memerlukan pemahaman dasar tentang Python dan konsep pemrograman umum untuk mengembangkan game pertama Anda.

Langkah

Bagian 1 dari 3: Membuat Game Berbasis Teks

Langkah 1. Pilih bahasa pemrograman

Semua bahasa pemrograman berbeda, jadi Anda harus memutuskan mana yang akan digunakan untuk menulis game Anda. Setiap bahasa pemrograman utama mendukung input teks, output teks, dan if-constructions (hal utama yang Anda perlukan untuk game berbasis teks sederhana), jadi jelajahi opsi dan putuskan mana yang Anda rasa paling nyaman dan berdedikasi untuk belajar. Berikut adalah beberapa faktor yang perlu dipertimbangkan:

Bahasa apa yang paling sering digunakan?

Beberapa bahasa pemrograman, seperti JavaScript, dirancang untuk digunakan di web, sementara yang lain, seperti Python, C, atau C++, dirancang untuk menjalankan program komputer. Untuk game Anda, gunakan bahasa dengan cakupan penggunaan yang lebih luas, seperti Python, C, C++, atau JavaScript.
Seberapa sulitkah untuk belajar?

Meskipun menulis program seharusnya cukup mudah setelah beberapa latihan dalam bahasa pemrograman normal (yaitu, tidak ada yang dirancang khusus untuk membingungkan seperti Malbolge), beberapa lebih ramah untuk pemula daripada yang lain. Java dan C, misalnya, akan mengharuskan Anda untuk memahami konsep pemrograman yang lebih dalam daripada sesuatu seperti Python, yang dikenal dengan sintaksisnya yang lebih mudah diakses dan langsung.
Di mana saya bisa menggunakannya?

Anda mungkin ingin orang-orang di sistem yang berbeda, seperti Linux, Mac atau Windows, semua dapat memainkan game Anda. Jadi sebaiknya Anda tidak menggunakan bahasa yang hanya didukung di beberapa sistem, seperti Visual Basic, yang hanya didukung di Windows.

Artikel ini akan menggunakan Python untuk contoh permainan berbasis teks, tetapi Anda dapat melihat bagaimana konsep dilakukan dalam bahasa pemrograman lain.

Langkah 2. Siapkan komputer Anda

Dua komponen utama yang Anda perlukan adalah editor teks, di mana Anda akan menulis kode Anda, dan kompiler, yang akan Anda gunakan untuk mengubahnya menjadi sebuah permainan. Jika Anda ingin mengikuti contoh di artikel ini, Anda harus menginstal Python dan mempelajari cara menjalankan program. Jika mau, Anda dapat mengatur IDE (Integraded Desktop Environment), yang menggabungkan pengeditan, kompilasi, dan debugging ke dalam satu program. IDE Python disebut IDLE. Tetapi Anda juga dapat menggunakan editor teks apa pun yang mendukung teks biasa, seperti Notepad untuk Windows, TextEdit untuk macOS, atau Vim untuk Linux.

Langkah 3. Tulis beberapa kode untuk menyapa pemain

Pemain akan ingin tahu apa yang sedang terjadi dan apa yang harus mereka lakukan, jadi Anda harus mencetak beberapa teks untuk mereka.

Ini dilakukan dengan fungsi print() dengan Python. Untuk mencobanya, buka file baru dengan ekstensi.py, masukkan kode berikut ke dalamnya, simpan dan jalankan:
```
print("Selamat datang di permainan tebak angka!") print("Masukkan bilangan bulat antara 1 dan 1000:")
```

Langkah 4. Hasilkan nomor acak

Mari kita membuat game berbasis teks yang meminta pemain untuk menebak angka yang benar. Hal pertama yang perlu kita lakukan adalah menghasilkan angka acak di awal permainan sehingga pemain tidak selalu menebak angka yang sama. Karena nomornya akan tetap sama sepanjang program, Anda akan ingin menyimpan nomor acak dalam sebuah variabel.

Python tidak memiliki fungsi angka acak bawaan, tetapi memiliki pustaka standar (ini berarti pengguna tidak perlu menginstal tambahan apa pun) yang berfungsi. Jadi pergi ke awal kode Anda (sebelum fungsi print()) dan ketikkan baris import random.
Gunakan fungsi acak. Itu disebut randint(), ada di perpustakaan acak yang baru saja Anda impor, dan mengambil nilai minimal dan maksimal yang bisa dimiliki nomor sebagai argumen. Jadi kembali ke akhir kode Anda dan masukkan baris berikut:
```
rightNum = random.randint(0, 1000)
```

Langkah 5. Dapatkan masukan dari pemain

Dalam sebuah permainan, pemain ingin melakukan sesuatu atau berinteraksi dengan sesuatu. Dalam permainan berbasis teks, ini dimungkinkan dengan memasukkan teks. Sekarang kita memiliki nomor acak, baris kode berikutnya harus meminta pemain untuk memasukkan tebakan terbaik mereka.

Karena kode yang Anda masukkan mencetak instruksi untuk memasukkan nomor ke pemain, itu juga harus membaca nomor yang mereka masukkan. Ini dilakukan dengan input() di Python 3, dan raw_input() di Python 2. Anda harus menulis di Python 3, karena Python 2 akan segera usang. Tambahkan baris berikut ke kode Anda untuk menyimpan input pemain dalam variabel yang disebut angka:
```
penggunaNum = masukan()
```

Langkah 6. Ubah input pemutar menjadi tipe data yang dapat digunakan

Pemain telah memasukkan nomor-sekarang apa?

Buat input pemain berupa angka. Nah, ini mungkin terdengar membingungkan karena mereka baru saja memasukkan angka. Tapi ada alasan bagus: Python mengasumsikan bahwa semua input adalah teks, atau "string", seperti yang disebut dalam pemrograman. Teks ini berisi nomor yang ingin Anda dapatkan. Python memiliki fungsi yang mengubah string yang hanya berisi angka menjadi angka di dalamnya. Jenis:
```
penggunaNum = int(Numpengguna)
```

Langkah 7. Bandingkan nomor pemain dengan nomor yang benar

Setelah pemain memasukkan nomornya, Anda harus membandingkannya dengan nomor yang dibuat secara acak. Jika jumlahnya tidak sama, permainan Anda dapat membuat pemain mencoba nomor lain. Jika angkanya cocok, Anda dapat memberi tahu pemain bahwa mereka menebak dengan benar, dan keluar dari program. Ini dilakukan dengan kode berikut:

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

Langkah 8. Berikan umpan balik kepada pemain

Meskipun Anda telah memproses masukan mereka, pemain tidak akan melihat ini. Anda harus benar-benar mencetak hasilnya ke pemutar sehingga mereka mengerti apa yang terjadi.

Tentunya, Anda bisa memberi tahu pemain apakah nomor mereka benar atau salah. Tetapi dengan pendekatan itu, pemain mungkin harus menebak 1000 kali dalam kasus terburuk, yang akan sangat membosankan.
Jadi beri tahu pemain apakah jumlahnya terlalu kecil atau terlalu besar. Ini akan mengurangi jumlah tebakan mereka secara signifikan. Jika, misalnya, pemain menebak 500 terlebih dahulu, dan permainan menjawab "Terlalu besar. Coba lagi," hanya akan ada 500 angka yang mungkin, bukan 1000. Ini dilakukan dengan konstruksi if, jadi ganti print("Salah. Coba lagi.") dengan satu.
Ketahuilah bahwa memeriksa apakah dua angka sama dilakukan dengan ==, bukan dengan =. = memberikan nilai di sebelah kanannya ke variabel di sebelah kirinya!

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

Langkah 9. Uji kode Anda

Sebagai seorang programmer, Anda harus yakin bahwa kode Anda berfungsi sebelum menganggapnya selesai.

Saat memprogram dengan python, pastikan Anda mendapatkan lekukan yang benar. Kode Anda akan terlihat seperti ini:

import random print("Selamat datang di permainan tebak angka!") print("Masukkan bilangan bulat antara 1 dan 1000:") rightNum = random.randint(0, 1000) userNum = input() userNum = int(userNum) while userNum != rightNum: if userNum < rightNum: print("Terlalu kecil. Coba lagi:") if userNum > rightNum: print("Terlalu besar. Coba lagi:") userNum = int(input()) print("Anda dapat menebaknya benar.")

Langkah 10. Validasi input

Pemain seharusnya tidak dapat merusak permainan Anda hanya dengan memasukkan hal yang salah. "Memvalidasi input" berarti memastikan pemain memasukkan hal yang benar sebelum memprosesnya.

Buka game lagi dan coba masukkan apa pun yang bukan angka. Game akan keluar dengan ValueError. Untuk menghindari hal ini, Anda dapat menerapkan cara untuk memeriksa apakah input berupa angka.
Definisikan sebuah fungsi. Karena memvalidasi input cukup lama, dan Anda harus melakukannya beberapa kali, Anda harus mendefinisikan suatu fungsi. Ini tidak akan mengambil argumen dan mengembalikan nomor. Pertama, tulis def numInput(): di bagian atas kode Anda, langsung di bawah import random.
Dapatkan masukan pemain sekali. Gunakan fungsi input() dan tetapkan hasilnya ke variabel inp.
Ketika input pemain bukan angka, minta mereka memasukkan angka. Untuk memeriksa apakah string adalah angka, gunakan fungsi isdigit(), yang hanya mengizinkan bilangan bulat, jadi Anda tidak perlu memeriksanya secara terpisah.
Jika inputnya adalah angka, ubah dari string menjadi angka dan kembalikan hasilnya. Gunakan fungsi int() untuk mengonversi string menjadi integer. Ini akan membuat konversi dalam kode utama tidak diperlukan, dan Anda harus menghapusnya dari sana.
Ganti semua panggilan ke input() dalam kode utama dengan panggilan ke numInput().
Kode fungsi numInput() akan terlihat seperti ini:

def numInput(): inp = input() while not inp.isdigit(): print("Anda disuruh memasukkan bilangan bulat! Masukkan bilangan bulat:") inp = input() return int(inp)

Langkah 11. Uji permainan lagi

Masukkan hal-hal yang salah dengan sengaja untuk melihat apa yang terjadi, lalu perbaiki kesalahan yang muncul.

Coba masukkan beberapa teks ketika program meminta Anda untuk memasukkan nomor. Sekarang, alih-alih keluar dengan pesan kesalahan, program akan meminta nomor Anda lagi

Langkah 12. Sarankan untuk memulai kembali permainan setelah selesai

Dengan cara ini, pemain dapat memainkan game Anda lebih lama tanpa harus terus-menerus memulai ulang.

Masukkan semua kode kecuali impor dan definisi fungsi ke dalam while-loop. Tetapkan Benar sebagai kondisinya: ini akan selalu benar, sehingga loop akan berlanjut selamanya.
Tanyakan kepada pemain apakah mereka ingin bermain lagi setelah mereka menebak angka dengan benar. Gunakan fungsi print().
Jika mereka menjawab "Tidak", hilangkan pandangan. Jika mereka menjawab hal lain, lanjutkan. Breaking out dari loop dilakukan dengan pernyataan break.
Pindahkan "Selamat datang di permainan menebak angka" di luar loop sementara. Pemain mungkin tidak ingin disambut setiap kali mereka memainkan game. Pindahkan instruksi print("Selamat datang di permainan tebak angka!" di atas while True:, sehingga hanya akan tercetak satu kali, saat pengguna memulai permainan pertama.

Langkah 13. Uji permainan

Anda harus menguji game Anda setiap kali menerapkan fitur baru.

Pastikan untuk menjawab "Ya" dan "Tidak" setidaknya sekali untuk memastikan kedua opsi berfungsi. Berikut adalah tampilan kode Anda:

import random def numInput(): inp = input() while not inp.isdigit(): print("Anda disuruh memasukkan bilangan bulat! Masukkan bilangan bulat:") inp = input() return int(inp) print ("Selamat datang di permainan tebak angka!") while True: print("Masukkan bilangan bulat antara 1 dan 1000:") rightNum = random.randint(0, 1000) userNum = numInput() while userNum != rightNum: if userNum < rightNum: print("Terlalu kecil. Coba lagi:") if userNum > rightNum: print("Terlalu besar. Coba lagi:") userNum = numInput() print("Anda menebak dengan benar.") print("Apakah Anda ingin bermain lagi? Masukkan Tidak untuk keluar.") if input() == "No": break

Langkah 14. Tulis game berbasis teks lainnya

Bagaimana kalau menulis petualangan teks selanjutnya? Atau permainan kuis? Jadilah kreatif.

Tip: Kadang-kadang membantu untuk melihat dokumentasi jika Anda tidak yakin bagaimana sesuatu dilakukan atau bagaimana suatu fungsi digunakan. Dokumentasi Python 3 dapat ditemukan di https://docs.python.org/3/. Terkadang mencari apa pun yang ingin Anda lakukan di internet juga memberikan hasil yang baik.

Bagian 2 dari 3: Membuat Game dengan Grafik 2D

Langkah 1. Pilih perpustakaan grafis

Membuat grafik sangat rumit, dan sebagian besar bahasa pemrograman (termasuk Python, C++, C, JavaScript) hanya menyediakan dukungan minimal atau bahkan tidak ada untuk grafik di inti atau pustaka standar. Jadi Anda harus menggunakan perpustakaan eksternal untuk dapat membuat grafik, misalnya Pygame untuk Python.

Bahkan dengan perpustakaan grafis, Anda harus khawatir tentang hal-hal seperti cara menampilkan menu, cara memeriksa apa yang diklik pemain, cara menampilkan ubin, dan sebagainya. Jika Anda lebih suka fokus pada pengembangan game yang sebenarnya, Anda dapat menggunakan perpustakaan mesin game seperti Unity, yang mengimplementasikan hal-hal ini dengan mudah

Artikel ini akan menggunakan Python dengan Cocos2D untuk menunjukkan cara membuat platformer 2D sederhana. Beberapa konsep yang disebutkan mungkin tidak ada di mesin game lain. Lihat dokumentasi mereka untuk informasi lebih lanjut.

Langkah 2. Instal perpustakaan grafis yang Anda pilih

Cocos2D untuk Python mudah dipasang. Anda bisa mendapatkannya dari https://python.cocos2d.org/index.html, atau dengan menjalankan Sudo pip3 install cocos2d jika Anda menggunakan Linux.

Langkah 3. Buat direktori baru untuk game dan media Anda

Anda akan menggunakan hal-hal seperti gambar dan suara dalam game Anda. Simpan hal-hal ini di direktori yang sama dengan program. Direktori ini tidak boleh berisi apa pun sehingga Anda dapat dengan mudah melihat aset apa yang Anda miliki dalam game.

Langkah 4. Buat file kode baru di direktori baru

Sebut saja main, dengan ekstensi file untuk bahasa pemrograman Anda. Jika Anda menulis program yang besar dan kompleks di mana masuk akal untuk memiliki banyak file program, ini akan menunjukkan kepada Anda yang merupakan file utama.

Dalam contoh ini, kita akan membuat file bernama main.py yang akan berisi semua kode kita

Langkah 5. Buat jendela permainan

Ini adalah prasyarat dasar untuk game dengan grafik.

Impor sub-modul cocos2d yang diperlukan: cocos.director, cocos.scene dan cocos.layer. Ini dilakukan dengan from subModuleName import *, di mana nama sub-Modul adalah submodul yang ingin Anda impor. Perbedaan antara from … import * dan import … adalah Anda tidak harus meletakkan nama modul di depan semua yang Anda gunakan dari modul tersebut dengan yang pertama.
Tentukan subkelas MainMenuBgr dari ColorLayer. Ini pada dasarnya berarti bahwa setiap latar belakang menu utama yang Anda buat akan berperilaku seperti lapisan warna dengan beberapa perubahan yang Anda buat.
Mulai direktur cocos. Ini akan memberi Anda jendela baru. Jika Anda tidak menyetel teks, jendela akan memiliki teks yang sama dengan nama file (main.py), yang tidak akan terlihat profesional. Biarkan jendela diubah ukurannya dengan mengatur resizable ke True.
Tentukan fungsi showMainMenu. Anda harus memasukkan kode untuk menampilkan menu utama ke dalam suatu fungsi karena ini akan memungkinkan Anda untuk kembali ke menu utama dengan mudah dengan memanggil kembali fungsi tersebut.
Membuat heboh. Adegan terdiri dari satu lapisan untuk saat ini, yang merupakan objek dari kelas MainMenuBgr yang Anda tetapkan.
Jalankan adegan ini di jendela.

from cocos.director import * from cocos.scene import * from 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", resizable=True) showMainMenu()

Langkah 6. Tambahkan menu utama ke jendela

Selain gim yang sebenarnya, Anda perlu menambahkan menu yang dapat digunakan pemain untuk menutup jendela, di antara elemen lain yang dapat Anda tambahkan nanti.

Impor cocos.menu (sekali lagi dengan instruksi from) dan pyglet.app (kali ini dengan impor).
Definisikan MainMenu sebagai subclass dari Menu.
Mengatur perataan menu utama. Anda harus mengatur perataan vertikal dan horizontal secara terpisah.
Buat daftar item menu dan tambahkan ke menu. Anda harus memiliki item menu "Mulai Game" dan "Keluar" setidaknya. Setiap item menu harus ditempatkan di dalam tanda kurung. Setiap item harus memiliki label dan fungsi panggilan balik yang menentukan apa yang terjadi saat pemain mengkliknya. Untuk item "Mulai Game", gunakan fungsi startGame (Anda akan segera menulisnya), untuk item "Keluar", gunakan "pyglet.app.exit" (sudah ada). Buat menu sebenarnya dengan memanggil self.create_menu(menuItems).
Tentukan startGame(). Masukkan saja ke dalam definisi untuk saat ini, Anda akan menggantinya saat Anda menulis game yang sebenarnya.
Pergi ke tempat dalam kode Anda di mana Anda membuat adegan menuSc, dan tambahkan objek MainMenu ke dalamnya.

Seluruh kode Anda sekarang akan terlihat sebagai berikut:

dari cocos.director import * from cocos.menu import * from cocos.scene import * from cocos.layer import * import pyglet.app class MainMenuBgr(ColorLayer): def _init_(self): super(MainMenuBgr, self)._init_(0, 200, 255, 255) class MainMenu(Menu): def _init_(self): super(MainMenu, self)._init_("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem("Mulai Game ", startGame)), (MenuItem("Quit", pyglet.app.exit))] self.create_menu(menuItems) def startGame(): lulus def showMainMenu(): menuSc = Scene(MainMenuBgr()) menuSc.add(MainMenu()) director.run(menuSc) director.init(caption="IcyPlat - platformer sederhana", resizable=True) showMainMenu()

Langkah 7. Uji kode Anda

Uji kode lebih awal, selagi masih pendek dan relatif sederhana. Kemudian Anda dapat mengidentifikasi dan memperbaiki kesalahan apa pun dalam struktur dasar sebelum semuanya menjadi terlalu rumit.

Kode dari instruksi akan membuka jendela dengan judul "IcyPlat - platformer sederhana." Latar belakang berwarna biru muda dan Anda dapat mengubah ukuran jendela. Ketika Anda mengklik "Mulai Game" pada menu, seharusnya tidak terjadi apa-apa (belum). Ketika Anda mengklik "Keluar", jendela akan ditutup

Langkah 8. Buat sprite

Sprite adalah "objek permainan", atau gambar 2 dimensi. Sprite dapat berupa objek dalam game, ikon, dekorasi latar belakang, karakter, dan apa pun yang dapat Anda wakili dengan gambar dalam game. Kita akan mulai dengan membuat sprite untuk karakter yang dapat berinteraksi dengan pemain.

Impor submodule cocos.sprite dengan ekspresi from-import.
Temukan gambar untuk mewakili sprite. Anda tidak dapat menampilkan sprite jika Anda tidak memiliki gambar untuk itu. Anda dapat menggambarnya, atau mendapatkannya dari internet (perhatikan lisensinya, jika Anda berencana untuk menerbitkan game Anda). Untuk contoh ini, buka https://opengameart.org/content/tux-classic-hero-style dan simpan gambar-p.webp" />
Buat layer sebagai objek baru dari kelas ScrollableLayer. Kemudian, buat sprite sebagai objek Sprite dan atur posisinya menjadi (8, 250). Untuk referensi, titik (0, 0) ada di pojok kiri bawah. Ini cukup tinggi, tetapi itu akan memastikan penguin tidak terjebak dalam es.
Tambahkan sprite ke layer sprite.
Buat adegan baru dari layer 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 kodenya. Anda akan melihat sosok penguin kecil (atau apa pun yang Anda gambar) dengan latar belakang hitam setelah Anda mengklik Memulai permainan.

Langkah 9. Mimpikan lanskap Anda

Di sebagian besar gim, sprite Anda seharusnya tidak hanya mengambang di kehampaan. Mereka harus benar-benar berdiri di suatu permukaan, dengan sesuatu di sekitar mereka. Dalam game 2D, ini sering dilakukan dengan satu set ubin dan peta ubin. Kumpulan ubin pada dasarnya mengatakan jenis kotak permukaan dan kotak latar belakang yang ada, dan seperti apa bentuknya.

Buat satu set ubin. Set ubin untuk game ini akan sangat mendasar: satu ubin untuk es dan satu ubin untuk langit. Ubin es yang digunakan dalam contoh ini berasal dari sini, di bawah CC-BY-SA 3.0.
Buat gambar set ubin. Itu adalah gambar dari semua ubin, yang semuanya harus memiliki ukuran yang sama (edit jika tidak) dan memiliki ukuran yang ingin Anda lihat dalam permainan, bersebelahan. Simpan gambar Anda sebagai icyTiles.png.
Buat deskripsi kumpulan ubin. Itu file XML. File XML berisi informasi tentang seberapa besar ubin di gambar kumpulan ubin, gambar mana yang akan digunakan, dan di mana menemukan ubin di sana. Buat file XML bernama icyTiles.xml dengan kode di bawah ini:
```
     
```

Langkah 10. Buat peta ubin untuk lanskap Anda

Peta ubin adalah peta yang menentukan ubin mana yang berada di posisi mana di level Anda. Dalam contoh, Anda harus menentukan fungsi untuk menghasilkan peta ubin karena mendesain peta ubin dengan tangan sangat membosankan. Gim yang lebih maju biasanya memiliki semacam editor level, tetapi untuk menjadi terbiasa dengan pengembangan gim 2D, algoritme dapat memberikan level yang cukup baik.

Cari tahu berapa banyak baris dan kolom yang dibutuhkan. Untuk ini, bagi ukuran layar dengan ukuran ubin baik secara horizontal (kolom) dan vertikal (baris). Bulatkan angka ke atas; Anda memerlukan fungsi dari modul matematika untuk itu, jadi tambahkan dari batas impor matematika ke impor di bagian atas kode Anda.
Buka file untuk menulis. Ini akan menghapus semua konten file sebelumnya, jadi pilih nama yang belum ada file di direktori, seperti levelMap.xml.
Tulis tag pembuka ke dalam file.
Hasilkan peta ubin sesuai dengan algoritma. Anda menggunakan yang ada di kode di bawah ini, atau Anda bisa membuatnya sendiri. Pastikan untuk mengimpor fungsi randint dari modul secara acak: ini diperlukan agar kode di bawah ini berfungsi, dan apa pun yang Anda buat mungkin juga memerlukan bilangan bulat acak. Juga, pastikan untuk meletakkan ubin langit dan ubin es di lapisan yang berbeda: es itu padat, langit tidak.
Tulis tag penutup ke dalam file dan tutup file.

def generateTilemap(): colAmount = ceil(800 / 16)*3 # (lebar layar / ukuran ubin) * 3 rowAmount = ceil(600 / 16) # tinggi layar / ukuran ubin tileFile = open("levelMap.xml", " w") tileFile.write('\n\n\n') iceHeight = randint(1, 10) untuk i dalam range(0, colAmount): tileFile.write('') makeHole = False if randint(0, 50) == 10 dan i != 0: # jangan biarkan lubang di spawnpoint makeHole = Benar untuk j di range(0, rowAmount): if makeHole: tileFile.write('\n') else: if j <= iceHeight: tileFile.write('\n') else: tileFile.write('\n') iceHeight = randint(iceHeight-5, iceHeight+5) jika iceHeight < 0: # batasi ubin agar tidak terlalu rendah iceHeight = randint(1, 5) jika iceHeight > rowAmount: # batasi ubin agar tidak terlalu tinggi iceHeight = randint(int(rowAmount/2)-5, int(rowAmount/2)+5) tileFile.write('\n') tileFile.write ('\n\n') untuk i dalam range(0, colAmount): tileFile.write('') untuk j dalam range(0, rowAmount): tileFile.write('\n') tileFile.write('\ n') tileFile.write('\n\n') tileFile.close()

Langkah 11. Tampilkan peta ubin

Impor semuanya dari cocos.tiles lalu masuk ke fungsi startGame untuk itu.

Di awal fungsi startGame Anda, buat peta ubin menggunakan fungsi yang Anda tetapkan untuk itu.
Buat pengelola gulir baru. Lakukan ini langsung di bawah garis tempat Anda menambahkan sprite ke layernya.
Buat layer baru yang berisi ubin, yang akan dimuat dari peta ubin levelMap.xml yang dihasilkan oleh fungsi generateTilemap Anda.
Tambahkan lapisan non-padat, lapisan padat dan lapisan sprite ke manajer pengguliran, persis dalam urutan ini. Anda dapat menambahkan posisi-z jika Anda mau.
Alih-alih membuat adegan dari lapisan sprite, buat dari manajer pengguliran.

Fungsi startGame Anda sekarang akan terlihat seperti ini:

def startGame(): generateTilemap() # 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 = Adegan(scrMang) director.run(gameSc)

Langkah 12. Uji kode Anda

Anda harus sering menguji kode Anda untuk memastikan bahwa fitur baru yang Anda terapkan benar-benar berfungsi.

Kode dalam contoh sekarang harus menunjukkan beberapa lanskap es di belakang penguin. Jika penguin terlihat seperti melayang jauh di atas es, Anda tidak melakukan kesalahan apa pun, dan itu akan diperbaiki pada langkah berikutnya

Langkah 13. Tambahkan kontrol

Pemain memiliki lebih banyak cara untuk berinteraksi dengan program dalam game 2D daripada di game berbasis teks. Yang umum termasuk memindahkan sosok mereka ketika tombol yang benar ditekan.

Impor semuanya dari cocos.mapcolliders dan dari cocos.actions. Juga impor kunci dari pyglet.window.
"Deklarasikan" beberapa variabel global. Variabel global dibagi antar fungsi. Anda tidak dapat benar-benar mendeklarasikan variabel dengan Python, tetapi Anda harus mengatakan bahwa variabel global ada dalam kode utama sebelum menggunakannya. Anda dapat menetapkan 0 sebagai nilai karena suatu fungsi akan menangani penetapan nilai yang benar nanti. Jadi tambahkan di bawah ekspresi impor:
```
# "mendeklarasikan" variabel global keyboard = 0 scrMang = 0
```

Sesuaikan fungsi startGame Anda:

Katakanlah Anda menggunakan keyboard variabel global dan scrMang. Lakukan ini dengan menulis keyboard global, scrMang di bagian atas fungsi.
Jadikan jendela mendengarkan acara keyboard.
Beri tahu gambar untuk bertindak berdasarkan PlatformerController. Anda akan segera mengimplementasikan PlatformerController itu.
Buat penumbuk peta untuk menangani tabrakan antara ubin padat dan gambar.

def startGame(): keyboard global, scrMang generateTilemap() # 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_bump ='slide') fig.collision_handler = make_collision_handler(mapcollider, solidTiles) # scrMang = ScrollingManager() scrMang.add(nsoliTiles, z=-1) scrMang.add(solidTiles, z=0) scrMang.add(figLayer 1) # gameSc = Scene(scrMang) director.run(gameSc)

Buat pengontrol platformer. Inilah yang akan menggerakkan angka sesuai dengan penekanan tombol Anda.
- Tentukan pengontrol platformer sebagai subkelas Action.
- Tentukan kecepatan bergerak, kecepatan melompat dan gravitasi.
- Tentukan fungsi awal. Fungsi ini dipanggil sekali, ketika pengontrol platformer terhubung ke gambar. Ini harus mengatur kecepatannya ke 0 baik dalam arah x dan y.
- Tentukan fungsi langkah. Ini akan diulang saat adegan sedang berjalan.
- Beri tahu fungsi langkah untuk menggunakan keyboard variabel global dan scrMang.
- Dapatkan dan ubah kecepatannya. Simpan kecepatan x dan y dalam variabel terpisah. Atur kecepatan x ke 1 atau -1 (tergantung apakah tombol kiri atau kanan ditekan) dikalikan dengan kecepatan gerak. Tambahkan gravitasi ke kecepatan y. Kalikan dengan waktu henti sehingga bekerja dengan cara yang sama pada perangkat yang lebih lambat. Jika tombol spasi ditekan dan sosok itu berdiri di tanah, lompatlah dengan mengubah kecepatan y menjadi kecepatan lompat.
- Hitung ke mana angka itu harus bergerak. Kemudian biarkan penangan tabrakan menyesuaikan posisi itu jika berada di dalam ubin padat. Terakhir, pindahkan gambar ke posisi baru yang disesuaikan.
- Atur fokus manajer pengguliran pada gambar. Hal ini menyebabkan kamera bergerak dengan wajar saat sosok 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) def step(self, dt): global keyboard, scroller jika dt > 0.1: # jangan lakukan apapun saat downtime untuk mengembalikan vx besar, vy = self.target.velocity vx = (keyboard[key. RIGHT] - keyboard[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() new = last.copy() new.x += dx new.y += dy self.target.velocity = self.target.collision_handler(last, new, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus(*new.center)
```

Langkah 14. Uji kode Anda

Jika Anda mengikuti contoh, Anda sekarang dapat memindahkan penguin dengan tombol panah dan melompat dengan menekan tombol spasi. Selain itu, penguin sekarang seharusnya jatuh dan bukannya melayang di atas tanah.

Langkah 15. Buat akhir untuk permainan

Bahkan permainan yang bisa berlangsung tanpa henti harus memiliki kemungkinan kalah. Karena level yang Anda buat dalam contoh dengan fungsi memiliki akhir, Anda juga harus memungkinkan untuk menang dengan mencapai akhir itu. Jika tidak, pemain hanya akan melompat-lompat di atas balok es di sana, yang akan membosankan.

Di dalam pengontrol platformer, setelah set fokus, dapatkan posisi x dan y dari gambar. Jika posisi y kurang dari 0, panggil fungsi finishGame() (Anda akan menulisnya nanti) dengan "Game Over" sebagai argumen. Jika posisi x lebih besar dari ukuran layar dikalikan dengan 3 (Anda telah mengaturnya sebagai ukuran level sebelumnya).
```
posX, posY = self.target.position jika posY < 0: finishGame("Game Over") kembali jika posX > 800*3: # ukuran level finishGame("Level Completed") kembali
```
Tentukan finishMenu kelas. Itu harus seperti kelas menu utama yang Anda definisikan sebelumnya, tetapi alih-alih memiliki string kosong sebagai judul, itu harus menggunakan teks variabel yang digunakan fungsi _init_ sebagai argumen. Item menu harus diberi label "Coba lagi" dan "Keluar" sekarang, tetapi fungsi yang mereka panggil tetap sama.
```
class FinishMenu(Menu): def _init_(self, text): super(FinishMenu, self)._init_(text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem("Coba lagi", startGame)), (MenuItem("Keluar", pyglet.app.exit))] self.create_menu(menuItems)
```
Tentukan fungsi finishGame(). Itu harus mengambil teks sebagai argumen. Itu harus membuat adegan keluar dari latar belakang menu utama, FinishMenu dengan argumen teks diteruskan ke menu ini. Maka itu harus menjalankan adegan ini.
```
def finishGame(teks): menuSc = Scene(MainMenuBgr()) menuSc.add(FinishMenu(teks)) director.run(menuSc)
```

Langkah 16. Tambahkan kredit

Di sinilah Anda mendapatkan kredit untuk kode mengagumkan Anda, serta memberikan kredit kepada orang lain yang membantu Anda selama ini. Jika Anda menggunakan gambar dari situs web lain (dengan izin), pastikan untuk mengaitkan gambar itu dengan pembuatnya.

Buat file KREDIT dan masukkan semua kredit Anda di sana, seperti ini:

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

Kembali ke kode Python Anda dan impor Label dari cocos.text.

Tentukan subclass Credits of Layer. Dalam fungsi _init_, baca file CREDITS dan buat label teks pada posisi yang benar dari setiap baris di dalamnya.

class Credits(Layer): def _init_(self): super(Credits, self)._init_() credFile = open("CREDITS", "r") creds = credFile.read() creds = creds.split("\n ") untuk i dalam range(0, len(creds)): credLabel = Label(creds, font_size=32, anchor_x="left", anchor_y="top") credLabel.position = 25, 500-(i +1)*40 self.add(credLabel)

Buka kelas menu utama Anda dan tambahkan item menu berlabel "Kredit" yang memanggil fungsi showCredits saat diklik.
Tentukan subkelas BackToMainMenuButton dari Menu. Jadikan ini menu dengan satu item, berlabel "Kembali", yang memanggil fungsi showMainMenu. "Menu" ini, yang lebih mirip tombol, harus disejajarkan secara vertikal ke bawah dan horizontal ke atas.
```
class BackToMainMenuButton(Menu): def _init_(self): super(BackToMainMenuButton, self)._init_("") self.menu_valign = BOTTOM self.menu_halign = KIRI menuItems = [(MenuItem("Back", showMainMenu))] self. buat_menu(Item menu)
```

Tentukan fungsi showCredits. Itu harus membuat adegan dari lapisan MainMenuBgr dan lapisan Kredit dan menjalankan adegan itu.

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

Langkah 17. Periksa kode Anda

Ketika Anda merasa telah menyelesaikan kode Anda, Anda harus memeriksa semuanya lagi. Ini dapat membantu Anda memperhatikan apakah ada sesuatu yang dapat dioptimalkan, atau apakah ada beberapa baris yang tidak perlu yang lupa Anda hapus. Jika Anda mengikuti contoh, seluruh kode Anda sekarang akan terlihat sebagai berikut:

dari cocos.director impor * dari cocos.menu impor * dari cocos.scene impor * dari cocos.layer impor * dari cocos.sprite impor * dari cocos.tiles impor * dari cocos.mapcolliders impor * dari cocos.actions impor * dari cocos.text import Label import pyglet.app dari pyglet.window import key from math import ceil from random import randint # "mendeklarasikan" variabel global keyboard = 0 scrMang = 0 class MainMenuBgr(ColorLayer): def _init_(self): super(MainMenuBgr, self)._init_(0, 200, 255, 255) class MainMenu(Menu): def _init_(self): super(MainMenu, self)._init_("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem("Mulai Game", startGame)), (MenuItem("Credits", showCredits)), (MenuItem("Quit", pyglet.app.exit))] self.create_menu(menuItems) class Credits(Layer): def _init_(self): super(Credits, self)._init_() credFile = open("CREDITS", "r") creds = credFile.read() creds = creds.split("\n") untuk i dalam jangkauan (0, len(creds)): credLabel = Label(creds, font_size=32, anchor_x="kiri", anchor_y="top") credLabel.position = 25, 500-(i+1)*40 kelas self.add(credLabel) BackToMainMenuButton(Menu): def _init_(self): super (BackToMainMenuButton, self)._init_("") self.menu_valign = BOTTOM self.menu_halign = KIRI menuItems = [(MenuItem("Back", showMainMenu))] self.create_menu(menuItems) class FinishMenu(Menu): def _init_(self, text): super(FinishMenu, self)._init_(text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem("Coba lagi", startGame)), (MenuItem("Keluar", 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) def step(self, dt): global keyboard, scroller jika dt > 0.1: # jangan lakukan apapun saat downtime terlalu besar kembalikan vx, vy = self.target.velocity vx = (keyboard[key. RIGHT] - keyboard [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() new = last.copy() new.x += dx new.y + = dy self.target.velocity = self.target.collision_handler(last, new, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus(* new.center) posX, posY = self.target.position jika posY < 0: finishGame("Game Over") kembali jika posX > 800*3: # ukuran level finishGame("Level Completed") mengembalikan def finishGame(teks): menuSc = Scene(MainMenuBgr()) menuSc.add(FinishMenu(text)) director.run(menuSc) def showCredits(): credSc = Scene(MainMenuBgr()) credSc.add(Credits()) credSc.add(BackToMainMenuButton()) director.run(credSc) def generateTilemap(): colAmount = ceil(800 / 16)*3 # (lebar layar / ukuran ubin) * 3 rowAmount = ceil(600 / 16) # tinggi layar / ukuran ubin tileFile = buka ("levelMap.xml", "w") tileFile.write('\n\n\n') iceHeight = randint(1, 10) for i in range(0, colAmount): tileFile.write('') makeHole = Salah jika rand int(0, 50) == 10 dan i != 0: # jangan biarkan lubang di spawnpoint makeHole = Benar untuk j dalam range(0, rowAmount): if makeHole: tileFile.write('\n') else: if j <= iceHeight: tileFile.write('\n') else: tileFile.write('\n') iceHeight = randint(iceHeight-5, iceHeight+5) if iceHeight < 0: # batasi ubin agar tidak terlalu low iceHeight = randint(1, 5) jika iceHeight > rowAmount: # batasi ubin agar tidak terlalu tinggi iceHeight = randint(int(rowAmount/2)-5, int(rowAmount/2)+5) tileFile.write('\n ') tileFile.write('\n\n') untuk i dalam range(0, colAmount): tileFile.write('') untuk j dalam range(0, rowAmount): tileFile.write('\n') tileFile.write('\n') tileFile.write('\n\n') tileFile.close() def startGame(): keyboard global, scrMang generateTilemap() # 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(keybo ard) # fig.do(PlatformerController()) mapcollider = RectMapCollider(velocity_on_bump='slide') fig.collision_handler = make_collision_handler(mapcollider, solidTiles) # scrMang = ScrollingManager() scrMang.add(nsoliTiles) add(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", resizable=True) showMainMenu()

Itu total 168 baris, dan 152 baris jika Anda hanya menghitung kodenya. Ini membuat tampak seperti banyak, tetapi untuk permainan yang begitu kompleks, ini sebenarnya adalah jumlah yang kecil.

Langkah 18. Selesai

Sekarang uji permainannya. Ketika Anda memprogram sesuatu, Anda harus memeriksa apakah itu berfungsi setiap kali Anda mengimplementasikan sesuatu yang baru. Juga, Anda mungkin ingin memainkan game yang Anda tulis untuk beberapa waktu.

Bagian 3 dari 3: Memublikasikan Game

Langkah 1. Tuliskan dependensi

Siapa pun yang menggunakan komputer lain tidak akan menginstal perangkat lunak dan pustaka yang sama seperti Anda. Jadi, Anda harus memastikan semua orang yang memasang game Anda tahu persis apa yang mereka perlukan untuk menjalankannya. Anda tidak harus menuliskan semua dependensi dari semua dependensi dari semua dependensi dan seterusnya, tetapi Anda setidaknya harus menulis dependensi dari paket Anda dan dependensinya.

Langkah 2. Pastikan Anda memiliki izin untuk menggunakan semua media

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

Seringkali ada beberapa kondisi, seperti harus memberi kredit kepada penulis atau berbagi modifikasi media di bawah lisensi yang sama. Terkadang Anda dapat menggunakan grafik tanpa menghubungkan pembuatnya selama Anda tidak mengenakan biaya untuk game tersebut. Jika Anda harus memberi kredit kepada penulis, lakukan di tempat yang terlihat jelas, seperti tab "Kredit" di game Anda.
Ada juga media dengan hak cipta yang diklaim dan tidak ada lisensi yang ditentukan, terkadang dengan beberapa teks seperti "Semua hak dilindungi undang-undang". Jika itu masalahnya, Anda harus mendapatkan izin eksplisit dari pembuatnya sebelum memasukkannya ke dalam game Anda.
Perpustakaan biasanya dirilis di bawah lisensi yang memungkinkan mereka untuk digunakan sebagai perpustakaan. Pengecualian penting adalah GPL tanpa pengecualian tautan: Lisensi semacam itu hanya memungkinkan untuk menggunakannya dalam program dengan lisensi tertentu. Dan Anda harus selalu membaca setidaknya poin dasar dari lisensi untuk memastikan apapun yang Anda lakukan dengan media atau perpustakaan diperbolehkan.

Peringatan: Menggunakan media atau perpustakaan dengan cara yang tidak diizinkan oleh lisensi dalam game yang Anda publikasikan dapat membawa Anda ke masalah hukum yang serius. Jadi tanyakan kepada penulisnya atau hindari media sama sekali jika Anda tidak yakin apakah penggunaan Anda diperbolehkan.

Langkah 3. Tentukan kondisi yang Anda inginkan untuk mempublikasikan game Anda

Apakah Anda akan menjual game Anda? Apakah Anda ingin mengizinkan orang lain menggunakan gambar dan ide Anda? Meskipun Anda harus berhati-hati dengan media yang Anda gunakan dalam proyek Anda, Anda biasanya dapat memutuskan bagaimana Anda ingin mengizinkan orang lain menggunakan permainan Anda. Anda dapat menggunakan lisensi Creative Commons CC0 untuk merilis game Anda di domain publik. Untuk mengizinkan distribusi dan modifikasi dalam beberapa kondisi sambil mempertahankan beberapa hak, cobalah lisensi Gnu General Public License (GPL) atau Berkeley Software Distribution (BSD). Atau, Anda dapat membuat perangkat lunak Anda berpemilik, artinya tidak seorang pun diizinkan untuk mendistribusikan atau memodifikasinya tanpa izin Anda.

Meskipun Anda dapat menghasilkan uang dengan menjual game, kecil kemungkinan orang akan membeli game pertama Anda yang biasanya memiliki sedikit fitur dan tidak ada yang istimewa. Juga, jika program gratis tidak berfungsi, orang yang mengunduhnya akan kecewa. Namun, jika mereka membayarnya, mereka akan meminta uang mereka kembali, menyebabkan lebih banyak masalah bagi Anda dan pengguna. Jadi pertimbangkan untuk membuat beberapa program pertama Anda tersedia secara gratis

Langkah 4. Putuskan bagaimana Anda ingin mempublikasikan game Anda

Setiap metode memiliki beberapa kelebihan dan kekurangan, jadi Anda harus memutuskan sendiri.

Menerbitkannya di situs web:

Jika Anda memiliki situs web, Anda dapat mengunggah game agar tersedia untuk diunduh. Pastikan untuk memberikan instruksi yang jelas tentang cara menginstal perangkat lunak, serta semua dependensi yang diperlukan. Kerugiannya adalah pemain harus menginstal dependensi secara manual, yang mungkin sulit bagi sebagian orang.
Membuat paket untuk manajer paket:

Ada manajer paket yang berbeda, seperti apt, Yum, dan Homebrew, yang memudahkan orang untuk menginstal aplikasi di lingkungan berbasis Linux dan Linux. Semuanya memiliki format paket yang berbeda. Hal yang baik tentang paket adalah mereka secara otomatis menginstal semua dependensi (jika Anda mengonfigurasinya dengan benar). Jadi pemain hanya perlu menginstal paket Anda dan kemudian dapat memainkan game. Masalahnya adalah ada banyak manajer paket yang berbeda pada platform yang berbeda, jadi Anda harus bekerja keras untuk menyediakan paket untuk semua yang paling umum.

Langkah 5. Arahkan perhatian ke program Anda

Pertimbangkan untuk mengunggah program Anda ke repositori paket utama, seperti yang dikelola Ubuntu dan Debian, untuk memungkinkan penginstalan yang mudah. Juga, posting di forum yang sesuai, seperti bagian proyek GameDev atau bagian dari tigSource. Tapi jangan kecewa jika game pertama Anda tidak menjadi terkenal. Jika Anda memiliki ide yang disukai banyak orang, permainan Anda bisa menjadi terkenal.

Tips

Sabar dan mau belajar. Pemrograman terkadang bisa membuat frustrasi!
Jika Anda bertanya-tanya bagaimana sesuatu dilakukan di game lain, dan game tersebut open-source, Anda dapat melihat kode sumbernya.
Saat mencari media, coba cari konten yang ada di domain publik. Cari gambar dan musik "Creative Commons" atau "Domain Publik", dan gunakan situs web seperti https://opengameart.org atau
Jangan menyalin sebagian besar kode tanpa memeriksa lisensinya. Hal ini sering dilarang, dan jika tidak, biasanya memerlukan atribusi.
Jangan membuat spam atau posting di tempat yang tidak pantas saat mempromosikan game Anda. Ini kemungkinan akan membuat Anda diblokir dari halaman tersebut, hanya mengganggu, dan akan merusak reputasi Anda.