Vil du skrive ditt første spill, men vet ikke hvor du skal begynne med spillutvikling? Pygame fjerner den barrieren. Du skriver i ren Python og ser umiddelbart resultatet på skjermen: en bevegelig sprite, respons på tastaturinput, levende mekanikker. Ingen tunge motorer, ingen tusenvis av linjer med boilerplate-kode.

Problemet med de fleste veiledninger er at de enten begraver deg i 40 sider med teori eller etterlater deg med «fullfør det selv». Her tar vi en mellomvei: vi forklarer akkurat nok til at du forstår hver linje, og bygger umiddelbart et fungerende spill med en figur som beveger seg over skjermen med WASD. Hele koden får plass på 60 linjer.

💡 Rask oversikt:

• Installer Pygame via pip og opprett en spillfil, det tar et par minutter
• Forstå spilløkken: hendelser, beregninger, rendering, tre faser som lever i en evig while True
• Skriv en spillerklasse og gi den liv: WASD-tastene flytter spriten, skjermen tegnes på nytt 60 ganger i sekundet
• Forstå koordinatsystemet og fargehåndtering, to hjørnesteiner som understøtter all 2D-grafikk

Hva er Pygame og hvorfor velge det

Pygame er et bibliotek for Python som pakker inn multimedia-biblioteket SDL (Simple DirectMedia Layer) i et praktisk Python-API. SDL håndterer lavnivå grafikk, lyd og inndataenheter, mens Pygame gir tilgang gjennom kjente klasser og metoder. Den nåværende versjonen, 2.6.0, vedlikeholdes aktivt og fungerer på Windows, macOS og Linux.

For nybegynnere har Pygame tre udiskutable fordeler. For det første, lav inngangsterskel: du bruker vanlig Python-kode, ikke noe nytt språk eller visuell editor. For det andre, umiddelbar tilbakemelding: du skriver pygame.draw.rect(...) og et rektangel dukker opp på skjermen, ingen magi. For det tredje, forståelse av grunnlaget: Pygame skjuler ikke spilløkken og hendelseskøen for deg, du ser hvordan ethvert spill fungerer innvendig. Etter Pygame vil overgangen til Godot eller Unity være enklere fordi du allerede vet hva delta time og event polling er.

Biblioteket prøver ikke å være en spillmotor. Det har ikke noe scenesystem, fysikk eller innebygd nivåeditor, og det er et bevisst valg. Du kontrollerer hver piksel og hvert tick, noe som betyr at du lærer å tenke som en spillutvikler, ikke som en operatør av andres verktøy.

Installere Pygame på to minutter

Har du allerede Python 3.9 eller nyere? Åpne en terminal og kjør én kommando:

1
pip install pygame

For prosjektisolering er det bedre å opprette et virtuelt miljø:

1
python -m venv game_env
2
game_env\Scripts\activate     # Windows
3
source game_env/bin/activate  # macOS / Linux
4
pip install pygame

Sjekk at biblioteket er installert:

1
import pygame
2
print(pygame.version.ver)

Hvis du får 2.6.0 som svar (eller nyere, du kan sjekke gjeldende versjon på pygame.org), er du klar. Opprett en prosjektmappe, legg et hvilket som helst 80×80 piksler stort sprite-bilde med navnet player.png i den, og en tekstfil game.py, vi starter med det.

Hvordan spilløkken fungerer: hendelser, beregninger, rendering

Hjertet i ethvert spill er hovedløkken. Mens spillet kjører, inne i en evig while True, veksler tre faser:

• Hendelsesbehandling, hva har skjedd siden forrige bilde? Tast trykket? Mus flyttet? Vindu lukket? Pygame samler alle hendelser i en kø, og vi itererer gjennom den med for event in pygame.event.get().

• Logikkberegning, hvordan endret verden seg som respons på hendelser? Spiller trykket W, øk Y-koordinaten. Kule kolliderte med asteroide, merk begge for fjerning.

• Rendering, tegn alt som skal være på skjermen. Fyll bakgrunnen, plasser spriter på nye koordinater, kall pygame.display.update(), og spilleren ser et bilde.

Disse tre stegene gjentas 60 ganger i sekundet, nøyaktig bildefrekvensen (FPS) vi setter på timeren. Illusjonen av bevegelse bygger på at spriten forskyves et par piksler mellom bildene, mens øyet oppfatter dette som kontinuerlig animasjon.

Skrive første kode: flytte en sprite over skjermen

Her er den komplette spillkoden. Lagre den som game.py og plasser player.png i samme mappe:

1
#!/usr/bin/env python3
2
 
3
import pygame
4
import sys
5
 
6
WIDTH, HEIGHT = 360, 480
7
WHITE = (255, 255, 255)
8
 
9
class Player(pygame.sprite.Sprite):
10
 
11
    def __init__(self, image_path):
12
        super().__init__()
