Farih.co.id
Home Programming Cara Menambahkan Scroll Kamera di Game Python

Cara Menambahkan Scroll Kamera di Game Python

Salah satu fitur umum yang akan Anda temukan di banyak game adalah kamera bergulir yang mengikuti Anda saat Anda bergerak di dunia game. Efek ini dapat menambah kedalaman dan realisme pada game Anda dan meningkatkan pengalaman gameplay secara keseluruhan.

Ada banyak cara berbeda untuk mengimplementasikan kamera bergulir di PyGame, jadi pastikan Anda memahami perbedaannya.

Membuat Game Sederhana

Sebelum memulai, instal pip pada perangkat Anda dan gunakan perintah di bawah ini untuk menginstal modul PyGame:

pip install pygame

Sekarang, Anda dapat membuat game sederhana dengan persegi panjang pemain dan dua platform statis. Pemain dapat bergerak ke kiri dan ke kanan menggunakan tombol panah.

Anda dapat menemukan kode lengkap untuk proyek ini repo GitHub.

Mulailah dengan mengimpor modul pygame. Kemudian, inisialisasi, dan buat jendela permainan menggunakan pygame.display.set_mode() fungsi. Kemudian, atur judul jendela dan buat objek jam untuk mengatur frekuensi gambar.

import pygame

pygame.init()

WINDOW_WIDTH = 800
WINDOW_HEIGHT = 600

screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))

pygame.display.set_caption(“My Simple Game”)

clock = pygame.time.Clock()

BACKGROUND_COLOR = (255, 255, 255)

 

Selanjutnya, siapkan pemutar dan platform statis. Tentukan ukuran pemain dan posisi awalnya.

PLAYER_WIDTH = 50
PLAYER_HEIGHT = 50

player_x = WINDOW_WIDTH // 2 – PLAYER_WIDTH // 2
player_y = WINDOW_HEIGHT – PLAYER_HEIGHT – 20

PLAYER_SPEED = 10

RECTANGLE_COLOR_1 = (255, 0, 0)
RECTANGLE_COLOR_2 = (0, 0, 255)

rectangle_1 = pygame.Rect(200, 200, 100, 100)
rectangle_2 = pygame.Rect(500, 300, 150, 50)

 

Kemudian, buat lingkaran permainan yang menangani peristiwa dan memperbarui layar. Di loop, periksa kejadian seperti keluar dari game atau memindahkan pemain menggunakan tombol panah.

while True:
    
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            quit()

screen.fill(BACKGROUND_COLOR)

pygame.draw.rect(screen, RECTANGLE_COLOR_1, rectangle_1)
pygame.draw.rect(screen, RECTANGLE_COLOR_2, rectangle_2)

player_rect = pygame.Rect(player_x, player_y, PLAYER_WIDTH,
PLAYER_HEIGHT)

pygame.draw.rect(screen, (0, 0, 0), player_rect)

pygame.display.update()

clock.tick(30)

 

Menyiapkan Kamera

Sekarang Anda memiliki permainan sederhana dengan persegi panjang pemutar dan dua platform statis, Anda dapat mulai mengerjakan kamera. Di PyGame, kamera pada dasarnya hanyalah offset yang bekerja pada semua objek yang Anda gambar ke layar. Artinya, jika Anda menggerakkan kamera ke kiri, semua yang ada di layar akan tampak bergerak ke kanan.

Untuk menyiapkan kamera, pertama-tama Anda harus menentukan variabel untuk menahan offset X kamera. Panggil variabel ini kamera_offset_x dan inisialisasi ke 0.


camera_offset_x = 0

Selanjutnya, perbarui posisi semua objek yang Anda gambar ke layar, untuk memperhitungkan offset kamera. Anda dapat melakukan ini dengan menambahkan kamera_offset_x nilai ke posisi X masing-masing objek. Misalnya, Anda dapat memperbarui posisi pemain seperti ini:


