Lär dig hur du modellerar en kamera som kan panorera över din spelvärld för att lägga till realism och funktionalitet.

En vanlig funktion som du hittar i många spel är en rullande kamera som följer dig när du rör dig i spelvärlden. Denna effekt kan lägga till djup och realism till ditt spel och förbättra den övergripande spelupplevelsen.

Det finns många olika sätt att implementera en rullande kamera i PyGame, så se till att du förstår deras skillnader.

Skapa ett enkelt spel

Innan du startar, installera pip på din enhet och använd kommandot nedan för att installera PyGame-modulen:

pip installera pygame

Nu kan du skapa ett enkelt spel med en spelarrektangel och två statiska plattformar. Spelaren kan flytta åt vänster och höger med hjälp av piltangenterna.

Du hittar hela koden för projektet i denna GitHub repo.

Börja med att importera pygame-modulen. Initiera det sedan och skapa spelfönstret med hjälp av pygame.display.set_mode() fungera. Ställ sedan in bildtexten för fönstret och skapa klockobjekt för att hantera bildhastigheten.

instagram viewer 
importera pygame
pygame.init()


WINDOW_WIDTH = 800
WINDOW_HEIGHT = 600


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


pygame.display.set_caption("Mitt enkla spel")


klocka = pygame.time. Klocka()
BACKGROUND_COLOR = (255, 255, 255)

Ställ sedan in spelaren och statiska plattformar. Definiera spelarens storlek och dess utgångsposition.

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)

Skapa sedan en spelloop som hanterar händelser och uppdaterar skärmen. I loopen, kolla efter händelser som att avsluta spelet eller flytta spelaren med piltangenterna.

medanSann:
# Hantera händelser
för händelse i pygame.event.get():
om event.type == pygame. SLUTA MED:
 pygame.quit()
 sluta med()
# Rita bakgrunden
 screen.fill (BACKGROUND_COLOR)


# Rita de statiska rektanglarna
 pygame.draw.rect (skärm, RECTANGLE_COLOR_1, rektangel_1)
 pygame.draw.rect (skärm, RECTANGLE_COLOR_2, rektangel_2)


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


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


# Uppdatera displayen
 pygame.display.update()
# Begränsa bildfrekvensen
 clock.tick(30)

Ställa in kameran

Nu när du har ett enkelt spel med en spelarrektangel och två statiska plattformar kan du börja arbeta med kameran. I PyGame är kameran i princip bara en offset som verkar på alla objekt du ritar till skärmen. Det betyder att om du flyttar kameran åt vänster kommer allt på skärmen att se ut att flyttas åt höger.

För att ställa in kameran måste du först definiera en variabel som håller kamerans X-offset. Kalla denna variabel camera_offset_x och initiera den till 0.

# Ställ in kamerans offset
camera_offset_x = 0

Uppdatera sedan positionerna för alla objekt som du ritar till skärmen för att ta hänsyn till kameraförskjutningen. Du kan göra detta genom att lägga till camera_offset_x värde till X-positionen för varje objekt. Du kan till exempel uppdatera spelarens position så här:

# Rita spelaren
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å samma sätt kan du uppdatera positionerna för de statiska plattformarna enligt följande:

# Rita de statiska rektanglarna
rectangle_1_draw_pos = rectangle_1.move (camera_offset_x, 0)
pygame.draw.rect (skärm, RECTANGLE_COLOR_1, rectangle_1_draw_pos)

rectangle_2_draw_pos = rectangle_2.move (camera_offset_x, 0)
pygame.draw.rect (skärm, RECTANGLE_COLOR_2, rectangle_2_draw_pos)

Flytta kameran med tangentbordsingångar

Nu när du har ställt in kameran kan du börja flytta runt den. Ett sätt att göra detta är att flytta kameran som svar på tangentbordsingångar. Du kan till exempel flytta kameran åt vänster när spelaren trycker på vänsterpilen.

För att göra detta, lägg till följande kod i händelseslingan som hanterar tangentbordsingångarna:

om event.type == pygame. NYCKEL NER:
om event.key == pygame. K_LEFT:
 camera_offset_x -= PLAYER_SPEED
elif event.key == pygame. K_RIGHT:
 camera_offset_x += PLAYER_SPEED

Ett annat sätt är att ändra spelarens x-koordinat på tangentbordstrycket och sedan uppdatera kamerans offset. Du kan implementera detta så här:

# Hantera händelser
för händelse i pygame.event.get():
om event.type == pygame. SLUTA MED:
 pygame.quit()
 sluta med()
