Lag ditt eget spill: micro:bit, Arcade og Raspberry Pi

Vil barnet lage sitt eget spill? Begynn med noe det allerede liker: en figur som samler stjerner, en reaksjonsduell eller en liten arkademaskin. Her får dere fire ferdige spillprosjekter med kode, utstyrslister og forslag til egne endringer, fra MakeCode Arcade og micro:bit til Raspberry Pi med Python. Oppleggene passer også for lærere som vil knytte programmering til elevenes spillinteresse.

Plutselig er det pappa som vil ha skjermtid, og barnet som minner om oppvaskmaskinen. Bak spøken ligger en enkel idé: Spillinteressen kan bli utgangspunktet for å lage noe sammen. La barnet vise frem det det har skapt, og vær en nysgjerrig medspiller. «Vis meg hvordan det virker» er en fin start, også når du ikke kan programmere selv.

Fra gaming til kreativitet: la barnet bestemme noe

«Du liker jo å spille. Vil du bestemme hvordan neste nivå skal være?» er ofte en mer innbydende åpning enn «nå skal vi lære programmering». Spill gir noe konkret å snakke om: Hvorfor føles styringen treg? Hva gjør en bane spennende? Hvordan vet spillet at figuren har truffet en stjerne? Barnets erfaring som spiller blir nyttig når dere lager noe sammen.

Dette er et forslag til arbeidsmåte, ikke et løfte om at gaming automatisk gir lærelyst. La barnet velge tema, tegne figuren eller endre én regel. Utdanningsdirektoratet fremhever elevmedvirkning som en del av arbeidet med motivasjon og læring. Her betyr medvirkning at barnet faktisk får påvirke det dere bygger.

Velg et spillprosjekt og riktig utstyr

Tidene er forslag til planlegging, ikke aldersgrenser. En nybegynner med en voksen ved siden av kan komme langt, mens en erfaren elev kan gjøre samme prosjekt mer krevende. Velg etter erfaring og interesse. I gamingkategorien finner dere både programmerbare konsoller og spillbyggesett. De gjør ulike ting:

Meowbits micro:bit-lignende kantkontakt betyr ikke at alle micro:bit-utvidelser eller programmer virker på den. Kontroller støtten for akkurat kortet og programmeringsmiljøet. Et Raspberry Pi 5-startsett er også et alternativ til nivå 3, men dette lille spillet trenger ikke ekstra RAM eller en AI-modul.

Nivå 1: lag ditt eget spill i MakeCode Arcade

Resultatet: En grønn figur samler gule stjerner i 30 sekunder. Hver stjerne gir ett poeng og flyttes til motsatt halvdel av skjermen. Spilleren blir stående der den var. Det er et lite, fullstendig spill: styring, mål, poeng og slutt.

Få spillet til å virke før dere endrer det

1. Åpne MakeCode Arcade på datamaskinen, velg et nytt prosjekt og kall det Stjernejakt. Dette er en annen editor enn MakeCode for micro:bit.
2. Velg fanen JavaScript. Slett eksempelkoden og lim inn hele programmet under.
3. Start simulatoren. Bruk piltastene og treff stjernen. Kontroller at poengtallet øker med én.
4. Vent til de 30 sekundene er gått. Spillet skal avsluttes. Start simulatoren på nytt for en ny runde.
5. Velg Blocks for å se samme program som blokker. Figurene kan redigeres i bildeeditoren. Lagre også en prosjektfil på datamaskinen; nettleserens lagring alene er ingen sikkerhetskopi.

