Aflați cum să modelați o cameră care poate trece prin lumea jocului pentru a adăuga realism și funcționalitate.

O caracteristică comună pe care o veți găsi în multe jocuri este o cameră cu defilare care vă urmărește pe măsură ce vă deplasați în lumea jocului. Acest efect poate adăuga profunzime și realism jocului dvs. și poate îmbunătăți experiența generală de joc.

Există multe moduri diferite de a implementa o cameră cu derulare în PyGame, așa că asigurați-vă că înțelegeți diferențele dintre acestea.

Crearea unui joc simplu

Înainte de a începe, instalați pip pe dispozitivul dvs și utilizați comanda de mai jos pentru a instala modulul PyGame:

pip install pygame

Acum, puteți crea un joc simplu cu un dreptunghi de jucător și două platforme statice. Jucătorul se poate deplasa la stânga și la dreapta folosind tastele săgeți.

Puteți găsi codul complet al proiectului în aceasta Repoziție GitHub.

Începeți prin a importa modulul pygame. Apoi, inițializați-l și creați fereastra jocului folosind pygame.display.set_mode()

instagram viewer
funcţie. Apoi, setați legenda ferestrei și creați obiect ceas pentru a gestiona rata de cadre.

import pygame
pygame.init()


WINDOW_WIDTH = 800
WINDOW_HEIGHT = 600


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


pygame.display.set_caption(„Jocul meu simplu”)


ceas = pygame.time. Ceas()
BACKGROUND_CULOR = (255, 255, 255)

Apoi, configurați playerul și platformele statice. Definiți dimensiunea jucătorului și poziția sa inițială.

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)
dreptunghi_1 = pygame. Rect(200, 200, 100, 100)
dreptunghi_2 = pygame. Rect(500, 300, 150, 50)

Apoi, creați o buclă de joc care se ocupă de evenimente și actualizează ecranul. În buclă, verificați evenimente precum părăsirea jocului sau mutarea jucătorului folosind tastele săgeți.

in timp ceAdevărat:
# Gestionați evenimentele
pentru eveniment în pygame.event.get():
dacă event.type == pygame. PĂRĂSI:
 pygame.quit()
 părăsi()
# Desenați fundalul
 screen.fill (BACKGROUND_COLOR)


# Desenați dreptunghiurile statice
 pygame.draw.rect (ecran, RECTANGLE_COLOR_1, dreptunghi_1)
 pygame.draw.rect (ecran, RECTANGLE_COLOR_2, dreptunghi_2)


# Desenați jucătorul
 player_rect = pygame. Rect (player_x, player_y, PLAYER_WIDTH,
 PLAYER_HEIGHT)


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


# Actualizați afișajul
 pygame.display.update()
# Limitați rata de cadre
 clock.tick(30)

Configurarea camerei

Acum că aveți un joc simplu cu un dreptunghi de jucător și două platforme statice, puteți începe să lucrați la cameră. În PyGame, camera este în esență doar un offset care acționează asupra tuturor obiectelor pe care le desenezi pe ecran. Aceasta înseamnă că, dacă mutați camera la stânga, totul de pe ecran va apărea că se mișcă la dreapta.

Pentru a configura camera, mai întâi trebuie să definiți o variabilă care să mențină decalajul X al camerei. Apelați această variabilă camera_offset_x și inițializați-l la 0.

# Setați offset-ul camerei
camera_offset_x = 0

Apoi, actualizați pozițiile tuturor obiectelor pe care le desenați pe ecran, pentru a ține cont de offset-ul camerei. Puteți face acest lucru adăugând camera_offset_x valoare la poziția X a fiecărui obiect. De exemplu, puteți actualiza poziția jucătorului astfel:

# Desenați jucătorul
player_rect = pygame. Rect (player_x + camera_offset_x, player_y, PLAYER_WIDTH,
 PLAYER_HEIGHT)
pygame.draw.rect (ecran, (0, 0, 0), player_rect)

În mod similar, puteți actualiza pozițiile platformelor statice după cum urmează:

# Desenați dreptunghiurile statice
rectangle_1_draw_pos = rectangle_1.move (camera_offset_x, 0)
pygame.draw.rect (ecran, RECTANGLE_COLOR_1, rectangle_1_draw_pos)

rectangle_2_draw_pos = rectangle_2.move (camera_offset_x, 0)
pygame.draw.rect (ecran, RECTANGLE_COLOR_2, rectangle_2_draw_pos)

Mutarea camerei cu intrările de la tastatură

Acum că aveți camera configurată, puteți începe să o mutați. O modalitate de a face acest lucru este să mutați camera ca răspuns la intrările de la tastatură. De exemplu, puteți muta camera spre stânga când jucătorul apasă tasta săgeată stânga.

Pentru a face acest lucru, adăugați următorul cod în bucla de evenimente care gestionează intrările de la tastatură:

dacă event.type == pygame. TASTA ÎN JOS:
dacă event.key == pygame. K_LEFT:
 camera_offset_x -= PLAYER_SPEED
elif event.key == pygame. K_DREPTA:
 camera_offset_x += PLAYER_SPEED

O altă modalitate este să modificați coordonatele x a jucătorului de la apăsarea tastaturii și apoi să actualizați offset-ul camerei. Puteți implementa acest lucru astfel:

