Dag 4 - Minecraft Kodekurs

🌅 Oppstart og oppsummering (10 min)

Recap av dag 1-3: variabler, løkker, if-setninger, agenten, interaktive dører
Dagens mål: Lage farlige områder hvor monstre spawner når du går!

👣 Konsept: Oppdage spillerens bevegelse (20 min)

Hvordan kan vi vite hvor spilleren er?

Python kan sjekke spillerens posisjon
Vi kan sammenligne med tidligere posisjon
Hvis posisjon har endret seg = spilleren har beveget seg

Få spillerens posisjon:

Spillerens posisjon

pos = player.position()
x = pos.x  # øst/vest koordinat
y = pos.y  # opp/ned koordinat  
z = pos.z  # nord/sør koordinat

Sjekke om spilleren er på et spesielt sted:

Posisjon-sjekking

pos = player.position()
if pos.x > 100 and pos.z < 200:
    player.say("Du er i det farlige området!")

⚠️ Farlige områder:

Vi kan definere områder hvor det er farlig å gå
Når spilleren går inn i området, spawner monstre
Kombinerer posisjon-sjekking med monster-spawning

👾 Konsept: Monster-spawning med kommandoblocker (20 min)

Kommandoblocker kan spawne monstre:

Spawn monster kommando

/summon zombie x y z

Eksempel: /summon zombie 100 70 200 spawner en zombie på koordinat (100, 70, 200)

Forskjellige monstre:

zombie - zombie
skeleton - skjelett
spider - edderkopp
creeper - creeper

Systemet fungerer slik:

⚠️ Sammenkobling:

Python oppdager at spilleren er på farlig sted
Python plasserer en signalblokk
Kommandoblokk ser signalblokken og spawner monstre

🎯 Oppgave 1: Setup monster-spawning kommandoblokk (15 min)

📋 Trinn:

Plasser en kommandoblokk
Skriv inn: /summon zombie 100 70 200 (bruk dine koordinater)
Sett den til "Needs Redstone"
Test med en knapp at zombie spawner

⚠️ Viktig:

Velg koordinater hvor du vil at monstre skal spawne
Ikke for nær deg selv!
Skriv ned koordinatene

👁️ Vis fasit ▼

Fasit - Monster-spawning kommando

/summon zombie [dine_koordinater]

Eksempel: /summon zombie 100 70 200

Test: Koble til en knapp og sjekk at zombie spawner!

🎯 Oppgave 2: Python oppdager bevegelse (15 min)

Oppgave: Lag Python-kode som oppdager når spilleren går inn i et farlig område

👁️ Vis fasit ▼

Fasit - Bevegelsesdeteksjon

# Oppdager når spilleren går inn i farlig område
def farlig_område():
    while True:
        pos = player.position()
        
        # Definer farlig område (endre koordinater!)
        if pos.x > 90 and pos.x < 110 and pos.z > 190 and pos.z < 210:
            player.say("⚠️ Du har gått inn i det farlige området!")
            # Plasser signalblokk som trigger monster-spawning
            blocks.place(REDSTONE_BLOCK, world(120, 70, 220))
            # Vent litt så ikke alt spawner på en gang
            loops.pause(2000)
            # Fjern signalblokken
            blocks.place(AIR, world(120, 70, 220))
            
        loops.pause(500)  # Sjekk posisjon hver halvt sekund

# Start systemet
loops.run_in_background(farlig_område)

💡 Tips:

Endre koordinatene til dit du vil ha det farlige området
Signalblokken må være der kommandoblokken din lytter
loops.pause() bruker millisekunder (1000 = 1 sekund)

☕ Pause (10 min)

Tid for en pause før vi kobler alt sammen!

🎯 Oppgave 3: Koble Python og kommandoblokk (15 min)

📋 Oppgave:

Endre kommandoblokken til å lytte etter signalblokken fra Python
Test at monstre spawner når du går inn i det farlige området

⚠️ Husk:

Kommandoblokken må være på "Needs Redstone"
Plasser redstone fra signalblokk-koordinatet til kommandoblokken
Eller plasser kommandoblokken rett ved siden av signalblokk-koordinatet

👁️ Vis fasit - setup tips ▼

🔧 Setup-tips:

Plasser kommandoblokken på koordinat (120, 69, 220) - rett under signalblokken
Når Python plasserer redstone_block på (120, 70, 220), aktiverer det kommandoblokken under
Kommandoblokken spawner monster på valgt sted

👾 Hovedoppgave: Farlig dungeon med flere monstre (35 min)

📋 Stor oppgave i deler:

Del 1: Lag flere farlige områder (10 min)

Del 2: Forskjellige monstre i forskjellige områder (15 min)

Del 3: Legg til advarsler og escape-rute (10 min)

👁️ Vis fasit Del 1 - Flere områder ▼