// MakeCode Arcade: lim inn hele filen i JavaScript-fanen.
scene.setBackgroundColor(8)
let spiller = sprites.create(img`
    . . 7 7 7 7 . .
    . 7 7 7 7 7 7 .
    7 7 1 7 7 1 7 7
    7 7 f 7 7 f 7 7
    7 7 7 7 7 7 7 7
    . 7 7 f f 7 7 .
    . 7 7 7 7 7 7 .
    . 7 . . . . 7 .
`, SpriteKind.Player)
let stjerne = sprites.create(img`
    . . . 5 . . . .
    . . 5 5 5 . . .
    5 5 5 5 5 5 5 .
    . 5 5 5 5 5 . .
    . . 5 5 5 . . .
    . 5 5 . 5 5 . .
    5 5 . . . 5 5 .
    . . . . . . . .
`, SpriteKind.Food)
controller.moveSprite(spiller, 80, 80)
spiller.setStayInScreen(true)
spiller.setPosition(80, 60)
stjerne.setPosition(20, 20)
info.setScore(0)
info.startCountdown(30)
sprites.onOverlap(SpriteKind.Player, SpriteKind.Food, function (a, b) {
    info.changeScoreBy(1)
    // Legg neste stjerne på motsatt halvdel, uten ny kollisjon.
    if (a.x < 80) {
        b.x = randint(96, 152)
    } else {
        b.x = randint(8, 64)
    }
    b.y = randint(20, 112)
})

Blokkfigurene viser koden over slik MakeCode tegner den. Blokknavnene er på engelsk, akkurat som i den engelske versjonen av editoren. Bytt språk i editorens innstillinger hvis navnene ser annerledes ut. Fargene i selve blokkene kommer fra MakeCode.

Hva gjør koden, og hva kan barnet endre?

sprites.create lager en spillfigur, ofte kalt en sprite. De små rutene mellom img-markørene er pikselbildet. controller.moveSprite knytter piltastene til figuren; tallene 80 og 80 er farten vannrett og loddrett. setStayInScreen(true) holder figuren innenfor skjermen.

sprites.onOverlap kjører når spilleren treffer en stjerne. Programmet gir ett poeng og flytter stjernen bort før neste bilde. randint velger et heltall tilfeldig. I info.startCountdown(30) er 30 antall sekunder, mens koordinatene viser plasseringen på spillflaten på 160 × 120 piksler.

• Første endring: tegn en katt, et romskip eller en potet i stedet for den grønne figuren.
• Ny spillregel: endre info.changeScoreBy(1) til info.changeScoreBy(2). Hvor mange stjerner trengs til 20 poeng nå?
• Test vanskelighetsgraden: endre 30 sekunder til 20, eller farten fra 80 til 100. Endre én ting om gangen og spill tre runder før dere vurderer resultatet.

En stjernepotet trenger ikke være den voksnes førstevalg. La barnet prøve sin egen idé, og undersøk sammen om spilleren fortsatt er lett å se og styre. Da blir tegning, testing og kode deler av samme prosjekt.

Vil dere bygge med blokker fra første klikk, er Microsofts Chase the Pizza en god veiledning. Den viser de samme grunnideene. Stjernejakt-koden her er et eget eksempel; den flytter stjernen bort fra spilleren og bruker en fast rundetid.

Fra nettleser til programmerbar spillkonsoll

1. Retro Arcade med micro:bit V2: velg maskinvaren micro:bit Arcade Shield (N3) i MakeCode Arcades nedlastingsvalg. Dette er navnet i MakeCodes maskinvareliste. Hvis kortet ikke vises, følg produsentens trinn for å slå på Experimental Hardware i editorens innstillinger. Følg ElecFreaks-veiledningen. Overfør den genererte .hex-filen til stasjonen MICROBIT. Bruk micro:bit-kortets USB-port, og sett kortet riktig vei i konsollen etter produsentens anvisning.
2. Meowbit: velg Meowbit som maskinvare. Følg KittenBots nedlastingsveiledning, sett konsollen i nedlastingsmodus og kopier .uf2-filen til ARCADE-F4. Den bruker ikke micro:bit-kortets .hex-fil.
3. Prøv alle retninger, poengtelling og avslutning på konsollen. Legg prosjektfilen og en kort beskrivelse av egen endring i samme mappe.

Ekstraprosjekt: lag romspillet Meteorvakt på Meowbit