13
        self.image = pygame.image.load(image_path)
14
        self.x = WIDTH / 2
15
        self.y = HEIGHT / 2
16
        self.speed = 5
17
 
18
    def move(self, dx, dy):
19
        self.x += dx
20
        self.y += dy
21
 
22
def main():
23
    pygame.init()
24
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
25
    pygame.display.set_caption("First Game on Pygame")
26
 
27
    clock = pygame.time.Clock()
28
    fps = 60
29
 
30
    player = Player("player.png")
31
    dx, dy = 0, 0
32
 
33
    running = True
34
    while running:
35
        for event in pygame.event.get():
36
            if event.type == pygame.QUIT:
37
                running = False
38
 
39
            elif event.type == pygame.KEYDOWN:
40
                if event.key == pygame.K_d:
41
                    dx = player.speed
42
                elif event.key == pygame.K_a:
43
                    dx = -player.speed
44
                elif event.key == pygame.K_w:
45
                    dy = -player.speed
46
                elif event.key == pygame.K_s:
47
                    dy = player.speed
48
 
49
            elif event.type == pygame.KEYUP:
50
                if event.key in (pygame.K_d, pygame.K_a):
51
                    dx = 0
52
                elif event.key in (pygame.K_w, pygame.K_s):
53
                    dy = 0
54
 
55
        player.move(dx, dy)
56
        screen.fill(WHITE)
57
        screen.blit(player.image, (player.x, player.y))
58
        pygame.display.update()
59
        clock.tick(fps)
60
 
61
    pygame.quit()
62
    sys.exit()
63
 
64
if __name__ == "__main__":
65
    main()

Kjør python game.py, et vindu med hvit bakgrunn og spriten din i midten åpnes. Hold W, A, S eller D, figuren beveger seg. Slipp tasten, den stopper. Dette er allerede et ekte spill, om enn minimalt.

Hva som er forbedret sammenlignet med klassiske veiledninger: KEYUP-behandler er lagt til for tastetrykkslipp. Uten den ville spriten fortsatt ut av skjermen for alltid etter første trykk. Og koden er pakket inn i if __name__ == "__main__"-konstruksjonen, en god praksis som tillater import av filen som en modul uten å starte spillet.

Koordinatsystem og fargehåndtering

I Pygame telles koordinater fra øverste venstre hjørne: (0, 0), helt øverst til venstre. Bevegelse mot høyre øker X, bevegelse nedover øker Y. Dette skiller seg fra skolens koordinatsystem der Y vokser oppover, bare husk det og sjekk deg selv på de første to kjøringene: trykket S, spriten beveget seg ned, trykket W, opp.

Farge angis med en tuppel av tre tall (R, G, B), hver fra 0 til 255. Hvit tilsvarer (255, 255, 255), svart tilsvarer (0, 0, 0), rød tilsvarer (255, 0, 0). Metoden screen.fill(WHITE) fyller hele skjermen med den valgte fargen før hvert bilde rendres. Hvis du ikke gjør dette, vil spriten etterlate seg et spor av tidligere posisjoner.

Hva som skjer under panseret: linje for linje-gjennomgang

Player-klassen arver fra pygame.sprite.Sprite, Pygames innebygde klasse for spillobjekter. I konstruktøren laster vi bildet via pygame.image.load() og setter startposisjonen i skjermens sentrum: WIDTH / 2 og HEIGHT / 2. Metoden move(dx, dy) mottar forskyvning og legger den til gjeldende koordinater, ren aritmetikk, ingen magi.

Funksjonen main() bringer alt sammen. pygame.init() starter interne undersystemer. pygame.display.set_mode() oppretter et vindu, og screen er en Surface vi tegner på. pygame.time.Clock() oppretter en timer: dens tick(fps)-metode på slutten av løkken forteller Pygame «vent til 1/60 av et sekund har gått siden forrige bilde», slik fikser vi bildefrekvensen og sløser ikke med CPU.

Hovedløkken while running spinner til running-flagget blir False. Inni, de tre fasene vi snakket om ovenfor:

I for event in pygame.event.get()-løkken poller vi hendelseskøen. pygame.QUIT er signalet «bruker klikket på vinduslukkeknappen»: sett running = False, og ved neste iterasjon avsluttes løkken. pygame.KEYDOWN utløses når en tast trykkes, og KEYUP når den slippes. For D og A endrer vi dx, for W og S endrer vi dy. Når tasten slippes, nullstiller vi den tilsvarende hastighetskomponenten, spriten stopper.

screen.blit(player.image, (player.x, player.y)), metoden som «overlegger» ett bilde på et annet. I vårt tilfelle, spillerspriten på hovedskjermflaten ved gjeldende koordinater. pygame.display.update() oppdaterer vinduet, og spilleren ser det ferdige bildet.