# Gestionați evenimentele
pentru eveniment în pygame.event.get():
dacă event.type == pygame. PĂRĂSI:
 pygame.quit()
 părăsi()
dacă event.type == pygame. TASTA ÎN JOS:
dacă event.key == pygame. K_LEFT:
 player_x -= PLAYER_SPEED
elif event.key == pygame. K_DREPTA:
 player_x += PLAYER_SPEED

Apoi, puteți actualiza offset-ul camerei în raport cu coordonatele x a jucătorului, după cum urmează:

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

Mutarea camerei cu intrările mouse-ului

Un alt mod de a muta camera este folosirea mouse-ului. Puteți permite jucătorului să tragă ecranul făcând clic și trăgând mouse-ul.

Pentru a face acest lucru, urmăriți poziția mouse-ului atunci când jucătorul apasă butonul stâng al mouse-ului. Când mișcă mouse-ul, actualizați coordonatele x ale jucătorului. Ar trebui să se schimbe prin diferența dintre poziția curentă a mouse-ului și poziția inițială pe care ați urmărit-o, mouse_start_pos.

# Gestionați evenimentele
pentru eveniment în pygame.event.get():
dacă event.type == pygame. PĂRĂSI:
 pygame.quit()
 părăsi()
dacă event.type == pygame. BUTONUL MOUSE-JOS:
dacă eveniment.buton == 1:
 mouse_start_pos = pygame.mouse.get_pos()
dacă event.type == pygame. MOUSEMOTION:
dacă 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

Adăugarea mai multor funcții ale camerei

Pe lângă efectul camerei de defilare, puteți adăuga câteva alte funcții legate de cameră pentru a îmbunătăți experiența de joc. O astfel de caracteristică este un efect de zoom care permite jucătorului să mărească sau să micșoreze lumea jocului. Puteți obține acest efect schimbând dimensiunea ferestrei de joc și scalând obiectele desenate pe ecran.

Pentru a face acest lucru, definiți o variabilă de zoom care va stoca nivelul actual de zoom al jocului. Setați valoarea sa inițială la 1,0, ceea ce reprezintă niciun zoom. Apoi, definiți o funcție care va calcula dimensiunea scalată a unui obiect pe baza nivelului de zoom actual.

zoom = 1.0
defget_scaled_size(mărimea):
întoarcere int (dimensiune * zoom)

Apoi, actualizați pozițiile și dimensiunile obiectelor desenate pe ecran utilizând get_scaled_size funcţie. De exemplu, puteți actualiza poziția și dimensiunea jucătorului după cum urmează:

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)
)

În mod similar, actualizați pozițiile și dimensiunile platformelor statice după cum urmează:

rectangle_1_draw_pos = pygame. Rect(
 get_scaled_size (dreptunghi_1.x + camera_offset_x),
 get_scaled_size (dreptunghi_1.y),
 get_scaled_size (dreptunghi_1.lățime),
 get_scaled_size (dreptunghi_1.înălțime)
)
pygame.draw.rect (ecran, RECTANGLE_COLOR_1, rectangle_1_draw_pos)


rectangle_2_draw_pos = pygame. Rect(
 get_scaled_size (dreptunghi_2.x + camera_offset_x),
 get_scaled_size (dreptunghi_2.y),
 get_scaled_size (dreptunghi_2.lățime),
 get_scaled_size (dreptunghi_2.înălțime)
)
pygame.draw.rect (ecran, RECTANGLE_COLOR_2, rectangle_2_draw_pos)

Măriți sau micșorați nivelul de zoom cu 0,1 atunci când jucătorul apasă tasta = sau - cheie, respectiv. Setați noua dimensiune a ferestrei de joc în funcție de nivelul actual de zoom. Pentru a face acest lucru, adăugați următorul cod în bucla de evenimente care gestionează intrările de la tastatură:

dacă event.type == pygame. TASTA ÎN JOS:
dacă event.key == pygame. K_EQUALS:
 zoom += 0.1
 ecran = pygame.display.set_mode((
 int (WINDOW_WIDTH * zoom),
 int (WINDOW_HEIGHT * zoom)
 ))
elif event.key == pygame. K_MINUS:
 zoom -= 0.1


dacă zoom < 0.1:
 zoom = 0.1
 ecran = pygame.display.set_mode((
 int (WINDOW_WIDTH * zoom),
 int (WINDOW_HEIGHT * zoom)
 ))

Cu codul de mai sus, ați adăugat cu succes un efect de mărire a camerei în jocul nostru PyGame. Combinând această caracteristică cu efectul camerei de defilare, puteți crea o experiență de joc dinamică și captivantă.

Îmbunătățirea gameplay-ului cu mișcările camerei

Adăugarea unei camere cu defilare la un joc PyGame nu numai că îmbunătățește experiența vizuală, ci și jocul. Acesta permite jucătorului să vadă mai mult din lumea jocului, oferindu-i o mai bună înțelegere a împrejurimilor și facilitând navigarea.

De asemenea, puteți utiliza mișcarea camerei pentru a crea efecte speciale, cum ar fi mărirea și micșorarea sau scuturarea ecranului pentru a simula explozii sau cutremure.