Resultatet: Du styrer et lite romskip mot venstre og høyre og trykker A for å skyte meteorer. Hvert treff gir ett poeng. En meteor som treffer skipet eller passerer nederste skjermkant, koster ett liv. Du starter med tre liv og vinner når du har truffet 20 meteorer. Nye meteorer faller litt raskere etter hvert som poengsummen øker.

MRSMARTs produktbeskrivelse oppgir at batteri ikke følger med denne utgaven. Begynn derfor med strøm fra USB. Pakker hos produsenten kan ha annet innhold. Spillet trenger verken sensorer, utvidelseskort eller microSD-kort.

1. Lag prosjektet og prøv det i nettleseren

1. Åpne MakeCode Arcade, velg New Project og kall prosjektet Meteorvakt. Bruk Arcade-editoren, ikke MakeCode for micro:bit.
2. Velg JavaScript, slett eksempelkoden og lim inn hele programmet under. Bildene av skip, skudd og meteorer ligger i koden, så ingen bildefiler eller utvidelser må lastes inn.
3. Start simulatoren. Bruk venstre og høyre pil, og klikk A-knappen i simulatoren for å skyte. Hvert nytt trykk gir ett skudd; det å holde knappen inne gir ikke automatisk skyting.
4. Treff en meteor og kontroller at poengsummen øker med én. Slipp deretter en meteor forbi skipet og se at ett liv forsvinner. Mister du alle tre livene, skal runden avsluttes.
5. Start på nytt fra sluttskjermen med en spillknapp, eller bruk simulatorens omstart. Spill til 20 poeng for å kontrollere seiersskjermen. Ikke endre koden før grunnversjonen virker.

scene.setBackgroundColor(15)
info.setScore(0)
info.setLife(3)

let skip = sprites.create(img`
    . . . 9 9 . . .
    . . 9 1 1 9 . .
    . . 9 1 1 9 . .
    . 9 9 1 1 9 9 .
    9 9 9 1 1 9 9 9
    9 . 9 9 9 9 . 9
    . . 4 . . 4 . .
    . . 5 . . 5 . .
`, SpriteKind.Player)
skip.setPosition(80, 108)
skip.setStayInScreen(true)
controller.moveSprite(skip, 100, 0)

controller.A.onEvent(ControllerButtonEvent.Pressed, function () {
    sprites.createProjectileFromSprite(img`
        5
        5
        5
        5
    `, skip, 0, -120)
})

game.onUpdateInterval(900, function () {
    let meteor = sprites.create(img`
        . . e e e . . .
        . e e d e e . .
        e e d d e e e .
        e e e e e d e e
        e d e e e e e e
        . e e e d e e .
        . . e e e e . .
        . . . e e . . .
    `, SpriteKind.Enemy)
    meteor.setPosition(randint(8, 152), -4)
    meteor.vy = 30 + Math.min(info.score(), 20)
})

sprites.onOverlap(SpriteKind.Projectile, SpriteKind.Enemy, function (skudd, meteor) {
    skudd.destroy()
    meteor.destroy()
    info.changeScoreBy(1)
})

sprites.onOverlap(SpriteKind.Player, SpriteKind.Enemy, function (spiller, meteor) {
    meteor.destroy()
    info.changeLifeBy(-1)
})

game.onUpdate(function () {
    for (let meteor of sprites.allOfKind(SpriteKind.Enemy)) {
        if (meteor.top > 120) {
            meteor.destroy()
            info.changeLifeBy(-1)
        }
    }
})

info.onLifeZero(function () {
    game.over(false)
})
info.onScore(20, function () {
    game.over(true, effects.confetti)
})

2. Forstå de fem delene i spillet

Løkken i game.onUpdate rydder bort meteorer som har passert nederst. Det hindrer at usynlige meteorer blir liggende igjen i spillet. Tallet 120 gjelder MakeCode Arcades spillflate, ikke antall piksler som står oppgitt for selve LCD-panelet.

Vil du lære de samme grunnideene gjennom et ferdig blokkbasert opplegg, er Microsofts Galga-veiledning en passende fortsettelse. Meteorvakt er vårt eget, enklere eksempel med et fast mål og tydelige regler for meteorer som slipper forbi.

