Leer hoe je een camera modelleert die door je gamewereld kan pannen om realisme en functionaliteit toe te voegen.
Een gemeenschappelijk kenmerk dat je in veel games aantreft, is een scrollende camera die je volgt terwijl je door de gamewereld beweegt. Dit effect kan diepte en realisme aan je game toevoegen en de algehele gameplay-ervaring verbeteren.
Er zijn veel verschillende manieren om een scrollende camera in PyGame te implementeren, dus zorg ervoor dat je hun verschillen begrijpt.
Een eenvoudig spel maken
Voor het starten, installeer pip op uw apparaat en gebruik de onderstaande opdracht om de PyGame-module te installeren:
pip installeer pygameNu kun je een eenvoudig spel maken met een spelersrechthoek en twee statische platforms. De speler kan naar links en rechts bewegen met behulp van de pijltjestoetsen.
Hierin vindt u de volledige code voor het project GitHub-opslagplaats.
Begin met het importeren van de pygame-module. Initialiseer het vervolgens en maak het spelvenster met behulp van de
pygame.display.set_mode() functie. Stel vervolgens het bijschrift van het venster in en maak het klokobject om de framesnelheid te beheren.importeren pyspelpygame.init()
WINDOW_WIDTH = 800
WINDOW_HEIGHT = 600scherm = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
pygame.display.set_caption("Mijn eenvoudige spel")
klok = pygame.tijd. Klok()
ACHTERGROND_COLOR = (255, 255, 255)
Stel vervolgens de speler en statische platforms in. Definieer de grootte van de speler en zijn beginpositie.
SPELER_WIDTH = 50
SPELER_HEIGHT = 50speler_x = WINDOW_WIDTH // 2 - PLAYER_WIDTH // 2
player_y = WINDOW_HEIGHT - PLAYER_HEIGHT - 20SPELER_SPEED = 10
RECTANGLE_COLOR_1 = (255, 0, 0)
RECTANGLE_COLOR_2 = (0, 0, 255)
rechthoek_1 = pygame. Recht(200, 200, 100, 100)
rechthoek_2 = pygame. Recht(500, 300, 150, 50)
Maak vervolgens een spellus die gebeurtenissen afhandelt en het scherm bijwerkt. Controleer in de lus op gebeurtenissen zoals het beëindigen van het spel of het verplaatsen van de speler met de pijltjestoetsen.
terwijlWAAR:
# Gebeurtenissen afhandelen
voor evenement in pygame.event.get():
als event.type == pygame. ONTSLAG NEMEN:
pygame.quit()
ontslag nemen()# Teken de achtergrond
schermvullend (BACKGROUND_COLOR)# Teken de statische rechthoeken
pygame.draw.rect (scherm, RECTANGLE_COLOR_1, rechthoek_1)
pygame.draw.rect (scherm, RECTANGLE_COLOR_2, rechthoek_2)# Teken de speler
player_rect = pygame. Rect (speler_x, speler_y, PLAYER_WIDTH,
SPELER_HEIGHT)pygame.draw.rect (scherm, (0, 0, 0), player_rect)
# Werk de weergave bij
pygame.display.update()
# Beperk de framesnelheid
klok.vinkje(30)
De camera instellen
Nu je een eenvoudig spel hebt met een spelersrechthoek en twee statische platforms, kun je aan de camera gaan werken. In PyGame is de camera in wezen slechts een offset die inwerkt op alle objecten die u naar het scherm tekent. Dit betekent dat als je de camera naar links beweegt, alles op het scherm naar rechts lijkt te bewegen.
Om de camera in te stellen, moet u eerst een variabele definiëren om de X-offset van de camera vast te houden. Noem deze variabele camera_offset_x en initialiseer het naar 0.
# Stel de camera-offset in
camera_offset_x = 0Werk vervolgens de posities bij van alle objecten die u naar het scherm tekent, om rekening te houden met de camera-offset. Dit doe je door de camera_offset_x waarde toe aan de X-positie van elk object. U kunt de positie van de speler bijvoorbeeld als volgt bijwerken:
# Teken de speler
player_rect = pygame. Rect (player_x + camera_offset_x, player_y, PLAYER_WIDTH,
SPELER_HEIGHT)
pygame.draw.rect (scherm, (0, 0, 0), player_rect)
Evenzo kunt u de posities van de statische platforms als volgt bijwerken:
# Teken de statische rechthoeken
rechthoek_1_draw_pos = rechthoek_1.verplaatsen (camera_offset_x, 0)
pygame.draw.rect (scherm, RECTANGLE_COLOR_1, rectangle_1_draw_pos)
rechthoek_2_draw_pos = rechthoek_2.verplaatsen (camera_offset_x, 0)
pygame.draw.rect (scherm, RECTANGLE_COLOR_2, rectangle_2_draw_pos)De camera verplaatsen met toetsenbordinvoer
Nu je de camera hebt ingesteld, kun je hem gaan verplaatsen. Een manier om dit te doen is door de camera te bewegen als reactie op toetsenbordinvoer. U kunt de camera bijvoorbeeld naar links verplaatsen wanneer de speler op de linkerpijltoets drukt.
Om dit te doen, voegt u de volgende code toe aan de gebeurtenislus die de toetsenbordinvoer afhandelt:
als event.type == pygame. TOETS NEER:
als event.key == pygame. K_LEFT:
camera_offset_x -= PLAYER_SPEED
elif event.key == pygame. K_RIGHT:
camera_offset_x += PLAYER_SPEEDEen andere manier is om de x-coördinaat van de speler te wijzigen door op het toetsenbord te drukken en vervolgens de camera-offset bij te werken. Je kunt dit als volgt implementeren:
# Gebeurtenissen afhandelen
voor evenement in pygame.event.get():
als event.type == pygame. ONTSLAG NEMEN:
pygame.quit()
ontslag nemen()
als event.type == pygame. TOETS NEER:
als event.key == pygame. K_LEFT:
player_x -= PLAYER_SPEED
elif event.key == pygame. K_RIGHT:
player_x += PLAYER_SPEED
Vervolgens kunt u de camera-offset ten opzichte van de x-coördinaat van de speler als volgt bijwerken:
camera_offset_x = WINDOW_WIDTH // 2 - speler_x - PLAYER_WIDTH // 2De camera verplaatsen met muisinvoer
Een andere manier om de camera te verplaatsen is met de muis. U kunt de speler toestaan het scherm rond te slepen door met de muis te klikken en te slepen.
Volg hiervoor de positie van de muis wanneer de speler op de linkermuisknop drukt. Wanneer ze de muis bewegen, update je de x-coördinaat van de speler. Het zou moeten veranderen door het verschil tussen de huidige muispositie en de aanvankelijke positie die u hebt gevolgd, mouse_start_pos.
# Gebeurtenissen afhandelen
voor evenement in pygame.event.get():
als event.type == pygame. ONTSLAG NEMEN:
pygame.quit()
ontslag nemen()als event.type == pygame. MUISKNOP OMLAAG:
als gebeurtenis.knop == 1:
mouse_start_pos = pygame.mouse.get_pos()
als event.type == pygame. MUISBEWEGING:
als pygame.mouse.get_press()[0]:
mouse_current_pos = pygame.mouse.get_pos()
mouse_offset_x = mouse_current_pos[0] - mouse_start_pos[0]
speler_x -= mouse_offset_x
mouse_start_pos = mouse_current_pos
Meer camerafuncties toevoegen
Naast het scrollende camera-effect kun je verschillende andere camera-gerelateerde functies toevoegen om de gameplay-ervaring te verbeteren. Een van die functies is een inzoomend camera-effect waarmee de speler in of uit de gamewereld kan inzoomen. U kunt dit effect bereiken door de grootte van het spelvenster te wijzigen en de op het scherm getekende objecten te schalen.
Definieer hiervoor een zoomvariabele die het huidige zoomniveau van het spel opslaat. Stel de beginwaarde in op 1,0, wat staat voor geen zoom. Definieer vervolgens een functie die de geschaalde grootte van een object berekent op basis van het huidige zoomniveau.
zoom = 1.0
defget_scaled_size(maat):
opbrengst int (grootte * zoom)
Werk vervolgens de posities en afmetingen van de op het scherm getekende objecten bij met behulp van de get_scaled_size functie. U kunt bijvoorbeeld de positie en grootte van de speler als volgt bijwerken:
player_rect = pygame. Recht(
get_scaled_size (speler_x + camera_offset_x),
get_scaled_size (speler_y),
get_scaled_size (PLAYER_WIDTH),
get_scaled_size (PLAYER_HEIGHT)
)Werk op dezelfde manier de posities en afmetingen van de statische platforms als volgt bij:
rechthoek_1_draw_pos = pygame. Recht(
get_scaled_size (rechthoek_1.x + camera_offset_x),
get_scaled_size (rechthoek_1.y),
get_scaled_size (rechthoek_1.breedte),
get_scaled_size (rechthoek_1.hoogte)
)pygame.draw.rect (scherm, RECTANGLE_COLOR_1, rectangle_1_draw_pos)
rechthoek_2_draw_pos = pygame. Recht(
get_scaled_size (rechthoek_2.x + camera_offset_x),
get_scaled_size (rechthoek_2.y),
get_scaled_size (rechthoek_2.breedte),
get_scaled_size (rechthoek_2.hoogte)
)
pygame.draw.rect (scherm, RECTANGLE_COLOR_2, rectangle_2_draw_pos)
Verhoog of verlaag het zoomniveau met 0,1 wanneer de speler op de = of - respectievelijk sleutel. Stel de nieuwe grootte van het spelvenster in op basis van het huidige zoomniveau. Om dit te doen, voegt u de volgende code toe aan de gebeurtenislus die de toetsenbordinvoer afhandelt:
als event.type == pygame. TOETS NEER:
als event.key == pygame. K_GELIJK:
zoomen += 0.1scherm = pygame.display.set_mode((
int (WINDOW_WIDTH * zoom),
int (WINDOW_HEIGHT * zoom)
))
elif event.key == pygame. K_MINUS:
zoomen -= 0.1als zoom < 0.1:
zoom = 0.1
scherm = pygame.display.set_mode((
int (WINDOW_WIDTH * zoom),
int (WINDOW_HEIGHT * zoom)
))
Met de bovenstaande code heb je met succes een zoomend camera-effect toegevoegd aan ons PyGame-spel. Door deze functie te combineren met het scrollende camera-effect, kun je een dynamische en boeiende game-ervaring creëren.
Gameplay verbeteren met camerabewegingen
Het toevoegen van een scrollende camera aan een PyGame-game verbetert niet alleen de visuele ervaring, maar verbetert ook de gameplay. Het stelt de speler in staat om meer van de gamewereld te zien, waardoor hij zijn omgeving beter begrijpt en gemakkelijker kan navigeren.
U kunt ook camerabewegingen gebruiken om speciale effecten te creëren, zoals in- en uitzoomen of het scherm schudden om explosies of aardbevingen te simuleren.