player_rect = pygame.Rect(player_x + camera_offset_x, player_y, PLAYER_WIDTH,
    PLAYER_HEIGHT)

pygame.draw.rect(screen, (0, 0, 0), player_rect)

 

Demikian pula, Anda dapat memperbarui posisi platform statis sebagai berikut:


rectangle_1_draw_pos = rectangle_1.move(camera_offset_x, 0)
pygame.draw.rect(screen, RECTANGLE_COLOR_1, rectangle_1_draw_pos)
    
rectangle_2_draw_pos = rectangle_2.move(camera_offset_x, 0)
pygame.draw.rect(screen, RECTANGLE_COLOR_2, rectangle_2_draw_pos)

Memindahkan Kamera Dengan Input Keyboard

Sekarang setelah Anda menyiapkan kamera, Anda dapat mulai memindahkannya. Salah satu cara untuk melakukannya adalah dengan menggerakkan kamera sebagai respons terhadap input keyboard. Misalnya, Anda dapat memindahkan kamera ke kiri saat pemain menekan tombol panah kiri.

Untuk melakukannya, tambahkan kode berikut di dalam event loop yang menangani input keyboard:

if event.type == pygame.KEYDOWN:
    if event.key == pygame.K_LEFT:
        camera_offset_x -= PLAYER_SPEED
    elif event.key == pygame.K_RIGHT:
        camera_offset_x += PLAYER_SPEED

Cara lain adalah mengubah koordinat x pemain pada keyboard, tekan, lalu perbarui offset kamera. Anda dapat menerapkan ini seperti ini:


for event in pygame.event.get():
    if event.type == pygame.QUIT:
        pygame.quit()
        quit()

if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
player_x -= PLAYER_SPEED
elif event.key == pygame.K_RIGHT:
player_x += PLAYER_SPEED

 

Kemudian, Anda dapat memperbarui offset kamera sehubungan dengan koordinat x pemutar sebagai berikut:

camera_offset_x = WINDOW_WIDTH // 2 - player_x - PLAYER_WIDTH // 2

Memindahkan Kamera Dengan Input Mouse

Cara lain untuk menggerakkan kamera adalah dengan menggunakan mouse. Anda dapat mengizinkan pemain untuk menyeret layar dengan mengklik dan menyeret mouse.

Untuk melakukan ini, lacak posisi mouse saat pemain menekan tombol kiri mouse. Saat mereka menggerakkan mouse, perbarui koordinat x pemain. Itu harus berubah dengan perbedaan antara posisi mouse saat ini dan posisi awal yang Anda lacak, mouse_start_pos.


for event in pygame.event.get():
    if event.type == pygame.QUIT:
        pygame.quit()
        quit()

if event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
mouse_start_pos = pygame.mouse.get_pos()

if event.type == pygame.MOUSEMOTION:
if pygame.mouse.get_pressed()[0]:
mouse_current_pos = pygame.mouse.get_pos()
mouse_offset_x = mouse_current_pos[0] – mouse_start_pos[0]
player_x -= mouse_offset_x
mouse_start_pos = mouse_current_pos

 

Menambahkan Lebih Banyak Fitur Kamera

Selain efek kamera bergulir, Anda dapat menambahkan beberapa fitur terkait kamera lainnya untuk meningkatkan pengalaman bermain game. Salah satu fitur tersebut adalah efek kamera pembesaran yang memungkinkan pemain untuk memperbesar atau memperkecil dunia game. Anda dapat mencapai efek ini dengan mengubah ukuran jendela permainan dan menskalakan objek yang digambar di layar.

Untuk melakukannya, tentukan variabel zoom yang akan menyimpan level zoom game saat ini. Setel nilai awalnya ke 1.0, yang menunjukkan tidak ada zoom. Kemudian, tentukan fungsi yang akan menghitung ukuran objek yang diskalakan berdasarkan tingkat zoom saat ini.

zoom = 1.0

def get_scaled_size(size):
return int(size * zoom)

 