Merk: player.move() kalles før screen.fill(). Hvis du bytter om på dem, vil spriten slettes i samme millisekund den dukker opp, du vil rett og slett ikke se den på skjermen. Rekkefølgen på operasjoner i spilløkken er kritisk.

Klikk på lukkeknappen, pygame.quit() avlaster Pygames undersystemer korrekt, og sys.exit() avslutter Python-prosessen. Uten pygame.quit() kan vinduet fryse ved lukking, en liten detalj, men kode bør være ryddig.

Kort video om temaet

Hvis tekstinstruksjonen ikke helt treffer, her er et utmerket videokurs på engelsk der de bygger Space Invaders i Pygame steg for steg. Alle konsepter fra artikkelen vises live:

⁉️🤔 Ofte stilte spørsmål

Trenger jeg å kunne OOP for Pygame?

Ja, på et grunnleggende nivå. Klasser, metoder, arv og self trenger du fra dag én: spiller, fiender, kuler og bonuser passer naturlig inn i en objektmodell. Hvis du har fullført et hvilket som helst introduksjonskurs i Python som forklarte class og __init__, er det nok. Resten plukker du opp underveis: Pygame krever ikke designmønstre, vanlig arv fra Sprite er tilstrekkelig for dusinvis av prototyper. Et spillobjekt i Pygame er en klasse som arver fra pygame.sprite.Sprite. I konstruktøren laster du spriten via pygame.image.load(), setter startkoordinater og hastighet. Metoden update() (eller din egen, som move()) endrer posisjon hvert bilde. Hovedløkken kaller update() på alle objekter, og rendrer dem deretter via screen.blit(). Ingen magi, bare metodekall i riktig rekkefølge 60 ganger i sekundet.

Blir Pygame tregt ved kompleks 2D-grafikk?

Med et fornuftig antall spriter, nei. Surfaces i Pygame lever i RAM, og blit er rask pikselkopiering, ikke programvarerendering. Med tusen samtidig bevegelige objekter kan du treffe Pythons ytelsesgrense, men for et plattformspill, top-down shooter eller tower defense er det nok margin. Hvis du trenger å presse ut maksimal ytelse, bruk pygame.sprite.Group med automatisk rendering og dirty rectangles for delvise skjermoppdateringer.

Kan jeg legge til lyd og musikk i Pygame?

Ja, rett ut av boksen. Modulen pygame.mixer kan spille av WAV og MP3. En skuddlyd startes via pygame.mixer.Sound("shoot.wav").play(), og bakgrunnsmusikk lastes via pygame.mixer.music.load("theme.mp3") og pygame.mixer.music.play(-1) (flagget -1 looper den). Eneste forbehold: pygame.mixer.init() må kalles før lasting av lyder, og for MP3 på Linux kan du trenge biblioteket libmpg123.

Er det noe poeng å lære Pygame i 2026 når Godot og Unity finnes?

Absolutt. Pygame er ikke en Godot-konkurrent, det er et pedagogisk verktøy og et lettvektslag for 2D-prototyper. Du lærer ikke C# bare for å flytte en firkant, og du setter deg ikke inn i nodesystemet for Pong. Pygame gir deg en forståelse av hvordan spill fungerer på et lavere nivå: spilløkke, bildebuffring, kollisjoner. Programmerere som startet med Pygame har lettere for Unity og Godot fordi de ser de levende mekanikkene bak motorens abstraksjoner. Ekte indie-prosjekter skrives i Pygame, inkludert kommersielle, et lite plattformspill eller puslespill kan utgis på Steam uten å røre C++.

Hva gjør jeg hvis spriten går ut av skjermen?

Legg til grensesjekk i move()-metoden: hvis self.x < 0, sett den til 0; hvis self.x + sprite_width > WIDTH, sett den til WIDTH - sprite_width. Samme for Y. Dette kalles clamping, og uten det vil figuren til slutt havne i et usynlig område. I mer avanserte spill er grenser nivåvegger definert via et rutenett eller en kollisjonsmatrise.

Klar til å lansere ditt første spill?

Kopier koden fra «Skrive første kode»-seksjonen, lagre den som game.py, plasser et hvilket som helst sprite-bilde ved siden av, og i løpet av noen sekunder vil du se et vindu med en bevegelig figur. Dette er inngangsporten til spillutvikling: ikke lesing, men lansering og begynnelse på å justere parametere.

Endre WIDTH og HEIGHT, vinduet blir større. Sett player.speed = 10, figuren vil bevege seg raskere. Bytt ut WHITE med (35, 35, 35), du får en mørk bakgrunn. Eksperimenter, og du vil forstå at et spillprogram ikke er magi, men en sekvens av steg du kontrollerer.

Når du har mestret bevegelse, ta fatt på kollisjoner (pygame.sprite.collide_rect()), animasjon (bytte av sprite sheet-bilder) og prosedyregenerering av nivåer. For å starte er én game.py-fil og ønsket om å forstå hvordan det fungerer nok.