om event.type == pygame. NYCKEL NER:
om event.key == pygame. K_LEFT:
 player_x -= PLAYER_SPEED
elif event.key == pygame. K_RIGHT:
 player_x += PLAYER_SPEED

Sedan kan du uppdatera kameraförskjutningen med avseende på spelarens x-koordinat enligt följande:

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

Flytta kameran med musingångar

Ett annat sätt att flytta kameran är att använda musen. Du kan tillåta spelaren att dra runt skärmen genom att klicka och dra musen.

För att göra detta, spåra musens position när spelaren trycker på vänster musknapp. När de flyttar musen uppdaterar du spelarens x-koordinat. Det bör ändras med skillnaden mellan den nuvarande muspositionen och den ursprungliga positionen du spårade, mouse_start_pos.

# Hantera händelser
för händelse i pygame.event.get():
om event.type == pygame. SLUTA MED:
 pygame.quit()
 sluta med()
om event.type == pygame. MUSKNAPP:
om event.button == 1:
 mouse_start_pos = pygame.mouse.get_pos()
om event.type == pygame. MUSMÖRELSE:
om 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

Lägga till fler kamerafunktioner

Förutom den rullande kameraeffekten kan du lägga till flera andra kamerarelaterade funktioner för att förbättra spelupplevelsen. En sådan funktion är en zoomande kameraeffekt som gör att spelaren kan zooma in eller ut ur spelvärlden. Du kan uppnå denna effekt genom att ändra storleken på spelfönstret och skala objekten som ritas på skärmen.

För att göra detta, definiera en zoomvariabel som lagrar den aktuella zoomnivån i spelet. Ställ in dess initiala värde till 1,0, vilket representerar ingen zoom. Definiera sedan en funktion som beräknar den skalade storleken på ett objekt baserat på den aktuella zoomnivån.

zooma = 1.0
defget_scaled_size(storlek):
lämna tillbaka int (storlek * zoom)

Uppdatera sedan positionerna och storlekarna för objekten som ritas på skärmen med hjälp av get_scaled_size fungera. Du kan till exempel uppdatera spelarens position och storlek enligt följande:

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

På samma sätt uppdaterar du positionerna och storlekarna för de statiska plattformarna enligt följande:

rectangle_1_draw_pos = pygame. Rekt(
 get_scaled_size (rektangel_1.x + kamera_offset_x),
 get_scaled_size (rektangel_1.y),
 get_scaled_size (rektangel_1.bredd),
 get_scaled_size (rektangel_1.höjd)
)
pygame.draw.rect (skärm, RECTANGLE_COLOR_1, rectangle_1_draw_pos)


rectangle_2_draw_pos = pygame. Rekt(
 get_scaled_size (rektangel_2.x + kamera_offset_x),
 get_scaled_size (rektangel_2.y),
 get_scaled_size (rektangel_2.bredd),
 get_scaled_size (rektangel_2.höjd)
)
pygame.draw.rect (skärm, RECTANGLE_COLOR_2, rectangle_2_draw_pos)

Öka eller minska zoomnivån med 0,1 när spelaren trycker på = eller - nyckel, respektive. Ställ in den nya storleken på spelfönstret baserat på den aktuella zoomnivån. För att göra detta, lägg till följande kod i händelseslingan som hanterar tangentbordsingångarna:

om event.type == pygame. NYCKEL NER:
om event.key == pygame. K_EQUALS:
 zooma += 0.1
 skärm = pygame.display.set_mode((
 int (WINDOW_WIDTH * zoom),
 int (WINDOW_HEIGHT * zoom)
 ))
elif event.key == pygame. K_MINUS:
 zooma -= 0.1


om zooma < 0.1:
 zooma = 0.1
 skärm = pygame.display.set_mode((
 int (WINDOW_WIDTH * zoom),
 int (WINDOW_HEIGHT * zoom)
 ))

Med ovanstående kod har du framgångsrikt lagt till en zoomande kameraeffekt till vårt PyGame-spel. Genom att kombinera den här funktionen med den rullande kameraeffekten kan du skapa en dynamisk och engagerande spelupplevelse.

Förbättra spelandet med kamerarörelser

Att lägga till en rullande kamera i ett PyGame-spel förbättrar inte bara den visuella upplevelsen utan förbättrar också spelet. Det gör att spelaren kan se mer av spelvärlden, vilket ger dem en bättre förståelse för sin omgivning och gör det lättare att navigera.

Du kan också använda kamerarörelser för att skapa specialeffekter som att zooma in och ut eller skaka skärmen för att simulera explosioner eller jordbävningar.