3. Last spillet over på Meowbit

1. Koble Meowbit direkte til datamaskinen med mikro-USB-datakabelen. Slå konsollen på. La kantkontakten være fri; prosjektet bruker bare de innebygde knappene og skjermen.
2. Sett Meowbit i nedlastingsmodus med RESET-knappen på siden. Når Arcade-fastvaren er aktiv, skal datamaskinen vise stasjonen ARCADE-F4. Se plasseringen av knappen i KittenBots Meowbit-veiledning.
3. I MakeCode Arcade velger du Download og maskinvaren Meowbit. Kontroller at filen du får, slutter på .uf2. Ikke velg micro:bit Arcade Shield og ikke bruk en .hex-fil.
4. Kopier den nedlastede .uf2-filen til ARCADE-F4. Vent til kopieringen er ferdig. Konsollen skal starte programmet; stasjonen kan forsvinne når den går tilbake til spillet.
5. Prøv venstre, høyre og A på selve konsollen. B og opp/ned har ingen funksjon i denne versjonen. Test både treff, mistet liv og omstart fra sluttskjermen.
6. Eksporter og lagre prosjektet fra editoren på datamaskinen. Behold også teksten i meteorvakt.ts. ARCADE-F4 er en overføringsstasjon, ikke en mappe du kan hente sikkerhetskopien av prosjektet fra.

4. Gjør Meteorvakt til barnets eget spill

Velg Blocks for å se koden som blokker. Åpne bildeeditoren i blokken som lager skipet, og tegn en rakett, en flyvende katt eller en rompotet. Behold omtrent samme størrelse først: større figurer blir lettere truffet. Tegn gjerne forslaget på rutepapir før dere endrer pikslene.

La én person være utvikler og den andre tester. Endre bare én ting, spill tre runder og sammenlign: Ble styringen bedre med 80 i stedet for 100? Ble 1200 millisekunder mellom meteorene for lett? Når dere senker seiersmålet til 10, må testplanen også si 10. Ta vare på grunnversjonen så dere kan gå tilbake.

Nivå 2: bygg et reaksjonsspill med micro:bit og LED

Resultatet: B starter runden. Slipp knappene og vent på haken i LED-matrisen. Trykk A så raskt du kan. Kortet viser reaksjonstiden i millisekunder. Trykker du før signalet, kommer «FOR TIDLIG». En rød LED utenfor kortet tennes samtidig med startsignalet.

Her er utfordringen å lage rettferdige regler: tilfeldig ventetid, kontroll av tyvstart og en tydelig avslutning. Dere kan dele kortet og sammenligne fem forsøk hver. Ikke sammenlign barn som om dette var en medisinsk eller standardisert reaksjonstest; programmet er et læringsprosjekt med skjerm- og kodeforsinkelser.

Koble én LED, eller start med kortet alene

1. Koble ringkontakten P1 til den ene enden av motstanden på 1 kΩ.
2. Koble den andre enden av motstanden til LED-ens anode, vanligvis det lange beinet.
3. Koble LED-ens katode, vanligvis det korte beinet ved den flate kanten, til ringkontakten GND. Kontroller polariteten mot merkingen hvis beina er klippet.
4. Kontroller hele strømveien: P1 → motstand → LED → GND. Koble til USB igjen.

Ved omtrent 3,3 V fra pinnen og 2,0 V over den røde LED-en gir 1 kΩ omtrent (3,3 − 2,0) / 1000 = 0,0013 A, altså 1,3 mA. Den faktiske strømmen avhenger av LED-en og spenningen fra pinnen. Lysstyrken blir moderat. LED-settet har 1 kΩ-motstander; ikke forveksle dem med 330 Ω fra andre sett. micro:bit-dokumentasjonen beskriver pinnene og de elektriske egenskapene.

Har dere et Discovery Kit fra før, inneholder det adapter, koblingsbrett, LED-er, ledninger og 330 Ω-motstander. Med en rød LED på omtrent 2,0 V gir 330 Ω rundt 4 mA. Dette er en alternativ krets; tegningen her bruker 1 kΩ. Se også kategoriene for koblingsbrett og prototyping og koblingsledninger.

