Cara membuat platformer dengan python

Tutorial ini menunjukkan cara menggunakan Python dan perpustakaan Arcade untuk membuat game platformer 2D. Anda akan belajar bekerja dengan Sprite dan Tiled Map Editor untuk membuat game Anda sendiri. Anda dapat menambahkan koin, landai, platform bergerak, musuh, dan lainnya

Di akhir setiap bab tutorial ini terdapat tautan ke kode sumber lengkap. Tutorial dibagi menjadi beberapa bagian ini

• Langkah 1 - Instal dan Buka Jendela
• Langkah 2 - Tambahkan Sprite
• Langkah 3 - Objek Adegan
• Langkah 4 - Tambahkan Kontrol Pengguna
• Langkah 5 - Tambahkan Gravitasi
• Langkah 6 - Tambahkan Kamera
• Langkah 7 - Tambahkan Koin Dan Suara
• Langkah 8 - Tampilkan Skor
• Langkah 9 - Gunakan Editor Peta Ubin
• Langkah 10 - Beberapa Level dan Lapisan Lainnya
• Langkah 11 - Tambahkan Tangga, Properti, dan Platform Bergerak
• Langkah 12 - Tambahkan Animasi Karakter, dan Kontrol Keyboard yang Lebih Baik
• Langkah 13 - Tambahkan Musuh
• Langkah 14 - Memindahkan Musuh
• Langkah 15 - Tabrakan dengan Musuh
• Langkah 16 - Menembak Peluru
• Langkah 17 - Tampilan

Saat ini ada beberapa contoh lagi yang berkembang di luar tutorial. Anda dapat melihat kode sumber untuk contoh tersebut serta setiap bab dalam tutorial di Arcade Github di https. //github. com/pythonarcade/arcade/tree/development/arcade/examples/platform_tutorial

Tutorial ini juga diperluas menjadi game berfitur lengkap yang dikembangkan oleh komunitas Arcade. Anda dapat melihat proyek itu di Github di https. //github. com/pythonarcade/community-platformer

Dalam tutorial sebelumnya kami memperkenalkan pengembangan game grafis dengan PyGame, membahas cara mengembangkan game 2D dengan sprite animasi dan interaksi pengguna. Dalam tutorial ini, kita akan melangkah lebih jauh dan membuat platformer 2D, di mana Anda dapat membuat alien berjalan dan melompati ruangan yang penuh dengan kotak. Tutorial PyGame sebelumnya bukanlah prasyarat untuk mencoba yang ini

Kami akan fokus pada animasi dan gerakan dasar untuk menciptakan basis yang kokoh dari mana Anda dapat terus membangun seluruh permainan platform, lengkap dengan musuh, power-up, dan berbagai level

Mulai

Buat repl baru dan pilih "PyGame" dari tarik-turun bahasa

Anda akan melihat "Python3 with PyGame" ditampilkan di konsol default dan panel terpisah di Replit IDE tempat Anda dapat melihat dan berinteraksi dengan game yang akan Anda buat

Sebelum kita mulai menulis kode, kita membutuhkan beberapa sprite, yang telah kita sediakan di sini. Ekstrak file ZIP ini dan tambahkan file di dalamnya ke repl Anda menggunakan fungsi

def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()

    player = Player(100, 200)

Dalam tutorial ini, kita akan membangun file

def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()

    player = Player(100, 200)

def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()

    player = Player(100, 200)

Menyiapkan perancah

Kami akan mulai dengan kode berikut di

def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()

    player = Player(100, 200)

import pygame

WIDTH = 400
HEIGHT = 300
BACKGROUND = (0, 0, 0)

def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

if __name__ == "__main__":
    main()

Di bagian atas file, kami mengimpor

def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()

    player = Player(100, 200)

def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()

    player = Player(100, 200)

Kemudian, dalam metode

def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()

    player = Player(100, 200)

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

Putaran permainan adalah tempat segala sesuatu terjadi. Karena game kita berjalan dalam waktu nyata, kode kita harus terus-menerus mengumpulkan penekanan tombol dan gerakan mouse pengguna, dan terus-menerus menggambar ulang layar sebagai respons terhadap penekanan tombol dan gerakan mouse tersebut, dan peristiwa lain dalam game. Kami mencapai ini dengan while loop yang tak terbatas. PyGame menggunakan baris

