Python adalah bahasa pemrograman yang sangat bagus bagi orang yang ingin belajar membuat program, serta sempurna untuk siapapun yang ingin menyelesaikan suatu permasalahan tanpa bergantung pada *boilerplate code*. [Arcade](http://arcade.academy/) adalah library Python untuk membuat game 2D yang mudah digunakan dan bisa dipakai untuk berbagai hal saat kita sudah berpengalaman menggunakannya. Di artikel ini, kita akan belajar bagaimana menggunakan Python dan Arcade untuk membuat game. 

Penulis asli tutorial ini telah menggunakan PyGame (*library* lain untuk membuat game) selama hampir 10 tahun. Alasan Ia berganti menggunakan Arcade ialah karena banyaknya bug PyGame yang belum pernah [diperbaiki](https://stackoverflow.com/questions/10148479/artifacts-when-drawing-primitives-with-pygame). 

## Pemasangan

Arcade, seperti *package* Python lainnya tersedia lewat [PyPi](https://pypi.python.org/pypi) yang artinya bisa kita pasang dengan perintah **pip** (atau perintah [pipenv](https://opensource.com/article/18/2/why-python-devs-should-use-pipenv)). Jika suda memasang Python sebelumnya, buka sebuah jendela *command prompt* baru di Windows dan ketikkan:

```
pip install arcadepip install arcade
```

Atau di MacOS dan Linux tuliskan:

```
pip3 install arcade
```

Untuk lebih lengkapnya, lihat halaman [Arcade installation documentation](http://arcade.academy/installation.html). 

## Membuat Gambar Sederhana

Kita bisa membuat gambar sederhana seperti gambar senyum di bawah ini dengan beberapa baris kode:

![smile face image](https://opensource.com/sites/default/files/styles/panopoly_image_original/public/smiley_face.png?itok=wLA63nV0)

Kodekode di bawah menunjukkan bagaimana kita bisa menggunakan perintah [Arcade](http://arcade.academy/quick_index.html#drawing-module) untuk menggambarnya. Perhatikan bahwa kita tidak perlu menulis kelas bahkan fungsi. Pemrograman yang bisa memberikan umpan balik visual sangat bermanfaat untuk orang yang baru belajar pemrograman. 

```python
import arcade

# Mengatur ukuran layar
SCREEN_WIDTH = 600
SCREEN_HEIGHT = 600

# Membuka jendela baru. Mengatur nama jendela dan dimensinya (lebar dan tinggi)
arcade.open_window(SCREEN_WIDTH, SCREEN_HEIGHT, "Drawing Example")

# Mengatur warna latar belakang menjadi putih
# Untuk daftar nama warna lihat:
# http://arcade.academy/arcade.color.html
# Warna bisa juga dipakai dalam format (red, green, blue) dan 
# (red, green, blue, alpha).
arcade.set_background_color(arcade.color.WHITE)

# Mulai proses render. Harus ditulis sebelum perintah drawing.
arcade.start_render()

# Menggambar wajah
x = 300
y = 300
radius = 200
arcade.draw_circle_filled(x, y, radius, arcade.color.YELLOW)

# Menggambar mata kanan
x = 370
y = 350
radius = 20
arcade.draw_circle_filled(x, y, radius, arcade.color.BLACK)

# Menggambar mata kiri
x = 230
y = 350
radius = 20
arcade.draw_circle_filled(x, y, radius, arcade.color.BLACK)

# Menggambar senyum
x = 300
y = 280
width = 120
height = 100
start_angle = 190
end_angle = 350
arcade.draw_arc_outline(x, y, width, height, arcade.color.BLACK, start_angle, end_angle, 10)

# Menampilkan hasil gambar (drawing)
arcade.finish_render()

# Biarkan jendela terbuka sampai user menutupnya dengan tombol 'close
arcade.run()
```

## Menggunakan Fungsi

Tentu saja, menulis kode di *global context* kurang baik untuk dilakukan. Untungnya, menulis program dengan fungsi tidak sulit dilakukan. Di bawah ini adalah contoh dimana kita menggambar pohon pinus di posisi (x, y) tertentu dengan sebuah fungsi:

```python
def draw_pine_tree(x, y):
    """ This function draws a pine tree at the specified location. """
    
    # Menggambar segitiga di bagian atas. 
    # Kita butuh tiga poin x, y untuk menggambar segitiga
    arcade.draw_triangle_filled(x + 40, y,       # Poin 1
                                x, y - 100,      # Poin 2
                                x + 80, y - 100, # Poin 3
                                arcade.color.DARK_GREEN)

    # Menggambar batang pohonnya
    arcade.draw_lrtb_rectangle_filled(x + 30, x + 50, y - 100, y - 140,
                                      arcade.color.DARK_BROWN)
```

Untuk contoh lengkapnya, lihat [drawing with functions](http://arcade.academy/examples/drawing_with_functions.html).

![classes and functions](https://opensource.com/sites/default/files/styles/panopoly_image_original/public/classes_and_functions.png?itok=4jXZuroK)

Programmer yang lebih berpengalaman akan tahu bahwa program harus memuat gambar terlebih dahulu ke kartu grafis sebelum meminta kartu grafis tersebut untuk menampilkannya sebagai sebuah *batch*. [Arcade mendukung teknik](http://arcade.academy/examples/shape_list_demo.html) ini. Menggambar 10.000 persegi panjang satu persatu akan memakan waktu 0.800 detik. Menggambar mereka sebagai *batch* hanya memerlukan waktu 0.001 detik. 

## Kelas Window

Program yang lebih besar biasanya akan diturunkan dari kelas [Window](http://arcade.academy/arcade.html#arcade.application.Window), atau menggunakan [decorator](http://arcade.academy/examples/decorator_drawing_example.html#decorator-drawing-example). Hal ini memungkinkan programmer untuk menulis kode yang melakukan proses gambar, mengubah, dan meng-*handle* input dari user di fungsi yang telah ditentukan. Template untuk program berbasis Window adalah sebagai berikut:

```python
import arcade

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


class MyGame(arcade.Window):
    """ Main application class. """

    def __init__(self, width, height):
        super().__init__(width, height)

        arcade.set_background_color(arcade.color.AMAZON)

    def setup(self):
        # Set up your game here
        pass

    def on_draw(self):
        """ Render the screen. """
        arcade.start_render()
        # Your drawing code goes here

    def update(self, delta_time):
        """ All the logic to move, and the game logic goes here. """
        pass


def main():
    game = MyGame(SCREEN_WIDTH, SCREEN_HEIGHT)
    game.setup()
    arcade.run()


if __name__ == "__main__":
    main()
```

Kelas Window memiliki beberapa method yang bisa di-*override* (ditimpa dengan menambah proses khusus oleh kita sendiri) untuk mengubah fungsi sebuah program. Berikut beberapa fungsi yang paling umum:

- `on_draw`: Seluruh kode untuk menggambar layar ditulis di sini.
- `update`: Semua kode untuk memindahkan konten game ditulis disini. Fungsi ini akan dipanggil sekitar 60 kali tiap detik. 
- `on_key_press`: Mendeteksi setiap kali sebuah tombol ditekan.
- `on_key_release`: Mendeteksi saat sebuah tombol dilepas setelah ditekan.
- `on_mouse_motion`: Dipanggil setiap kali mouse bergerak.
- `on_mouse_press`: Dipanggil saat tombol mouse di tekan.
- `set_viewport`: Fungsi ini dipakai di game scrolling, saat dunia game lebih luas dari apa yang dilihat di layar. Memanggil  `set_viewport` memungkinkan programmer untuk mengatur bagian dunia game mana yang akan tampil ke layar. 

## Sprites

Sprites adalah sebuah teknik membuat objek 2D di Arcade. Arcade memiliki sebuah metode untuk mempermudah menampilkan, menggerakkan, dan menganimasikan *sprites*. Kita juga bisa memakai sprites untuk mendeteksi tabrakan antar objek. 

### Membuat sebuah sprite

Membuat sebuah instance kelas Sprite Arcade sangat mudah. Programmer hanya memerlukan nama file dari gambar yang ingin ditampilkan, lalu sebuah angka untuk mengskalakan (memperbesar atau memperkecil berdasarkan rasio). Misal:

```python
SPRITE_SCALING_COIN = 0.2

coin = arcade.Sprite("coin_01.png", SPRITE_SCALING_COIN)
```

Kode ini akan membuat sebuah sprite menggunakan gambar yang disimpan di file `coin_01.png`. Gambar ini akan diperkecil menjadi 20% dari ukuran aslinya. 

![sprites collecting coins](https://opensource.com/sites/default/files/styles/panopoly_image_original/public/sprite_collect_coins1.png?itok=jv1wu_A4)

### Spites Lists

Sprites biasanya dikelompokkan kedalam *list*. *List* ini dibuat untuk mempermudah manajemen sprites tersebut. Sprites di dalam lists menggunakan OpenGL untuk melakukan *batch-draw* *sprites* sebagai group. Kode di bawah menyiapkan sebuah game dengan satu karakter pemain, dan beberapa koin yang bisa diambil oleh pemain. Kita memiliki dua *list*, satu untuk karakter pemain dan satu lagi untuk koin. 

```python
def setup(self):
    """ Set up the game and initialize the variables. """

    # Membuat list sprite
    self.player_list = arcade.SpriteList()
    self.coin_list = arcade.SpriteList()

    # Skor
    self.score = 0

    # Menyiapkan pemain
    # Gambar karakter dari kenney.nl
    self.player_sprite = arcade.Sprite("images/character.png", SPRITE_SCALING_PLAYER)
    self.player_sprite.center_x = 50 # Posisi awal pemain
    self.player_sprite.center_y = 50
    self.player_list.append(self.player_sprite)

    # Membuat koin
    for i in range(COIN_COUNT):

        # Membuat instance koin
        # Gambar koin dari kenney.nl
        coin = arcade.Sprite("images/coin_01.png", SPRITE_SCALING_COIN)

        # Posisi koin
        coin.center_x = random.randrange(SCREEN_WIDTH)
        coin.center_y = random.randrange(SCREEN_HEIGHT)

        # Menambah koin ke lists
        self.coin_list.append(coin)
```

Kita lalu bisa menggambar semua koin di dalam lists:

```python
def on_draw(self):
    """ Draw everything """
    arcade.start_render()
    self.coin_list.draw()
    self.player_list.draw()
```

### Mendeteksi tabrakan sprite

Fungsi `check_for_collision_with_lists` memungkinkan kita untuk mendeteksi apakah ada sebuah *sprite* yang bertabrakan dengan sprite lain di dalam sebuah list. Kita bisa memanfaatkannya untuk mengetahui koin dan disentuh oleh pemain. Dengan menggunakan *forloop*, kita bisa menghapus koin dari game (untuk koin yang disentuh) dan menaikkan skor. 

```python
def update(self, delta_time):
    # Membuat list koin yang bertabrakan dengan pemain
    coins_hit_list = arcade.check_for_collision_with_list(self.player_sprite, self.coin_list)

    # Lakukan looping ke sprite yang ditabrak, lalu, hapus dari game, dan tambahkan skor
    for coin in coins_hit_list:
        coin.kill()
        self.score += 1
```

Untuk contoh lebih lengkap, cek http://arcade.academy/examples/sprite_collect_coins.html

## Physics

Banyak game memiliki fitur *physics* untuk mensimulasikan gravitasi atau "efek nyata" lainnya. Misal, kita mungkin tidak ingin pemain untuk melewati sebuah dinding. 

### Game top-down

![spring moving to walls](https://opensource.com/sites/default/files/styles/panopoly_image_original/public/sprite_move_walls1.png?itok=qKZmvJTC)

Untuk game *top-down *sederhana, program Arcade memerlukan sebuah *list* dinding yang tidak bisa ditembus oleh pemain (atau objek lainnya). Penulis biasanya memberinya nama `wall_list`. Lalu sebuah *engine* *physics* dibuat di kelas Window dengan kode:

```python
self.physics_engine = arcade.PhysicsEngineSimple(self.player_sprite, self.wall_list)
```

Objek `player_sprite` diberikan sebuah *movement vector* dengan dua atribut yaitu `change_x` dan `change_y`. Contoh sederhananya ialah kita ingin menggerakkan karakter pemain dengan tombol panah di keyboard:

```python
MOVEMENT_SPEED = 5

def on_key_press(self, key, modifiers):
    """Dipanggil setiap tombol di tekan. """

    if key == arcade.key.UP:
        self.player_sprite.change_y = MOVEMENT_SPEED
    elif key == arcade.key.DOWN:
        self.player_sprite.change_y = -MOVEMENT_SPEED
    elif key == arcade.key.LEFT:
        self.player_sprite.change_x = -MOVEMENT_SPEED
    elif key == arcade.key.RIGHT:
        self.player_sprite.change_x = MOVEMENT_SPEED

def on_key_release(self, key, modifiers):
    """Dipanggil setiap tombol dilepas. """

    if key == arcade.key.UP or key == arcade.key.DOWN:
        self.player_sprite.change_y = 0
    elif key == arcade.key.LEFT or key == arcade.key.RIGHT:
        self.player_sprite.change_x = 0
```

Meskipun kode di atas mengatur kecepatan pemain, ia tidak menggerakkannya. Pada *method* update di kelas Window, memanggil physics_engine.update() akan menggerakkan pemain, tapi tidak menembus dinding. 

```python
def update(self, delta_time):
    """ Menggerakkan pemain """

     self.physics_engine.update()
```

Untuk kode lengkapnya lihat http://arcade.academy/examples/sprite_move_walls.html

### Platformers

![sprite tiled map](https://opensource.com/sites/default/files/styles/panopoly_image_original/public/sprite_tiled_map1.png?itok=8aNa-1Ex)

Bergerak ke samping untuk game platformer cukup mudah. Programmer hanya perlu mengganti engine physics-nya ke `PhysicsEnginePlatformer` dan menambahkan konstanta *gravity*:

```python
self.physics_engine = arcade.PhysicsEnginePlatformer(self.player_sprite,
                                                     self.wall_list, 
                                                     gravity_constant=GRAVITY)
```

Pembaca bisa memakai program seperti [Tiled](http://www.mapeditor.org/) untuk menyusun* tiles/block *yang menjadi sebuah level. 

Untuk contoh lengkap, lihat file http://arcade.academy/examples/sprite_tiled_map.html

Untuk *engine physics* 2D yang lebih lengkap, lihat libarary [PyMunk](http://arcade.academy/examples/pymunk_platformer.html#pymunk-platformer).

## Belajar dari contoh

Salah satu cara belajar paling baik ialah melalui contoh. Library Arcade memiliki banyak [contoh program](http://arcade.academy/examples/index.html) yang bisa dilihat untuk mengetahui proses pembuatannya. Contoh-contoh ini menunjukkan konsep yang banyak ditanyakan oleh orang yang belajar membuat game. 

Jika Arcade sudah terpasang, menjalankan contoh program di atas sangat mudah. Setiap contoh memiliki komentar di bagian awal program dengan perintah yang harus dijalankan untuk memuat contoh tersebut, misalnya:

```
python -m arcade.examples.sprite_moving_platforms
```

## Penutup

Arcade memungkinkan kita untuk membuat game dengan kode yang mudah dipahami. Banyak programmer baru telah membuat game menarik tidak lama setelah mereka [mulai belajar](http://arcade.academy/sample_games.html). Selamat mencoba. 

*Diterjemahkan dari [How to create a 2D game with Python and the Arcade library](https://opensource.com/article/18/4/easy-2d-game-creation-python-and-arcade) karya [Paul Vincent Craven](https://opensource.com/users/paul-vincent-craven)*

Belajar Cara Membuat Game 2D dengan Python dan Arcade

GenAI Video Fest adalah ajang kompetisi video kreatif yang diselenggarakan oleh CODEPOLITAN bekerjasama dengan Alibaba Cloud.

Kami menantang kreator, tech-enthusiast, dan siapa saja untuk mendobrak batas imajinasi menggunakan teknologi Generative AI terbaru. Di sini, kamu wajib menggunakan WAN Model Studio dari Alibaba Cloud sebagai tools utama untuk menghasilkan karya videomu (bisa dikombinasikan dengan tools editing lainnya).

Tunjukkan pada dunia bagaimana teknologi dan kreativitas bisa bersatu menciptakan karya visual yang berdampak!

Kategori Kompetisi
Pilih satu dari empat tema besar ini untuk karyamu:
* Humanity (Kemanusiaan): Cerita yang menyentuh hati, sosial, dan kepedulian antar sesama.
* Sports (Olahraga): Energi, semangat juang, dan dinamika dunia olahraga.
* Entertainment (Hiburan): Komedi, musik, video klip, atau parodi yang menghibur.
* Science (Sains): Visualisasi masa depan, teknologi, alam semesta, atau penemuan ilmiah.

Total Prize Pool senilai Rp 250.000.000 menunggu para pemenang!
* Top Winners Rewards: Uang Tunai, Alibaba Cloud Credits (hingga $500), Merchandise Eksklusif, dan SWAG CODEPOLITAN.
* Lucky Draw Event: Kesempatan menang hadiah tambahan bagi peserta yang beruntung.
* Massive Exposure: Karya terbaik akan di-highlight di media sosial CODEPOLITAN, Alibaba Cloud, dan channel industri kreatif lainnya.
* Special Access (Khusus Alumni RuangAI): Dapatkan 2 Token untuk klaim Kelas Spesialisasi di RuangAI secara gratis.

Jangan sampai ketinggalan tanggal penting ini:
* Pendaftaran & Submission: 23 Desember 2024 - 23 Januari 2025
* Penjurian (Judging Phase): 24 - 26 Januari 2025
* Pengumuman Pemenang: 27 Januari 2025

Cara Ikutan:
1. Daftar: Klik tombol "Daftar Sekarang" dan pastikan kamu punya akun RuangAI.
2. Join Discord: Masuk ke server Discord komunitas untuk info teknis dan diskusi.
3. Create: Buat video kreatifmu menggunakan WAN Model Studio (Alibaba Cloud) sesuai kategori pilihan.
4. Upload & Submit: Unggah videomu ke media sosial (IG/TikTok/YouTube) dan submit link karyamu di halaman submission RuangAI.

Ikuti kompetisi video Generative AI terbesar dari CODEPOLITAN dan Alibaba Cloud! Gunakan teknologi WAN Model Studio untuk menyulap ide liarmu menjadi visual memukau. Rebut total hadiah senilai Rp 250.000.000!

GenAI Video Fest

Beasiswa Basic Cybersecurity adalah program inisiatif dari JagoanSiber yang dirancang untuk membuka wawasan masyarakat luas tentang dunia keamanan digital. Program ini hadir untuk menjawab kebutuhan talenta keamanan siber yang tinggi, dimulai dengan membangun pemahaman fundamental yang kokoh.

Program ini berbentuk Kelas Online Belajar Mandiri (Self-Paced Learning) berbasis video. Peserta diberikan keleluasaan penuh untuk mengakses materi kapan saja dan di mana saja tanpa terikat jadwal, sehingga sangat fleksibel bagi pelajar, mahasiswa, maupun pekerja profesional.

Kelebihan utama program ini adalah aksesnya yang 100% GRATIS dan terbuka untuk siapa saja tanpa syarat latar belakang IT. Peserta akan dibimbing langsung oleh Mahrus Qusaery, seorang praktisi keamanan siber berpengalaman, yang akan mengupas tuntas materi dasar yang krusial.

Program beasiswa kelas online gratis untuk mempelajari dasar keamanan siber dari nol. Belajar mandiri berbasis video langsung dari praktisi ahli, Mahrus Qusaery.

Belajar Cara Membuat Game 2D dengan Python dan Arcade

Learning

KelasFullstack

RuangAI

JagoanSiber

Baca Artikel Lainnya

Tips Tetap Termotivasi Saat Belajar Pemrograman

Kaya Mendadak, Programmer Ini Berhasil Selesaikan Puzzle Bernilai $50,000

Nenek 82 Tahun Ini Buktikan Semua Bisa Jadi Programmer

Phaser 3, Framework Game HTML5 Jaman Now

Distro Linux Khusus Hacking Selain Kali Linux

Berbagai Sertifikasi Untuk Programmer yang Perlu Diketahui