Legg inn programmet og test reglene

1. Åpne MakeCode for micro:bit, opprett et prosjekt og velg JavaScript. Lim inn hele koden nedenfor.
2. Last ned programmet som .hex og overfør det til MICROBIT. Programmet fungerer også uten den eksterne LED-en: haken på kortet er startsignalet.
3. Trykk B og slipp begge knappene. Kortet viser en liten firkant mens det venter mellom to og fem sekunder. Trykk A etter haken; tallet er millisekunder. Trykk B for neste runde.
4. Prøv bevisst å trykke A for tidlig. Prøv også å vente uten å trykke: etter fem sekunder skal programmet vise «TIMEOUT». LED-en skal slukke etter runden.

// MakeCode for micro:bit. B starter, A måler reaksjonen.
// Valgfri rød LED: P1 -> 1 kΩ -> anode, katode -> GND.
pins.digitalWritePin(DigitalPin.P1, 0)
basic.forever(function () {
    basic.showString("B", 100)
    while (!(input.buttonIsPressed(Button.B))) {
        basic.pause(5)
    }
    while (input.buttonIsPressed(Button.A) || input.buttonIsPressed(Button.B)) {
        basic.pause(5)
    }
    basic.showIcon(IconNames.SmallSquare, 0)
    let klarVed = input.runningTime() + randint(2000, 5000)
    let forTidlig = false
    while (input.runningTime() < klarVed) {
        if (input.buttonIsPressed(Button.A)) {
            forTidlig = true
            break
        }
        basic.pause(1)
    }
    // Sjekk også grensen mellom venting og startsignalet.
    if (input.buttonIsPressed(Button.A)) {
        forTidlig = true
    }
    if (forTidlig) {
        basic.showString("FOR TIDLIG", 100)
    } else {
        pins.digitalWritePin(DigitalPin.P1, 1)
        basic.showIcon(IconNames.Yes, 0)
        let start = input.runningTime()
        while (!(input.buttonIsPressed(Button.A))) {
            if (input.runningTime() - start >= 5000) {
                break
            }
            basic.pause(1)
        }
        let tid = input.runningTime() - start
        pins.digitalWritePin(DigitalPin.P1, 0)
        if (tid < 5000) {
            basic.showNumber(tid)
        } else {
            basic.showString("TIMEOUT", 100)
        }
    }
    while (input.buttonIsPressed(Button.A) || input.buttonIsPressed(Button.B)) {
        basic.pause(5)
    }
    basic.pause(500)
})

Se måledelen som ekte MakeCode-blokker

De grå feltene bevarer JavaScript-kode som MakeCode ikke gjør om til vanlige blokker. Endre disse linjene i JavaScript-fanen. De grå feltene er en del av editorens egen visning, ikke blokker du skal lete etter i menyen.

input.runningTime() leser tiden siden kortet startet. Når du trykker A, trekker programmet starttidspunktet fra gjeldende tid. input.buttonIsPressed leser om knappen er nede, i stedet for å vente på hendelsen som kommer etter at knappen slippes. Pausene lar kortet behandle andre oppgaver; de gir ikke en garantert måleoppløsning på ett millisekund.

forTidlig er en boolsk variabel: enten sann eller usann. digitalWritePin slår P1 av og på. Null som siste argument til showIcon unngår ikonets vanlige visningspause før tidtakingen. Det er et fint sted å snakke om at en linje kode som ser uskyldig ut, kan påvirke spillets rettferdighet.

Prøv selv: skriv ned fem gyldige tider og sorter dem fra kortest til lengst og finn den midterste, altså medianen. Endre deretter ventetiden til mellom tre og sju sekunder. Blir det vanskeligere å gjette startsignalet? Vil dere lage to store håndlagde knapper, viser micro:bit Foundations Reaction game et eget opplegg med papp, folie og berøring. Det bruker en annen kobling og annen kode enn LED-prosjektet her.