def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()

    player = Player(100, 200)

Sekarang mari menggambar sesuatu di layar hitam ini. Game kita akan memiliki dua sprite. alien, yang akan menjadi pemain, dan sebuah kotak. Untuk menghindari duplikasi kode, mari buat kelas induk

def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()

    player = Player(100, 200)

def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()

    player = Player(100, 200)

class Sprite(pygame.sprite.Sprite):
    def __init__(self, image, startx, starty):
        super().__init__()

        self.image = pygame.image.load(image)
        self.rect = self.image.get_rect()

        self.rect.center = [startx, starty]

    def update(self):
        pass

    def draw(self, screen):
        screen.blit(self.image, self.rect)

def main():

Karena class ini akan menjadi induk untuk semua objek lain dalam game kita, kita membuatnya cukup sederhana. Ini memiliki tiga metode

•     player = Player(100, 200)
  
      boxes = pygame.sprite.Group()
  

  0, yang akan membuat sprite dengan gambar tertentu dan persegi panjang PyGame berdasarkan gambar tersebut. Persegi panjang ini awalnya akan ditempatkan pada posisi yang ditentukan oleh

      player = Player(100, 200)
  
      boxes = pygame.sprite.Group()
  

  1 dan

      player = Player(100, 200)
  
      boxes = pygame.sprite.Group()
  

  2. Persegi panjang sprite adalah apa yang akan digunakan PyGame untuk gerakan sprite dan deteksi tabrakan

•     player = Player(100, 200)
  
      boxes = pygame.sprite.Group()
  

  3, yang akan kita gunakan di kelas anak untuk menangani peristiwa, seperti penekanan tombol, gravitasi, dan tabrakan

•     player = Player(100, 200)
  
      boxes = pygame.sprite.Group()
  

  4, yang kita gunakan untuk menggambar sprite. Kami melakukan ini dengan memasukkannya ke layar

Sekarang kita dapat membuat objek

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()

    player = Player(100, 200)

class Sprite(pygame.sprite.Sprite):
    # ...
class Player(Sprite):
    def __init__(self, startx, starty):
        super().__init__("p1_front.png", startx, starty)

class Box(Sprite):
    def __init__(self, startx, starty):
        super().__init__("boxAlt.png", startx, starty)

def main():

Kami akan menambahkan lebih banyak kode ke pemain nanti, tetapi pertama-tama mari menggambar sprite ini di layar

Menggambar sprite

Mari kembali ke fungsi

def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()

    player = Player(100, 200)

def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()

    player = Player(100, 200)

Maka kita perlu meletakkan kotak di bawah kaki pemain. Karena kami akan menempatkan banyak sprite, kami akan membuat PyGame untuk memasukkannya

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

Sprite kotak kami memiliki lebar 70 piksel, dan kami perlu menjangkau lebar layar 400 piksel. Kita bisa melakukan ini dalam

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

    player = Player(100, 200)

    boxes = pygame.sprite.Group()
    for bx in range(0,400,70):
        boxes.add(Box(bx,300))

Sekarang kita perlu kembali ke loop game dan menambahkan beberapa kode untuk mewujudkannya. Pertama, kita akan membuat PyGame menempatkan acara baru di antrean acara, lalu kita akan memanggil fungsi

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

    player = Player(100, 200)

    boxes = pygame.sprite.Group()
    for bx in range(0,400,70):
        boxes.add(Box(bx,300))

    while True:
        pygame.event.pump()
        player.update()
        # ...

Untuk permainan yang lebih kompleks, kami ingin mengulang beberapa sprite dan memanggil metode

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

Berbeda dengan

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

    player = Player(100, 200)

    boxes = pygame.sprite.Group()
    for bx in range(0,400,70):
        boxes.add(Box(bx,300))

    while True:
        pygame.event.pump()
        player.update()

        # Draw loop
        screen.fill(BACKGROUND)
        player.draw(screen)
        boxes.draw(screen)
        pygame.display.flip()

        clock.tick(60)

