Lær, hvordan du modellerer et kamera, der kan panorere over din spilverden for at tilføje realisme og funktionalitet.

En fælles funktion, du finder i mange spil, er et rullekamera, der følger dig, når du bevæger dig rundt i spilverdenen. Denne effekt kan tilføje dybde og realisme til dit spil og forbedre den overordnede spiloplevelse.

Der er mange forskellige måder at implementere et rullekamera på i PyGame, så sørg for at forstå deres forskelle.

Oprettelse af et simpelt spil

Inden start, installer pip på din enhed og brug nedenstående kommando til at installere PyGame-modulet:

pip installer pygame

Nu kan du oprette et simpelt spil med et spillerrektangel og to statiske platforme. Spilleren kan flytte til venstre og højre ved hjælp af piletasterne.

Du kan finde den komplette kode for projektet i denne GitHub repo.

Start med at importere pygame-modulet. Initialiser det derefter og opret spilvinduet ved hjælp af pygame.display.set_mode() fungere. Indstil derefter billedteksten til vinduet og opret urobjekt for at styre billedhastigheden.

instagram viewer 
importere pygame
pygame.init()


WINDOW_WIDTH = 800
WINDOW_HEIGHT = 600


skærm = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))


pygame.display.set_caption("Mit simple spil")


ur = pygame.time. Ur()
BACKGROUND_COLOR = (255, 255, 255)

Konfigurer derefter afspilleren og statiske platforme. Definer størrelsen på spilleren og dens udgangsposition.

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

Opret derefter en spilløkke, der håndterer begivenheder og opdaterer skærmen. I løkken skal du tjekke for begivenheder såsom at afslutte spillet eller flytte spilleren ved hjælp af piletasterne.

mensRigtigt:
# Håndter begivenheder
til begivenhed i pygame.event.get():
hvis event.type == pygame. AFSLUT:
 pygame.quit()
 Afslut()
# Tegn baggrunden
 screen.fill (BACKGROUND_COLOR)


# Tegn de statiske rektangler
 pygame.draw.rect (skærm, RECTANGLE_COLOR_1, rektangel_1)
 pygame.draw.rect (skærm, RECTANGLE_COLOR_2, rektangel_2)


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


 pygame.draw.rect (skærm, (0, 0, 0), player_rect)


# Opdater displayet
 pygame.display.update()
# Begræns billedhastigheden
 clock.tick(30)

Opsætning af kameraet

Nu hvor du har et simpelt spil med et spillerrektangel og to statiske platforme, kan du begynde at arbejde på kameraet. I PyGame er kameraet i bund og grund kun en offset, der virker på alle de objekter, du tegner til skærmen. Det betyder, at hvis du flytter kameraet til venstre, vil alt på skærmen se ud til at bevæge sig til højre.

For at opsætte kameraet skal du først definere en variabel til at holde kameraets X offset. Kald denne variabel camera_offset_x og initialisere den til 0.

# Indstil kameraets offset
camera_offset_x = 0

Opdater derefter positionerne for alle de objekter, du tegner til skærmen, for at tage højde for kameraforskydningen. Du kan gøre dette ved at tilføje camera_offset_x værdi til X-positionen af ​​hvert objekt. For eksempel kan du opdatere spillerens position på denne måde:

# Tegn afspilleren
player_rect = pygame. Rect (player_x + camera_offset_x, player_y, PLAYER_WIDTH,
 PLAYER_HEIGHT)
pygame.draw.rect (skærm, (0, 0, 0), player_rect)

På samme måde kan du opdatere positionerne for de statiske platforme som følger:

# Tegn de statiske rektangler
rectangle_1_draw_pos = rektangel_1.move (camera_offset_x, 0)
pygame.draw.rect (skærm, RECTANGLE_COLOR_1, rectangle_1_draw_pos)

rectangle_2_draw_pos = rektangel_2.move (camera_offset_x, 0)
pygame.draw.rect (skærm, RECTANGLE_COLOR_2, rectangle_2_draw_pos)

Flytning af kameraet med tastaturindgange

Nu hvor du har sat kameraet op, kan du begynde at flytte rundt på det. En måde at gøre dette på er at flytte kameraet som svar på tastaturinput. For eksempel kan du flytte kameraet til venstre, når afspilleren trykker på venstre piletast.

For at gøre dette skal du tilføje følgende kode i begivenhedsløkken, der håndterer tastaturinput:

hvis event.type == pygame. NASTATUR:
hvis event.key == pygame. K_LEFT:
 camera_offset_x -= PLAYER_SPEED
elif event.key == pygame. K_RIGHT:
 camera_offset_x += PLAYER_SPEED

En anden måde er at ændre afspillerens x-koordinat på tastaturtrykket og derefter opdatere kameraforskydningen. Du kan implementere dette sådan:

# Håndter begivenheder
til begivenhed i pygame.event.get():
hvis event.type == pygame. AFSLUT:
 pygame.quit()
 Afslut()
hvis event.type == pygame. NASTATUR:
hvis event.key == pygame. K_LEFT:
 player_x -= PLAYER_SPEED
elif event.key == pygame. K_RIGHT:
 player_x += PLAYER_SPEED

Derefter kan du opdatere kameraforskydningen i forhold til afspillerens x-koordinat som følger:

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

Flytning af kameraet med museindgange

En anden måde at flytte kameraet på er at bruge musen. Du kan tillade afspilleren at trække rundt på skærmen ved at klikke og trække med musen.

For at gøre dette skal du spore musens position, når afspilleren trykker på venstre museknap. Når de flytter musen, skal du opdatere spillerens x-koordinat. Det bør ændres med forskellen mellem den aktuelle museposition og den oprindelige position, du sporede, mouse_start_pos.

# Håndter begivenheder
til begivenhed i pygame.event.get():
hvis event.type == pygame. AFSLUT:
 pygame.quit()
 Afslut()
hvis event.type == pygame. MUSEKNAP NED:
hvis begivenhed.knap == 1:
 mouse_start_pos = pygame.mouse.get_pos()
hvis event.type == pygame. MUSEMØVELSE:
hvis 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

Tilføjelse af flere kamerafunktioner

Udover den rullende kamera-effekt kan du tilføje flere andre kamera-relaterede funktioner for at forbedre gameplay-oplevelsen. En sådan funktion er en zoomende kameraeffekt, der gør det muligt for spilleren at zoome ind eller ud af spilverdenen. Du kan opnå denne effekt ved at ændre størrelsen på spilvinduet og skalere objekterne tegnet på skærmen.

For at gøre dette skal du definere en zoomvariabel, der gemmer spillets aktuelle zoomniveau. Indstil dens startværdi til 1,0, hvilket repræsenterer ingen zoom. Definer derefter en funktion, der beregner den skalerede størrelse af et objekt baseret på det aktuelle zoomniveau.

zoom = 1.0
deffå_skaleret_størrelse(størrelse):
Vend tilbage int (størrelse * zoom)

Opdater derefter positionerne og størrelserne af de objekter, der er tegnet på skærmen ved hjælp af få_skaleret_størrelse fungere. For eksempel kan du opdatere spillerens position og størrelse som følger:

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

Tilsvarende skal du opdatere positionerne og størrelserne af de statiske platforme som følger:

rectangle_1_draw_pos = pygame. Rekt(
 get_scaled_size (rektangel_1.x + camera_offset_x),
 get_scaled_size (rektangel_1.y),
 get_scaled_size (rektangel_1.bredde),
 get_scaled_size (rektangel_1.højde)
)
pygame.draw.rect (skærm, RECTANGLE_COLOR_1, rectangle_1_draw_pos)


rectangle_2_draw_pos = pygame. Rekt(
 get_scaled_size (rektangel_2.x + camera_offset_x),
 get_scaled_size (rektangel_2.y),
 get_scaled_size (rektangel_2.bredde),
 get_scaled_size (rektangel_2.højde)
)
pygame.draw.rect (skærm, RECTANGLE_COLOR_2, rectangle_2_draw_pos)

Forøg eller sænk zoomniveauet med 0,1, når afspilleren trykker på = eller - nøgle hhv. Indstil den nye størrelse på spilvinduet baseret på det aktuelle zoomniveau. For at gøre dette skal du tilføje følgende kode i begivenhedsløkken, der håndterer tastaturinput:

hvis event.type == pygame. NASTATUR:
hvis event.key == pygame. K_EQUALS:
 zoom += 0.1
 skærm = pygame.display.set_mode((
 int (WINDOW_WIDTH * zoom),
 int (WINDOW_HEIGHT * zoom)
 ))
elif event.key == pygame. K_MINUS:
 zoom -= 0.1


hvis zoom < 0.1:
 zoom = 0.1
 skærm = pygame.display.set_mode((
 int (WINDOW_WIDTH * zoom),
 int (WINDOW_HEIGHT * zoom)
 ))

Med ovenstående kode har du tilføjet en zoomende kameraeffekt til vores PyGame-spil. Ved at kombinere denne funktion med rullekameraeffekten kan du skabe en dynamisk og engagerende spiloplevelse.

Forbedring af gameplay med kamerabevægelser

Tilføjelse af et rullekamera til et PyGame-spil forbedrer ikke kun den visuelle oplevelse, men forbedrer også gameplayet. Det giver spilleren mulighed for at se mere af spilverdenen, hvilket giver dem en bedre forståelse af deres omgivelser og gør det lettere at navigere.

Du kan også bruge kamerabevægelser til at skabe specielle effekter såsom at zoome ind og ud eller ryste skærmen for at simulere eksplosioner eller jordskælv.