Nivå 3: lag et Python-spill og en arkademaskin med Raspberry Pi

Resultatet: En kurv flyttes mot venstre og høyre for å fange fallende stjerner. En fanget stjerne gir ett poeng. En bom koster ett av tre liv. Stjernene faller raskere etter hvert, og etter siste liv vises en sluttskjerm med mulighet for en ny runde. Spillet tegner alt selv, så det trenger ingen bilder, konto eller nedlastede spillfiler.

Installer, lagre og start

1. Sett opp Raspberry Pi OS med skrivebord og få skjerm, nettverk, tastatur og mus til å virke. Følg startguiden for Raspberry Pi hvis dere begynner med et tomt minnekort. Raspberry Pi Pico er en annen type kort og kjører ikke dette skrivebordsprogrammet.
2. Åpne Terminal på Raspberry Pi og kjør kommandoene under. De installerer pygame fra operativsystemets pakkekilde.
3. Åpne Thonny eller en teksteditor, lim inn hele Python-programmet og lagre det som stjernefangst.py i hjemmemappen. Ikke kall filen pygame.py; det ville skjule biblioteket.
4. Kjør python3 ~/stjernefangst.py fra Terminal på skrivebordet. Bruk venstre og høyre piltast. Esc avslutter; mellomrom starter på nytt etter at alle liv er brukt.

sudo apt update
sudo apt install python3-pygame

"""Eget pygame-spill. Ingen bilder, konto eller spillfiler trengs.

Kjør: python3 stjernefangst.py
USB-kontroller: python3 stjernefangst.py --joystick
Annen vannrett akse: legg til --axis 1, eventuelt --invert.
"""
import argparse
import random
import pygame

parser = argparse.ArgumentParser()
parser.add_argument("--joystick", action="store_true")
parser.add_argument("--axis", type=int, default=0)
parser.add_argument("--invert", action="store_true")
args = parser.parse_args()
pygame.init()
screen = pygame.display.set_mode((800, 600))
pygame.display.set_caption("Stjernefangst")
font = pygame.font.Font(None, 32)
clock = pygame.time.Clock()
pad = None
if args.joystick:
    pygame.joystick.init()
    if pygame.joystick.get_count() == 0:
        pygame.quit()
        raise SystemExit("Ingen USB-kontroller. Koble til før programmet starter.")
    pad = pygame.joystick.Joystick(0)
    pad.init()
    print(pad.get_name(), "akser:", pad.get_numaxes(), "retningskryss:", pad.get_numhats())
    if args.axis < 0 or (pad.get_numaxes() and args.axis >= pad.get_numaxes()):
        pygame.quit()
        raise SystemExit("Ugyldig --axis. Velg en av aksene fra 0 og oppover.")


def new_game():
    return {"x": 355.0, "star_x": random.randint(20, 780),
            "star_y": -20.0, "score": 0, "lives": 3, "over": False}


def label(text, x, y):
    screen.blit(font.render(text, True, (238, 241, 243)), (x, y))