Putaran permainan kami sekarang disiapkan untuk memperbarui dan menggambar setiap sprite dalam permainan di setiap siklus putaran permainan. Jika Anda menjalankan permainan sekarang, Anda akan melihat pemain dan garis kotak di layar

Selanjutnya, kita akan menambahkan beberapa interaksi pengguna

Membuat Pemain Berjalan

Mari kembali ke objek

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

    player = Player(100, 200)

    boxes = pygame.sprite.Group()
    for bx in range(0,400,70):
        boxes.add(Box(bx,300))

    while True:
        pygame.event.pump()
        player.update()
        # ...

class Player(Sprite):
    # ...
    def move(self, x, y):
        self.rect.move_ip([x,y])

Sekarang kita memiliki cara untuk memindahkan pemain, saatnya menambahkan metode

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

PyGame menyediakan beberapa cara berbeda untuk memeriksa status keyboard. Secara default, antrian kejadiannya mengumpulkan

    while True:
        pygame.event.pump()
        player.update()
        # ...

    while True:
        pygame.event.pump()
        player.update()
        # ...

    while True:
        pygame.event.pump()
        player.update()
        # ...

Kami membutuhkan cara untuk memindahkan pemain setiap kali tombol panah ditekan, tidak hanya setelah ditekan. Jadi alih-alih mengandalkan acara, kami akan menanyakan status saat ini dari semua tombol keyboard dengan

    while True:
        pygame.event.pump()
        player.update()
        # ...

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

Metode ini mengembalikan tupel 0 dan 1 yang menunjukkan status penekanan setiap tombol pada keyboard. Dengan demikian, kami dapat mendeteksi apakah tombol panah kiri atau kanan saat ini ditekan dengan mengindeks tuple dengan konstanta keyboard PyGame, seperti itu

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

Jalankan permainan. Anda sekarang dapat menggerakkan pemain ke kiri dan ke kanan, meskipun sangat lambat. Mari kita percepat dan kurangi ketergantungan kode kita pada angka ajaib pada saat yang sama dengan memberi pemain variabel

    while True:
        pygame.event.pump()
        player.update()
        # ...

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

Saat ini pemain meluncur dari satu sisi ke sisi lain, tetapi kami telah mengupload gambar untuk animasi siklus berjalan, jadi mari terapkan itu sekarang. Pertama, kami akan menambahkan beberapa kode pemuatan gambar ke metode

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

Dalam kode ini, pertama-tama kita menetapkan gambar alien awal kita sebagai

    while True:
        pygame.event.pump()
        player.update()
        # ...

    while True:
        pygame.event.pump()
        player.update()

        # Draw loop
        screen.fill(BACKGROUND)
        player.draw(screen)
        boxes.draw(screen)
        pygame.display.flip()

        clock.tick(60)

    while True:
        pygame.event.pump()
        player.update()

        # Draw loop
        screen.fill(BACKGROUND)
        player.draw(screen)
        boxes.draw(screen)
        pygame.display.flip()

        clock.tick(60)

    while True:
        pygame.event.pump()
        player.update()

        # Draw loop
        screen.fill(BACKGROUND)
        player.draw(screen)
        boxes.draw(screen)
        pygame.display.flip()

        clock.tick(60)

    while True:
        pygame.event.pump()
        player.update()

        # Draw loop
        screen.fill(BACKGROUND)
        player.draw(screen)
        boxes.draw(screen)
        pygame.display.flip()

        clock.tick(60)

    while True:
        pygame.event.pump()
        player.update()

        # Draw loop
        screen.fill(BACKGROUND)
        player.draw(screen)
        boxes.draw(screen)
        pygame.display.flip()

        clock.tick(60)

Sekarang mari kita terapkan animasi yang sebenarnya. Buat metode baru bernama

    while True:
        pygame.event.pump()
        player.update()

        # Draw loop
        screen.fill(BACKGROUND)
        player.draw(screen)
        boxes.draw(screen)
        pygame.display.flip()

        clock.tick(60)

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