Selanjutnya, perbarui posisi dan ukuran objek yang digambar di layar menggunakan get_scaled_size fungsi. Misalnya, Anda dapat memperbarui posisi dan ukuran pemain sebagai berikut:

player_rect = pygame.Rect(
    get_scaled_size(player_x + camera_offset_x),
    get_scaled_size(player_y),
    get_scaled_size(PLAYER_WIDTH),
    get_scaled_size(PLAYER_HEIGHT)
)

Demikian pula, perbarui posisi dan ukuran platform statis sebagai berikut:

rectangle_1_draw_pos = pygame.Rect(
    get_scaled_size(rectangle_1.x + camera_offset_x),
    get_scaled_size(rectangle_1.y),
    get_scaled_size(rectangle_1.width),
    get_scaled_size(rectangle_1.height)
)

pygame.draw.rect(screen, RECTANGLE_COLOR_1, rectangle_1_draw_pos)

rectangle_2_draw_pos = pygame.Rect(
get_scaled_size(rectangle_2.x + camera_offset_x),
get_scaled_size(rectangle_2.y),
get_scaled_size(rectangle_2.width),
get_scaled_size(rectangle_2.height)
)

pygame.draw.rect(screen, RECTANGLE_COLOR_2, rectangle_2_draw_pos)

 

Menambah atau mengurangi tingkat pembesaran sebesar 0,1 saat pemain menekan tombol = atau kunci, masing-masing. Tetapkan ukuran baru jendela permainan berdasarkan tingkat zoom saat ini. Untuk melakukannya, tambahkan kode berikut di dalam event loop yang menangani input keyboard:

if event.type == pygame.KEYDOWN:
    if event.key == pygame.K_EQUALS:
        zoom += 0.1

screen = pygame.display.set_mode((
int(WINDOW_WIDTH * zoom),
int(WINDOW_HEIGHT * zoom)
))
elif event.key == pygame.K_MINUS:
zoom -= 0.1

if zoom < 0.1:
zoom = 0.1

screen = pygame.display.set_mode((
int(WINDOW_WIDTH * zoom),
int(WINDOW_HEIGHT * zoom)
))

 

Dengan kode di atas, Anda telah berhasil menambahkan efek kamera zoom ke game PyGame kami. Dengan menggabungkan fitur ini dengan efek kamera bergulir, Anda dapat menciptakan pengalaman bermain yang dinamis dan menarik.

Meningkatkan Gameplay Dengan Gerakan Kamera

Menambahkan kamera gulir ke game PyGame tidak hanya meningkatkan pengalaman visual tetapi juga meningkatkan gameplay. Ini memungkinkan pemain untuk melihat lebih banyak dunia game, memberi mereka pemahaman yang lebih baik tentang lingkungan mereka dan membuatnya lebih mudah dinavigasi.

Anda juga dapat menggunakan gerakan kamera untuk membuat efek khusus seperti memperbesar dan memperkecil atau mengguncang layar untuk mensimulasikan ledakan atau gempa bumi.

Comment
Share:

Leave a Reply

Your email address will not be published. Required fields are marked *

beli jitu https://167.71.217.241/ https://188.166.210.27/ https://103.253.147.8/ https://139.59.194.132/ https://152.42.192.54/ https://152.42.187.123/ https://188.166.196.248/ https://163.47.9.78/ https://157.230.245.144/ http://68.183.96.87/ http://147.182.210.122/ http://147.182.128.234/ http://167.172.1.184/ http://157.245.5.74/ http://139.59.217.59/ http://163.47.9.16/ http://144.126.251.215/ http://139.59.217.128/ http://103.186.0.254/ http://161.35.251.176/ http://157.245.29.71/ https://170.64.254.102/ https://www.markas303.ac.id/ https://www.markas303.or.id/ https://www.markas303.sch.id/ http://103.172.205.75/ http://103.245.38.119/ http://138.197.224.231/ http://138.197.224.231/

Ad