Fasit Del 1 - Flere farlige områder

# System med flere farlige områder
def flere_farlige_områder():
    while True:
        pos = player.position()
        
        # Område 1: Zombie-sone
        if pos.x > 90 and pos.x < 110 and pos.z > 190 and pos.z < 210:
            player.say("⚠️ Zombie-sone! Løp!")
            blocks.place(REDSTONE_BLOCK, world(120, 70, 220))
            loops.pause(1000)
            blocks.place(AIR, world(120, 70, 220))
        
        # Område 2: Skjelett-sone  
        elif pos.x > 120 and pos.x < 140 and pos.z > 190 and pos.z < 210:
            player.say("🏹 Skjelett-sone! Pass deg!")
            blocks.place(REDSTONE_BLOCK, world(150, 70, 220))
            loops.pause(1000)
            blocks.place(AIR, world(150, 70, 220))
        
        # Område 3: Creeper-sone
        elif pos.x > 90 and pos.x < 110 and pos.z > 220 and pos.z < 240:
            player.say("💥 Creeper-sone! Ikke løp!")
            blocks.place(REDSTONE_BLOCK, world(120, 70, 250))
            loops.pause(1000)
            blocks.place(AIR, world(120, 70, 250))
            
        loops.pause(500)

loops.run_in_background(flere_farlige_områder)

👁️ Vis fasit Del 2 - Kommandoblokk oppsett ▼

🔧 Kommandoblokk-oppsett for Del 2:

Kommandoblokk 1 (Zombie-spawner):

Plasser på (120, 69, 220)
Kommando: /summon zombie ~ ~2 ~

Kommandoblokk 2 (Skjelett-spawner):

Plasser på (150, 69, 220)
Kommando: /summon skeleton ~ ~2 ~

Kommandoblokk 3 (Creeper-spawner):

Plasser på (120, 69, 250)
Kommando: /summon creeper ~ ~2 ~

👁️ Vis fasit Del 3 - Advansert system ▼

Fasit Del 3 - Komplett farlig dungeon

# Avansert dungeon med advarsler og sikker sone
def avansert_dungeon():
    i_farlig_område = False
    
    while True:
                        pos = player.position()
                        
                        # Sikker sone (ingen monstre)
                        if pos.x > 70 and pos.x < 90 and pos.z > 170 and pos.z < 190:
                            if i_farlig_område:
                                player.say("✅ Du er i sikkerhet!")
                                i_farlig_område = False
                        
                        # Advarsel-sone (gul advarsel)
                        elif pos.x > 85 and pos.x < 95 and pos.z > 185 and pos.z < 195:
                            player.say("⚠️ ADVARSEL: Farlig område foran!")
                            # Spawn advarsels-fakler
                            blocks.place(TORCH, world(pos.x + 1, pos.y, pos.z))
                            blocks.place(TORCH, world(pos.x - 1, pos.y, pos.z))
                        
                        # Zombie-sone (lett)
                        elif pos.x > 90 and pos.x < 110 and pos.z > 190 and pos.z < 210:
                            if not i_farlig_område:
                                player.say("🧟 Zombie-sone aktivert!")
                                i_farlig_område = True
                            # Spawn 1 zombie
                            blocks.place(REDSTONE_BLOCK, world(120, 70, 220))
                            loops.pause(3000)  # 3 sekunder mellom spawns
                            blocks.place(AIR, world(120, 70, 220))
                        
                        # Skjelett-sone (medium)
                        elif pos.x > 120 and pos.x < 140 and pos.z > 190 and pos.z < 210:
                            if not i_farlig_område:
                                player.say("🏹 Skjelett-sone aktivert!")
                                i_farlig_område = True
                            # Spawn 2 skjeletter
                            blocks.place(REDSTONE_BLOCK, world(150, 70, 220))
                            loops.pause(1000)
                            blocks.place(AIR, world(150, 70, 220))
                            blocks.place(REDSTONE_BLOCK, world(150, 70, 220))
                            loops.pause(2000)
                            blocks.place(AIR, world(150, 70, 220))
                        
                        # Boss-sone (vanskelig)
                        elif pos.x > 90 and pos.x < 110 and pos.z > 220 and pos.z < 240:
                            if not i_farlig_område:
                                player.say("💀 BOSS-SONE! EKSTREM FARE!")
                                i_farlig_område = True
                            # Spawn flere monstre raskt
                            for spawn_count in range(3):
                                blocks.place(REDSTONE_BLOCK, world(120, 70, 250))
                                loops.pause(500)
                                blocks.place(AIR, world(120, 70, 250))
                            loops.pause(2000)
                            
                        loops.pause(500)

loops.run_in_background(avansert_dungeon)

🌟 Ekstra utfordringer:

Lett: Legg til flere monster-typer
Medium: Lag en "boss-kamp" med mange monstre på en gang
Vanskelig: Lag feller som spawner monstre under spilleren

🏗️ Avanserte teknikker (15 min)

Spawne monstre på spillerens posisjon:

Kommando for spawn på spiller

/execute at @p run summon zombie ~ ~ ~

Spawne mange monstre på en gang:

Masse-spawning kommando

/summon zombie ~ ~ ~
/summon skeleton ~ ~1 ~
/summon spider ~ ~ ~1

💡 Profi-tips:

~ ~ ~ betyr "her hvor kommandoblokken er"
~ ~1 ~ betyr "1 blokk over kommandoblokken"
@p betyr "nærmeste spiller"

🏗️ Prosjektarbeid: Lag din egen farlige verden (25 min)

Velg ett av disse prosjektene:

🏰 Haunted Castle

Bygg et spøkelsesslott hvor monstre spawner i forskjellige rom

🌲 Dark Forest

Lag en mørk skog hvor fare lurker bak hvert tre

⚔️ Arena Battle

Bygg en arena hvor bølger av monstre angriper

🕳️ Trap Dungeon

Lag en felle-fylt dungeon med skjulte monstre

👁️ Vis eksempel-prosjekt ▼

Eksempel - Monster Arena

# Monster Arena - bølger av monstre
def monster_arena():
    arena_aktiv = False
    bølge_nummer = 0
    
    while True:
                        pos = player.position()
                        
                        # Når spilleren går inn i arenaen
                        if pos.x > 100 and pos.x < 120 and pos.z > 100 and pos.z < 120:
                            if not arena_aktiv:
                                arena_aktiv = True
                                player.say("⚔️ ARENA AKTIVERT! Kamp starter!")
                                
                                # Start bølge 1
                                for bølge in range(3):
                                    bølge_nummer = bølge + 1
                                    player.say(f"🌊 Bølge {bølge_nummer} starter!")
                                    
                                    # Spawn monstre basert på bølge-nummer
                                    for monster in range(bølge_nummer + 2):
                                        if bølge == 0:  # Lett bølge
                                            blocks.place(REDSTONE_BLOCK, world(130, 70, 130))
                                        elif bølge == 1:  # Medium bølge  
                                            blocks.place(REDSTONE_BLOCK, world(135, 70, 130))
                                        else:  # Vanskelig bølge
                                            blocks.place(REDSTONE_BLOCK, world(140, 70, 130))
                                        
                                        loops.pause(1000)
                                        blocks.place(AIR, world(130 + (bølge * 5), 70, 130))
                                        loops.pause(2000)
                                    
                                    player.say(f"✅ Bølge {bølge_nummer} fullført!")
                                    loops.pause(5000)  # Pause mellom bølger
                                
                                player.say("🏆 Arena fullført! Du vant!")
                                arena_aktiv = False
                        
                        # Spilleren forlater arenaen
                        else:
                            if arena_aktiv:
                                player.say("🏃 Du rømte fra arenaen!")
                                arena_aktiv = False
                                bølge_nummer = 0
                        
                        loops.pause(500)

loops.run_in_background(monster_arena)

🔧 Viktige tips og feilsøking (10 min)

⚠️ Husk alltid:

Redstone-tilkobling: Kommandoblokker trenger redstone-signal for å aktiveres
Koordinat-nøyaktighet: Python må plassere signalblokk nær kommandoblokken
Pause mellom spawns: Bruk loops.pause() så ikke alt skjer på en gang
Fjern signalblokker: Alltid rydde opp etter seg

🔧 Vanlige feil og løsninger:

❌ Monstre spawner ikke

Sjekk: Er kommandoblokken koblet til redstone? Er koordinatene riktige?

❌ For mange monstre

Løsning: Øk pause-tiden mellom spawns

❌ Python reagerer ikke

Sjekk: Kjører loopen i bakgrunnen? Riktige koordinater?

❌ Spilleren står fast

Løsning: Lag escape-ruter eller safe-zones

🛡️ Sikkerhetstips:

Lag alltid en sikker sone hvor spilleren kan hvile
Ikke spawn for mange monstre på en gang
Bruk /kill @e[type=zombie] for å fjerne alle zombies hvis det blir for mye

📝 Oppsummering av dag 4 (10 min)

🎉 Hva har vi lært i dag?

Oppdage spillerens posisjon med player.position()
Lage farlige områder basert på koordinater
Koble Python-deteksjon med kommandoblokk monster-spawning
Bruke /summon kommandoer for forskjellige monstre
Lage komplekse systemer med flere områder og monstre

🚀 I morgen (Dag 5):

Oppsummering av hele kurset
Jobbe videre på egne prosjekter
Forberede presentasjon for foreldre
Vise frem alt det kule vi har laget!

← Forrige: Dag 3 Neste: Dag 5 - Oppsummering →