game = new_game()
running = True
try:
    while running:
        # Sekunder siden forrige bilde; ikke hopp langt etter et vindusbytte.
        dt = min(clock.tick(60) / 1000.0, 0.05)
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_ESCAPE:
                    running = False
                elif event.key == pygame.K_SPACE and game["over"]:
                    game = new_game()
            elif event.type == pygame.JOYBUTTONDOWN and game["over"]:
                game = new_game()
            elif event.type == pygame.JOYDEVICEREMOVED and pad is not None:
                if event.instance_id == pad.get_instance_id():
                    pad = None  # Piltastene fortsetter å virke.

        keys = pygame.key.get_pressed()
        direction = int(keys[pygame.K_RIGHT]) - int(keys[pygame.K_LEFT])
        if pad is not None:
            horizontal = pad.get_axis(args.axis) if pad.get_numaxes() else 0
            if pad.get_numhats() and pad.get_hat(0)[0] != 0:
                horizontal = pad.get_hat(0)[0]
            if args.invert:
                horizontal = -horizontal
            if abs(horizontal) > 0.25:  # Dødsone mot små bevegelser.
                direction = 1 if horizontal > 0 else -1

        if not game["over"]:
            game["x"] = max(0, min(710, game["x"] + direction * 380 * dt))
            game["star_y"] += (160 + min(game["score"], 20) * 12) * dt
            basket = pygame.Rect(round(game["x"]), 540, 90, 22)
            star = pygame.Rect(game["star_x"] - 10, round(game["star_y"]) - 10, 20, 20)
            caught = basket.colliderect(star)
            missed = game["star_y"] > 610
            if caught or missed:
                if caught:
                    game["score"] += 1
                else:
                    game["lives"] -= 1
                game["star_x"] = random.randint(20, 780)
                game["star_y"] = -20.0
                game["over"] = game["lives"] == 0

        screen.fill((23, 38, 50))
        pygame.draw.rect(screen, (84, 199, 171), (round(game["x"]), 540, 90, 22), border_radius=5)
        sx, sy = game["star_x"], round(game["star_y"])
        points = [(sx, sy-12), (sx+4, sy-4), (sx+12, sy-4), (sx+6, sy+3),
                  (sx+8, sy+12), (sx, sy+7), (sx-8, sy+12), (sx-6, sy+3),
                  (sx-12, sy-4), (sx-4, sy-4)]
        pygame.draw.polygon(screen, (250, 202, 75), points)
        label(f"Poeng: {game['score']}    Liv: {game['lives']}", 20, 18)
        label("Piltaster: flytt   Esc: avslutt", 20, 572)
        if game["over"]:
            label("Spillet er over!", 300, 265)
            label("Mellomrom / kontrollerknapp: nytt spill", 175, 305)
        pygame.display.flip()
finally:
    pygame.quit()

Fire deler som får spillet til å henge sammen

dt er antall sekunder siden forrige bilde. Derfor henger bevegelsen sammen med tid, ikke bare antall bilder. Koden begrenser tidssteget etter et vindusbytte. Ved treff eller bom flyttes den samme stjernen tilbake over skjermen; en kollisjon gir derfor bare ett poeng. min(score, 20) setter et tak på økningen i fallfart.

Dette er et selvstendig prosjekt med vanlige pygame-funksjoner. For en annen ferdig spillidé med en linjevis forklaring, se pygame-prosjektets Chimp-veiledning. pygame-dokumentasjonen viser også den grunnleggende spilløkken.

Gi spillet joystick og et eget kabinett

Et arkadesett med USB-tilkobling bruker et koderkort mellom knappene og Raspberry Pi. Det er en annen løsning enn å koble knapper til GPIO. Følg koblingsmerkingen og monteringsveiledningen som hører til settet. Koble kontrolleren til USB før spillet startes. Programmet bruker den første kontrolleren operativsystemet finner.

python3 ~/stjernefangst.py --joystick

Prøv venstre og høyre. Programmet leser første akse og første retningskryss, hvis kontrolleren har dem. Hvis vannrett bevegelse ligger på en annen akse, prøv for eksempel --axis 1; tell fra null og bruk antallet akser som skrives i terminalen. Går kurven motsatt vei, legg til --invert. Ikke alle USB-kodere har samme oppsett. Piltastene virker fortsatt, og en kontrollerknapp starter en ny runde etter spillets slutt.

Bygg først et kabinett i papp. Merk av skjerm, joystick og knapper før dere skjærer hull. Fest elektronikken slik at løse metalldeler ikke kortslutter kortet, og la ventilasjonen være åpen. En voksen hjelper med kniv, boring og eventuell lodding. La Raspberry Pi få strøm fra sin vanlige strømforsyning; ikke koble knappelys eller 12 V til GPIO. Integrert lys i arkadeknapper krever korrekt separat kobling etter settets dokumentasjon og inngår ikke i dette opplegget.

Vil dere senere lage en kontroller direkte på GPIO, fortsetter dere med Raspberry Pi GPIO med Python, knapper og LED. Det er et eget koblingsprosjekt. Det trengs ikke for USB-versjonen her.