Di sini kami menyetel gambar pemain saat ini ke bingkai siklus berjalan yang sedang kami jalani. Jika pemain menghadap ke kiri, kita gunakan

    while True:
        pygame.event.pump()
        player.update()

        # Draw loop
        screen.fill(BACKGROUND)
        player.draw(screen)
        boxes.draw(screen)
        pygame.display.flip()

        clock.tick(60)

    while True:
        pygame.event.pump()
        player.update()

        # Draw loop
        screen.fill(BACKGROUND)
        player.draw(screen)
        boxes.draw(screen)
        pygame.display.flip()

        clock.tick(60)

Mari tambahkan ini ke metode

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

Jika kita bergerak ke kiri atau kanan, kita mengatur

    while True:
        pygame.event.pump()
        player.update()

        # Draw loop
        screen.fill(BACKGROUND)
        player.draw(screen)
        boxes.draw(screen)
        pygame.display.flip()

        clock.tick(60)

class Player(Sprite):
    # ...
    def move(self, x, y):
        self.rect.move_ip([x,y])

class Player(Sprite):
    # ...
    def move(self, x, y):
        self.rect.move_ip([x,y])

Jalankan game sekarang untuk melihat gerakan siklus berjalan pemain. Setelah itu, saatnya membuatnya melompat

Membuat Pemain Melompat

Agar pemain kita bisa melompat, kita perlu menerapkan empat hal

1. Gerakan ke atas dipicu oleh tombol panah atas
2. Gravitasi, untuk membawa pemain kembali turun setelah mencapai puncak lompatannya
3. Deteksi tabrakan, sehingga pemain tidak jatuh ke tanah
4. Sebuah animasi melompat

Memicu lompatan

Untuk sekadar membuat pemain naik, kita bisa menambahkan

class Player(Sprite):
    # ...
    def move(self, x, y):
        self.rect.move_ip([x,y])

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

Jika Anda mencoba permainan sekarang, Anda akan melihat beberapa masalah dengan pendekatan ini. Selain kekurangan gravitasi, kita hanya bisa melompat lurus ke atas, dan harus melepaskan tombol panah kiri dan kanan sebelum melakukannya. Sebagian besar gameplay di platformer bergantung pada kemampuan pemain untuk melompat ke kiri atau kanan, jadi ini tidak akan berhasil. Untuk memperbaikinya, kami akan mengubah

class Player(Sprite):
    # ...
    def move(self, x, y):
        self.rect.move_ip([x,y])

class Player(Sprite):
    # ...
    def move(self, x, y):
        self.rect.move_ip([x,y])

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

Kita juga mungkin ingin bisa melompat dengan kecepatan yang berbeda dengan kecepatan berjalan kita, jadi mari kita definisikan variabel lain dan gunakan itu

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

Itu lebih baik, tapi sekarang kita benar-benar membutuhkan gravitasi

Menambahkan gravitasi

Hingga saat ini, kami hanya memiliki satu operasi yang memanipulasi kecepatan horizontal atau vertikal kami per putaran pembaruan. Dengan penambahan gravitasi, ini akan berubah, jadi kita perlu merestrukturisasi kode kita untuk menghitung pergerakan horizontal dan vertikal bersih kita sebelum memanggil

    while True:
        pygame.event.pump()
        player.update()
        # ...

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

class Sprite(pygame.sprite.Sprite):
    def __init__(self, image, startx, starty):
        super().__init__()

        self.image = pygame.image.load(image)
        self.rect = self.image.get_rect()

        self.rect.center = [startx, starty]

    def update(self):
        pass

    def draw(self, screen):
        screen.blit(self.image, self.rect)

def main():

Kami telah menambahkan dua variabel,

class Player(Sprite):
    # ...
    def move(self, x, y):
        self.rect.move_ip([x,y])

class Player(Sprite):
    # ...
    def move(self, x, y):
        self.rect.move_ip([x,y])

    while True:
        pygame.event.pump()
        player.update()
        # ...

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

    while True:
        pygame.event.pump()
        player.update()
        # ...

Tapi tunggu. Masuk akal jika kecepatan horizontal disetel ke 0 pada awal setiap loop pembaruan, karena langsung dikontrol oleh penekanan tombol pemain. Saat panah kiri ditahan, pemain bergerak ke kiri dengan kecepatan 4 piksel per putaran; . Kecepatan vertikal akan kurang dapat dikendalikan – sambil menekan panah atas akan memulai lompatan, melepaskannya tidak akan menghentikan pemain di udara. Oleh karena itu, kecepatan vertikal harus bertahan di antara loop