Et undervisningsopplegg som viser mer enn ferdig kode

La målet være «jeg kan forklare én regel og endre den», ikke «jeg har limt inn et langt program». Knyt oppgaven til elevenes nivå. Variabler, løkker, vilkår og funksjoner står sentralt i læreplanen i valgfaget programmering. Spillprosjektene gir konkrete eksempler på disse begrepene; de er ikke et fullstendig undervisningsopplegg for alle kompetansemål.

1. Spill og undersøk: bruk fem minutter på originalen. Hva teller som et poeng, og når slutter spillet?
2. Velg én endring: la hvert par skrive sin regel med vanlige ord før de endrer kode.
3. Forutsi og test: skriv hva dere tror skal skje, spill en runde og noter hva som faktisk skjedde.
4. Bytt spill med et annet par: testeren beskriver én ting som er tydelig og én ting som er vanskelig.
5. Forklar: vis kodebiten som styrer regelen. Ta vare på både første og endret versjon.

Noen vil tegne figurer; andre vil justere regler, bygge knappene eller skrive kode. Bytt på rollene så alle får prøve mer enn det de allerede kan. Bruk den detaljerte guiden micro:bit i skolen når dere trenger flere oppgaver og koblinger til fag. Den tekniske innføringen finnes i micro:bit-programmering med MakeCode og Python.

Vanlige spørsmål om å lage egne spill

Kan barn lage spill uten å kunne programmere fra før?

Ja. Begynn med det ferdige MakeCode Arcade-programmet, spill en runde og endre figuren eller poengverdien. En voksen kan hjelpe med å finne riktig blokk og lagre prosjektet. Forklar én endring om gangen.

Trenger vi en spillkonsoll for MakeCode Arcade?

Nei, simulatoren kjører i nettleseren. En kompatibel konsoll gir fysiske knapper og en håndholdt versjon etterpå. Retro Arcade i denne guiden trenger micro:bit V2 i tillegg, mens Meowbit har egen prosessor.

Er MakeCode Arcade og MakeCode for micro:bit det samme?

De er to forskjellige editorer. Stjernejakt bruker Arcade med spillfigurer og fargeskjerm. Reaksjonsspillet bruker micro:bit-editoren og kortets egne knapper og pinner. Kopier koden til riktig editor.

Kan vi bruke Raspberry Pi 5 til arkadespillet?

Ja, Python-prosjektet er laget for Raspberry Pi OS med skrivebord og pygame på Pi 4 eller Pi 5. Det trenger ikke RetroPie. Start med tastatur og legg til en USB-kontroller etter at grunnspillet virker.

Er dette en oppskrift på en RetroPie-konsoll?

Her lager dere egen spillkode. RetroPie er en annen vei, der programvare emulerer eldre systemer. Ingen ROM-filer eller kommersielle spill er nødvendige for prosjektene i denne guiden.

Hva vil dere bygge etter det første spillet?

Velg neste steg etter det barnet likte best. For den som liker knapper og montering, er et reaksjonsspill som loddesett eller et elektronisk minnespill en konkret fortsettelse. Disse settene trener først og fremst montering og lodding; de er ikke en direkte måte å laste inn MakeCode-spill på.

For den som vil at koden skal bevege noe, kan Cutebot med micro:bit gjøre gulvet til en hinderløype. Følg Cutebot-guiden, eller se roboter for nybegynnere. For flere skjermer, sensorer og styringer finnes Raspberry Pi, micro:bit og tilbehør og mikrokontrollere og små datamaskiner.

Det viktigste neste steget trenger likevel ikke være et nytt produkt. La barnet vise spillet til noen, forklare én regel og finne på én forbedring. Da har dere et naturlig utgangspunkt for neste byggeøkt.

Og hvis testeren plutselig vil ha «bare én runde til», har barnet i alle fall laget noe som vekker interesse. Avtal når testøkten er ferdig, og la barnet spørre hva som fungerte. En morsom runde kan bli starten på neste forbedring, også når testeren er pappa.