Kita dapat melakukannya dengan memindahkan definisi

class Player(Sprite):
    # ...
    def move(self, x, y):
        self.rect.move_ip([x,y])

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

class Sprite(pygame.sprite.Sprite):
    def __init__(self, image, startx, starty):
        super().__init__()

        self.image = pygame.image.load(image)
        self.rect = self.image.get_rect()

        self.rect.center = [startx, starty]

    def update(self):
        pass

    def draw(self, screen):
        screen.blit(self.image, self.rect)

def main():

Sekarang kita bisa menerapkan gravitasi. Kami akan melakukan ini dengan menambahkan konstanta kecil ke kecepatan vertikal pemain (

class Player(Sprite):
    # ...
    def move(self, x, y):
        self.rect.move_ip([x,y])

class Sprite(pygame.sprite.Sprite):
    def __init__(self, image, startx, starty):
        super().__init__()

        self.image = pygame.image.load(image)
        self.rect = self.image.get_rect()

        self.rect.center = [startx, starty]

    def update(self):
        pass

    def draw(self, screen):
        screen.blit(self.image, self.rect)

def main():

Mulai permainan sekarang, dan pemain akan jatuh lurus ke bawah, menembus tanah dan keluar dari layar. Gravitasi berfungsi, tapi kami butuh tempat untuk mendaratkan pemain

Menambahkan deteksi tabrakan

Deteksi tabrakan adalah elemen kunci dari sebagian besar game grafis. Di PyGame, sebagian besar pendeteksian tabrakan melibatkan pemeriksaan apakah persegi panjang berpotongan satu sama lain. Untungnya, PyGame menyediakan sejumlah built-in yang berguna untuk melakukan hal ini, jadi kita tidak perlu memikirkan terlalu banyak tentang cara kerja tabrakan internal.

Mari tambahkan beberapa deteksi tabrakan sekarang, di dekat bagian atas metode

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

class Sprite(pygame.sprite.Sprite):
    def __init__(self, image, startx, starty):
        super().__init__()

        self.image = pygame.image.load(image)
        self.rect = self.image.get_rect()

        self.rect.center = [startx, starty]

    def update(self):
        pass

    def draw(self, screen):
        screen.blit(self.image, self.rect)

def main():

Metode PyGame ini membutuhkan dua argumen. satu sprite dan sekelompok sprite. Ini mengembalikan apakah sprite diberikan sebagai argumen pertama, i. e. pemain, bertabrakan dengan salah satu sprite dalam grup yang diberikan sebagai argumen kedua, i. e. kotak-kotak. Jadi kita akan tahu bahwa pemain berada di kotak saat kembali

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

Kita dapat meneruskan grup

    player = Player(100, 200)

    boxes = pygame.sprite.Group()
    for bx in range(0,400,70):
        boxes.add(Box(bx,300))

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

class Sprite(pygame.sprite.Sprite):
    def __init__(self, image, startx, starty):
        super().__init__()

        self.image = pygame.image.load(image)
        self.rect = self.image.get_rect()

        self.rect.center = [startx, starty]

    def update(self):
        pass

    def draw(self, screen):
        screen.blit(self.image, self.rect)

def main():

Sekarang kita dapat mengetahui apakah pemain berada di tanah, kita dapat mencegah melompat di udara dengan menambahkan kondisi pada kode lompat kita

class Sprite(pygame.sprite.Sprite):
    def __init__(self, image, startx, starty):
        super().__init__()

        self.image = pygame.image.load(image)
        self.rect = self.image.get_rect()

        self.rect.center = [startx, starty]

    def update(self):
        pass

    def draw(self, screen):
        screen.blit(self.image, self.rect)

def main():

Untuk menghentikan pemain agar tidak jatuh ke tanah, kami akan menambahkan kode berikut ke implementasi gravitasi kami

class Sprite(pygame.sprite.Sprite):
    def __init__(self, image, startx, starty):
        super().__init__()

        self.image = pygame.image.load(image)
        self.rect = self.image.get_rect()

        self.rect.center = [startx, starty]

    def update(self):
        pass

    def draw(self, screen):
        screen.blit(self.image, self.rect)

def main():

Menambahkan animasi melompat

Terakhir, kami akan menggunakan gambar alien terakhir kami (

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

class Sprite(pygame.sprite.Sprite):
    def __init__(self, image, startx, starty):
        super().__init__()

        self.image = pygame.image.load(image)
        self.rect = self.image.get_rect()

        self.rect.center = [startx, starty]

    def update(self):
        pass

    def draw(self, screen):
        screen.blit(self.image, self.rect)

def main():

Kemudian buat metode

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

class Sprite(pygame.sprite.Sprite):
    def __init__(self, image, startx, starty):
        super().__init__()

        self.image = pygame.image.load(image)
        self.rect = self.image.get_rect()

        self.rect.center = [startx, starty]

    def update(self):
        pass

    def draw(self, screen):
        screen.blit(self.image, self.rect)

def main():

Animasi lompat kami hanya memiliki satu bingkai, jadi kodenya jauh lebih sederhana daripada yang kami gunakan untuk animasi berjalan kami. Untuk memicu metode ini saat pemain berada di udara, ubah implementasi gravitasi seperti itu

class Sprite(pygame.sprite.Sprite):
    def __init__(self, image, startx, starty):
        super().__init__()

        self.image = pygame.image.load(image)
        self.rect = self.image.get_rect()

        self.rect.center = [startx, starty]

    def update(self):
        pass

    def draw(self, screen):
        screen.blit(self.image, self.rect)

def main():

Jalankan game, dan Anda harus bisa berlari dan melompat. Berhati-hatilah agar tidak jatuh dari tepi

Menyempurnakan Game

Pada titik ini, kami memiliki permainan kami bekerja pada tingkat dasar, tetapi itu bisa menggunakan beberapa perbaikan. Pertama, lompatannya cukup tidak responsif terhadap masukan pengguna. menekan panah atas untuk waktu yang lama menghasilkan lompatan ukuran yang sama. Kedua, deteksi tabrakan kami hanya akan mencegah pemain jatuh dari lantai, tidak berjalan menembus dinding atau melompati langit-langit

Kami akan mengulangi kode kami untuk memperbaiki kedua kekurangan ini

Membuat variabel lompatan

Alangkah baiknya jika pemain dapat mengontrol ketinggian lompatan mereka dengan menahan tombol lompat untuk jangka waktu yang berbeda. Ini cukup sederhana untuk diterapkan – kita hanya perlu cara untuk mengurangi kecepatan lompatan jika pemain melepaskan tombol lompat saat pemain masih bergerak ke atas. Tambahkan kode berikut ke metode

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

class Sprite(pygame.sprite.Sprite):
    # ...
class Player(Sprite):
    def __init__(self, startx, starty):
        super().__init__("p1_front.png", startx, starty)

class Box(Sprite):
    def __init__(self, startx, starty):
        super().__init__("boxAlt.png", startx, starty)

def main():

Di sini kami telah menambahkan variabel instan

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

Sekarang mari tambahkan variabel melompat ke metode

    player = Player(100, 200)

    boxes = pygame.sprite.Group()

class Sprite(pygame.sprite.Sprite):
    # ...
class Player(Sprite):
    def __init__(self, startx, starty):
        super().__init__("p1_front.png", startx, starty)

class Box(Sprite):
    def __init__(self, startx, starty):
        super().__init__("boxAlt.png", startx, starty)

def main():

Pernyataan

class Player(Sprite):
    # ...
    def move(self, x, y):
        self.rect.move_ip([x,y])

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

Coba permainan sekarang, dan Anda akan melihat ketinggian lompatan yang berbeda saat menekan tombol panah ke atas dengan ringan dibandingkan saat Anda menahannya. Bermain-main dengan nilai

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

Menyempurnakan deteksi tabrakan

Seperti disebutkan di atas, satu-satunya deteksi tabrakan yang kami terapkan berlaku untuk tanah di bawah kaki pemain, sehingga dia dapat berjalan menembus dinding dan melompat menembus langit-langit. Lihat ini sendiri dengan menambahkan beberapa kotak di atas dan di samping pemain dalam metode

def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()

    player = Player(100, 200)

class Sprite(pygame.sprite.Sprite):
    # ...
class Player(Sprite):
    def __init__(self, startx, starty):
        super().__init__("p1_front.png", startx, starty)

class Box(Sprite):
    def __init__(self, startx, starty):
        super().__init__("boxAlt.png", startx, starty)

def main():

Masalah lain yang mungkin telah Anda perhatikan adalah bahwa pemain tenggelam ke dalam tanah setelah beberapa lompatan – ini diakibatkan oleh ketidaktepatan pendeteksian tabrakan kami

Kami akan memperbaiki masalah ini dengan membuat perubahan halus pada cara kami menangani tabrakan dengan kotak. Daripada memutuskan bahwa kita berada di tanah saat sprite pemain bertabrakan dengan kotak, kita akan memeriksa apakah pemain berada 1 piksel di atas tabrakan dengan kotak. Kami kemudian akan menerapkan prinsip yang sama untuk kiri, kanan dan atas, menghentikan pemain tepat sebelum tabrakan

Pertama, mari beri pemain metode

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

class Sprite(pygame.sprite.Sprite):
    # ...
class Player(Sprite):
    def __init__(self, startx, starty):
        super().__init__("p1_front.png", startx, starty)

class Box(Sprite):
    def __init__(self, startx, starty):
        super().__init__("boxAlt.png", startx, starty)

def main():

Di sini, kami memindahkan pemain dengan jumlah tertentu, memeriksa tabrakan, lalu memindahkan pemain kembali. Gerakan bolak-balik ini terjadi sebelum pemain ditarik ke layar, sehingga pengguna tidak akan melihat apapun

Mari ubah centang

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

class Sprite(pygame.sprite.Sprite):
    # ...
class Player(Sprite):
    def __init__(self, startx, starty):
        super().__init__("p1_front.png", startx, starty)

class Box(Sprite):
    def __init__(self, startx, starty):
        super().__init__("boxAlt.png", startx, starty)

def main():

Jalankan game sekarang, dan Anda mungkin dapat melihat sedikit perbedaan dalam cara pemain berdiri di tanah dari sebelumnya

Ini belum menyelesaikan masalah tabrakan horizontal dan ke atas kita. Untuk itu, kita harus menerapkan metode

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

    while True:
        pygame.event.pump()
        player.update()
        # ...

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

class Sprite(pygame.sprite.Sprite):
    # ...
class Player(Sprite):
    def __init__(self, startx, starty):
        super().__init__("p1_front.png", startx, starty)

class Box(Sprite):
    def __init__(self, startx, starty):
        super().__init__("boxAlt.png", startx, starty)

def main():

Kemudian kita akan memeriksa tabrakan, jadi kita harus mulai meneruskan

    player = Player(100, 200)

    boxes = pygame.sprite.Group()
    for bx in range(0,400,70):
        boxes.add(Box(bx,300))

    while True:
        pygame.event.pump()
        player.update()
        # ...

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

class Sprite(pygame.sprite.Sprite):
    # ...
class Player(Sprite):
    def __init__(self, startx, starty):
        super().__init__("p1_front.png", startx, starty)

class Box(Sprite):
    def __init__(self, startx, starty):
        super().__init__("boxAlt.png", startx, starty)

def main():

Tapi tunggu. Kode ini hanya akan berfungsi sebagaimana mestinya jika kita bergerak ke bawah dan

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

class Sprite(pygame.sprite.Sprite):
    # ...
class Player(Sprite):
    def __init__(self, startx, starty):
        super().__init__("p1_front.png", startx, starty)

class Box(Sprite):
    def __init__(self, startx, starty):
        super().__init__("boxAlt.png", startx, starty)

def main():

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)

class Sprite(pygame.sprite.Sprite):
    # ...
class Player(Sprite):
    def __init__(self, startx, starty):
        super().__init__("p1_front.png", startx, starty)

class Box(Sprite):
    def __init__(self, startx, starty):
        super().__init__("boxAlt.png", startx, starty)

def main():

Sekarang lakukan hal yang sama untuk

    while True:
        screen.fill(BACKGROUND)
        pygame.display.flip()

        clock.tick(60)