yourschool
yourschoolPLUS
Classic
Meine erste Website in HTML & CSS
Quiz in Python
How to work with Scratch
How to work with Microbit
Klimaquiz mit HTML, CSS und Javascript
Meteoritenalarm
Minecraft: Hausbau leicht gemacht
Energienetzwerke in Svelte
Archived: Bash IT-Security Verschlüsselung

Minecraft: Hausbau leicht gemacht

Das Verständnis zur Grundidee und zum Ablauf der Kurse in unserem Classic-Format ist notwendige Voraussetzung zur Durchführung eines Kurses. Unsicher?

Minecraft: Hausbau leicht gemacht

Kennenlernen

Vorstellungsrunde mit Programmiererfahrung/Motivation

Ihr stellt euch vor und erzählt, wie ihr zur Hacker School und zum Coden gekommen seid.
Nun die Teilnehmer:

  • Wie heißt Du? (Achtet darauf, dass die Kinder sich nur mit Vornamen vorstellen – Datenschutz.)
  • Warum bist Du hier?
  • Hast Du schon mal programmiert?
  • Was willst Du lernen?
Vorstellung interaktiver gestalten? (!Klick mich an!)

In unserem Inspirer Handbuch findet ihr
weitere Spielideen.
Wenn Du die Vorstellung etwas interaktiver gestalten möchtest, empfehlen wir das Spiel “Alle, die”, was im folgenden erklärt wird:

Spielidee und Ziel

  • Wir kommen locker und leicht mit den Teilnehmer*innen ins Gespräch und erfahren, was sie gerne mögen (positiver Beziehungsaufbau).
  • Wir können eine erste Diagnose stellen, was die Schülerinnen und Schüler können, was sie gerne mögen.

Ablauf

  1. Stellt Euch vor die Klasse.
  2. Ein*e Inspirer sagt: “Alle, die”-Frage z.B: “Alle, die Sport in der Freizeit machen?”.
  3. Alle, die sich angesprochen fühlen, stehen von ihrem Platz auf.
  4. Die*der Inspirer stellt Rückfragen und kommt ins Gespräch mit den Teilnehmer*innen, z.B. “Cool, du in der ersten Reihe: Wie heißt du? [Antwort] Welchen Sport machst du denn gerne? [Gespräch entsteht] Super und du in der letzten Reihe…”.
  5. Die*der Inspirer sagt: "Alle wieder setzen".
  6. Die*der Inspirer stellt die nächste Frage: z.B. “Alle, die gerne Spiele auf dem Handy oder Computer spielen!”
  7. Siehe 3.-5.
  8. Spielt das Ganze etwa 5 min (nach Gefühl)
Sammlung möglicher Fragen (!Klick mich an!)

Diese Sammlung kann gern erweitert oder angepasst werden.

IT/Programmieren

  • Wer hat schon mal programmiert?
  • Wer kann sich vorstellen etwas mit Programmieren und IT zu machen?

Hobbies

  • Wer von Euch macht Sport in der Freizeit?
  • Wer spielt ein Instrument?
  • Wer spielt Computerspiele?
  • Wer spielt Handyspiele?

Lustiges

  • Wer hat eine Schuhgröße größer als 35?

Letzte Frage

  • Wer ist schon in repl.it angemeldet?

Minecraft kennenlernen

Lass zuerst die Kinder Minecraft starten und kennenlernen. Vermutlich werden einige Kinder dabei sein, die Minecraft noch nie gespielt haben.

Erstelle eine neue Welt

Nach dem Starten muss eine Welt gestartet werden. Klicke hierzu auf Spielen.

Wir benötigen eine neue Welt, klicke hierzu auf Neu Erstellen und dann Neu.


Damit wir einfach bauen können, wollen wir den Modus zu Kreativ ändern.

Damit wir gut bauen können, benötigen wir eine flache Welt. Hierzu muss der Welttyp auf Flach geändert werden.

Damit wir programmieren können, müssen zusätzlich Cheats aktiviert werden. Diese Einstellung findet sich ziemlich weit unten im Menü.

Jetzt sind alle Einstellungen aktiv und die Welt kann mit Spielen generiert werden.

Lerne die Steuerung kennen

Lass die Kinder sich mit der Steuerung vertraut machen.

    Eine kurze Anleitung zur Steuerung findet ihr hier:

  • Schau dich mit der Maus um
  • Bewege dich mit W A S D
  • Mit LEERZEICHEN kann man springen
  • Mit 2x LEERZEICHEN kann man fliegen
  • Mit E öffnet man das Inventar und kannst Blöcke in der Auswahlleiste unter dem Fenster platzieren
  • Mit der LINKEN MAUSTASTE kann man Blöcke zerstören
  • Mit der RECHTEN MAUSTASTE kann man den Block, der gerade ausgewählt ist, platzieren

Baue ein Haus

Um Minecraft kennen zu lernen, wollen wir ein quadratisches Haus bauen.
Ein Haus besteht aus einem Fußboden, 4 Wänden und einem Dach. Um es einfach zu halten, werden wir beim Programmieren ein Flachdach nutzen. Damit wir zwischen Fußboden, Wänden und Dach unterscheiden können, nutzen wir am besten verschiedene Materialien.



Programmiere mit Minecraft

Öffne die Programmierumgebung

Um zu programmieren, müssen wir den Code Editor starten. Diesen öffnen wir mit der Taste C. Wähle als Editor Microsoft MakeCode aus.

Starte ein Neues Projekt und benenne es. Gehe anschließend zur Programmieroberfläche mit Erstelle.


Lerne den Agenten kennen Teil 1

Der Agent ist eine Art Roboter. Wir können ihm Befehle geben, die er dann ausführt.
Wir wollen den Agenten mittels Chat-Befehlen steuern. Da wir den Block beim Start nicht benötigen, löschen wir diesen, indem wir ihn in die Seitenleiste ziehen.

Wir wollen den Agenten beim Eingeben von “run” zu uns teleportieren. Drücke auf den grünen Pfeil um den Code zum Spiel hinzuzufügen.

Um den Code auszuführen, drücken wir T und geben run ein. Anschließend wird die Eingabe mit ENTER bestätigt. Schau dich um, bei dir müsste jetzt der Agent stehen.

zurück zum Code Editor

Wenn der Kurs für Python oder Javascript ist, geht anschließend zurück in den Code Editor mit C und wechselt zur entsprechenden Programmiersprache. Besprich mit den Teilnehmenden, was ein Objekt ist und was eine Funktion ist und wie die Schreibweise ist.

Erläutert die Punktnotation, was die verschiedenen Klammern bedeuten, wie eine Funktion definiert wird und was Parameter sind.

1
2
3
4
5
JavaScript
player.onChat("run", function on_on_chat() {
    agent.teleportToPlayer()
})

Schreibe zur einfacheren Erklärung die Funktion um in:

1
2
3
4
5
6
JavaScript
function on_on_chat() {
    agent.teleportToPlayer()
}
player.onChat("run", on_on_chat)

Erläutert die Punktnotation, wie eine Funktion definiert wird, was die Doppelpunkte bedeuten, was die verschiedenen Einrückungen bedeuten, was die Klammern bedeuten, und was Parameter sind.

1
2
3
4
5
Python
def on_on_chat():
    agent.teleport_to_player()
player.on_chat("run", on_on_chat)

Lerne den Agenten kennen Teil 2

Lass den Agenten ein paar Schritte nach vorne laufen.
1
2
3
4
player.onChat("run", function () {
    agent.teleportToPlayer()
    agent.move(FORWARD, 5)
})
1
2
3
4
5
6
Python
player.onChat("run", function () {
    agent.teleportToPlayer()
    agent.move(FORWARD, 5)
})
FORWARD ist eine globale Variable mit dem Wert 0.

Fußboden bauen

Als erstes wollen wir den Fußboden bauen.

ersten Block platzieren

Hierzu wollen wir als erstes den Agenten einen Block platzieren lassen. Hierzu benötigt der Agent einen Block im Inventar zum Platzieren. Überlege auch, wo der Agent den Block platzieren soll.
1
2
3
4
5
6
7
8
JavaScript
player.onChat("run", function on_on_chat() {
    agent.teleportToPlayer()
    agent.move(FORWARD, 5)
    agent.setItem(PLANKS_OAK, 64, 1)
    agent.place(BACK)
})
1
2
3
4
5
6
7
8
Python
def on_on_chat():
    agent.teleport_to_player()
    agent.move(FORWARD, 5)
    agent.set_item(PLANKS_OAK, 64, 1)
    agent.place(BACK)
player.on_chat("run", on_on_chat)

Eine Linie platzieren

Wir wollen dies jetzt steigern. Hierzu lassen wir den Agenten 6 Blöcke in einer Linie bauen. Hierzu nutzen wir eine Schleife. Erkläre den Teilnehmenden, dass Schleifen verwendet werden, um wiederholende Tätigkeiten auszuführen.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
JavaScript
player.onChat("run", function () {
    agent.teleportToPlayer()
    agent.move(FORWARD, 5)
    agent.setItem(PLANKS_OAK, 64, 1)
    for (let index = 0; index < 6; index++) {
        agent.move(FORWARD, 1)
        agent.place(BACK)
    }
})
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
Python
def on_on_chat():
    agent.teleport_to_player()
    agent.move(FORWARD, 5)
    agent.set_item(PLANKS_OAK, 64, 1)
    for index in range(6):
        agent.move(FORWARD, 1)
        agent.place(BACK)
player.on_chat("run", on_on_chat)

Eine Doppellinie platzieren

Um einen Fußboden zu bauen, können wir nicht einfach 6 Linien nebeneinander bauen, da jede zweite Linie auf der anderen Seite endet. Stattdessen müssen wir in Doppellinien.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
JavaScript
player.onChat("run", function on_on_chat() {
    agent.teleportToPlayer()
    agent.move(FORWARD, 5)
    agent.setItem(PLANKS_OAK, 64, 1)
    for (let index = 0; index < 6; index++) {
        agent.move(FORWARD, 1)
        agent.place(BACK)
    }
    agent.turn(LEFT_TURN)
    agent.move(FORWARD, 1)
    agent.turn(LEFT_TURN)
    agent.move(FORWARD, 1)
    for (let index2 = 0; index2 < 6; index2++) {
        agent.move(FORWARD, 1)
        agent.place(BACK)
    }
})
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
Python
def on_on_chat():
    agent.teleport_to_player()
    agent.move(FORWARD, 5)
    agent.set_item(PLANKS_OAK, 64, 1)
    for index in range(6):
        agent.move(FORWARD, 1)
        agent.place(BACK)
    agent.turn(LEFT_TURN)
    agent.move(FORWARD, 1)
    agent.turn(LEFT_TURN)
    agent.move(FORWARD, 1)
    for index2 in range(6):
        agent.move(FORWARD, 1)
        agent.place(BACK)
player.on_chat("run", on_on_chat)

Auslagern in eine Funktion

Damit wir nicht das Platzieren einer Linie mehrfach schreiben müssen (wir werden es sicher noch für die Wand benötigen), sollten wir dies in eine separate Funktion auslagern. Erkläre, dass wenn eine Funktion aufgerufen wird, der Code der Funktion ausgeführt wird. Funktionen befinden sich in der Seitenleiste unter Fortgeschritten.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
JavaScript
function linie () {
    for (let index = 0; index < 6; index++) {
        agent.move(FORWARD, 1)
        agent.place(BACK)
    }
}
player.onChat("run", function () {
    agent.teleportToPlayer()
    agent.move(FORWARD, 5)
    agent.setItem(PLANKS_OAK, 64, 1)
    linie()
    agent.turn(LEFT_TURN)
    agent.move(FORWARD, 1)
    agent.turn(LEFT_TURN)
    agent.move(FORWARD, 1)
    linie()
})
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
Python
def linie():
    for index in range(6):
        agent.move(FORWARD, 1)
        agent.place(BACK)
def on_on_chat():
    agent.teleport_to_player()
    agent.move(FORWARD, 5)
    agent.set_item(PLANKS_OAK, 64, 1)
    linie()
    agent.turn(LEFT_TURN)
    agent.move(FORWARD, 1)
    agent.turn(LEFT_TURN)
    agent.move(FORWARD, 1)
    linie()
player.on_chat("run", on_on_chat)

Ein Quadrat platzieren

Jetzt benötigen wir noch 2 weitere Doppellinien. Lass die Kinder dies ausprobieren.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
JavaScript
function linie() {
    for (let index = 0; index < 6; index++) {
        agent.move(FORWARD, 1)
        agent.place(BACK)
    }
}
player.onChat("run", function on_on_chat() {
    agent.teleportToPlayer()
    agent.move(FORWARD, 5)
    agent.setItem(PLANKS_OAK, 64, 1)
    for (let index2 = 0; index2 < 3; index2++) {
        linie()
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        linie()
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
    }
})
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Python
def linie():
    for index in range(6):
        agent.move(FORWARD, 1)
        agent.place(BACK)
def on_on_chat():
    agent.teleport_to_player()
    agent.move(FORWARD, 5)
    agent.set_item(PLANKS_OAK, 64, 1)
    for index2 in range(3):
        linie()
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        linie()
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
player.on_chat("run", on_on_chat)

Eigene Bodenfunktion

Damit unsere Hauptfunktion übersichtlich bleibt, sollten wir das Erstellen des Fußbodens in eine Funktion auslagern.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
JavaScript
function linie() {
    for (let index = 0; index < 6; index++) {
        agent.move(FORWARD, 1)
        agent.place(BACK)
    }
}
function quadrat() {
    for (let index2 = 0; index2 < 3; index2++) {
        linie()
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        linie()
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
    }
}
player.onChat("run", function on_on_chat() {
    agent.teleportToPlayer()
    agent.move(FORWARD, 5)
    agent.setItem(PLANKS_OAK, 64, 1)
    quadrat()
})
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Python
def linie():
    for index in range(6):
        agent.move(FORWARD, 1)
        agent.place(BACK)
def quadrat():
    for index2 in range(3):
        linie()
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        linie()
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
def on_on_chat():
    agent.teleport_to_player()
    agent.move(FORWARD, 5)
    agent.set_item(PLANKS_OAK, 64, 1)
    quadrat()
player.on_chat("run", on_on_chat)

Wand bauen

Damit wir eine Wand bauen können, muss der Agent erst einmal auf die richtige Startposition. Dabei können wir gleichzeitig einen neuen Block für die Wände festlegen.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
JavaScript
function linie () {
    for (let index = 0; index < 6; index++) {
        agent.move(FORWARD, 1)
        agent.place(BACK)
    }
}
player.onChat("run", function () {
    agent.teleportToPlayer()
    agent.move(FORWARD, 5)
    agent.setItem(PLANKS_OAK, 64, 1)
    quadrat()
    agent.move(UP, 1)
    agent.move(RIGHT, 1)
    agent.setItem(WHITE_CONCRETE, 64, 1)
})
function quadrat () {
    for (let index = 0; index < 3; index++) {
        linie()
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        linie()
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
Python
def linie():
    for index in range(6):
        agent.move(FORWARD, 1)
        agent.place(BACK)
def on_on_chat():
    agent.teleport_to_player()
    agent.move(FORWARD, 5)
    agent.set_item(PLANKS_OAK, 64, 1)
    quadrat()
    agent.move(UP, 1)
    agent.move(RIGHT, 1)
    agent.set_item(WHITE_CONCRETE, 64, 1)
player.on_chat("run", on_on_chat)
def quadrat():
    for index3 in range(3):
        linie()
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        linie()
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)

Wände platzieren

Da wir bereits eine Funktion für das Platzieren einer Linie haben, wollen wir diese auch für das Platzieren der Wände nutzen. Wir haben 4 Wände, also müssen wir uns 4 Mal wiederholen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
JavaScript
function linie () {
    for (let index = 0; index < 6; index++) {
        agent.move(FORWARD, 1)
        agent.place(BACK)
    }
}
player.onChat("run", function () {
    agent.teleportToPlayer()
    agent.move(FORWARD, 5)
    agent.setItem(PLANKS_OAK, 64, 1)
    quadrat()
    agent.move(UP, 1)
    agent.move(RIGHT, 1)
    agent.setItem(WHITE_CONCRETE, 64, 1)
    for (let index = 0; index < 4; index++) {
        linie()
        agent.turn(RIGHT_TURN)
    }
})
function quadrat () {
    for (let index = 0; index < 3; index++) {
        linie()
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        linie()
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
Python
def linie():
    for index in range(6):
        agent.move(FORWARD, 1)
        agent.place(BACK)
def on_on_chat():
    agent.teleport_to_player()
    agent.move(FORWARD, 5)
    agent.set_item(PLANKS_OAK, 64, 1)
    quadrat()
    agent.move(UP, 1)
    agent.move(RIGHT, 1)
    agent.set_item(WHITE_CONCRETE, 64, 1)
    for index2 in range(4):
        linie()
        agent.turn(RIGHT_TURN)
player.on_chat("run", on_on_chat)
def quadrat():
    for index3 in range(3):
        linie()
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        linie()
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)

Linienlänge variieren

Wir merken, dass die Wände zu lang sind für den Fußboden. Wir benötigen eine kürzere Linie. Hierzu passen wir die Funktion an (rechtsklick auf den Block und dann Funktion bearbeiten) und fügen eine Zahl hinzu. Jetzt müssen wir die Variable in der Funktion in der Schleife verwenden und bei allen Aufrufen die Länge angeben.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
JavaScript
function linie(num: number) {
    for (let index = 0; index < num; index++) {
        agent.move(FORWARD, 1)
        agent.place(BACK)
    }
}
player.onChat("run", function on_on_chat() {
    agent.teleportToPlayer()
    agent.move(FORWARD, 5)
    agent.setItem(PLANKS_OAK, 64, 1)
    quadrat()
    agent.move(UP, 1)
    agent.move(RIGHT, 1)
    agent.setItem(WHITE_CONCRETE, 64, 1)
    for (let index2 = 0; index2 < 4; index2++) {
        linie(5)
        agent.turn(RIGHT_TURN)
    }
})
function quadrat() {
    for (let index3 = 0; index3 < 3; index3++) {
        linie(6)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        linie(6)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
Python
def linie(num: number):
    for index in range(num):
        agent.move(FORWARD, 1)
        agent.place(BACK)
def on_on_chat():
    agent.teleport_to_player()
    agent.move(FORWARD, 5)
    agent.set_item(PLANKS_OAK, 64, 1)
    quadrat()
    agent.move(UP, 1)
    agent.move(RIGHT, 1)
    agent.set_item(WHITE_CONCRETE, 64, 1)
    for index2 in range(4):
        linie(5)
        agent.turn(RIGHT_TURN)
player.on_chat("run", on_on_chat)
def quadrat():
    for index3 in range(3):
        linie(6)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        linie(6)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)

Platzieren der letzten Wand

Die letzte Wand kann nicht vollständig platziert werden, da ein Block im Weg ist. Daher sollten wir die letzte Wand außerhalb der Schleife platzieren und den letzten Block manuell setzen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
JavaScript
function linie (num: number) {
    for (let index = 0; index < num; index++) {
        agent.move(FORWARD, 1)
        agent.place(BACK)
    }
}
player.onChat("run", function () {
    agent.teleportToPlayer()
    agent.move(FORWARD, 5)
    agent.setItem(PLANKS_OAK, 64, 1)
    quadrat()
    agent.move(UP, 1)
    agent.move(RIGHT, 1)
    agent.setItem(WHITE_CONCRETE, 64, 1)
    for (let index = 0; index < 3; index++) {
        linie(5)
        agent.turn(RIGHT_TURN)
    }
    linie(4)
    agent.move(UP, 1)
    agent.place(DOWN)
    agent.move(FORWARD, 1)
    agent.turn(RIGHT_TURN)
})
function quadrat () {
    for (let index = 0; index < 3; index++) {
        linie(6)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        linie(6)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
Python
def linie(num: number):
    for index in range(num):
        agent.move(FORWARD, 1)
        agent.place(BACK)
def on_on_chat():
    agent.teleport_to_player()
    agent.move(FORWARD, 5)
    agent.set_item(PLANKS_OAK, 64, 1)
    quadrat()
    agent.move(UP, 1)
    agent.move(RIGHT, 1)
    agent.set_item(WHITE_CONCRETE, 64, 1)
    for index2 in range(3):
        linie(5)
        agent.turn(RIGHT_TURN)
    linie(4)
    agent.move(UP, 1)
    agent.place(DOWN)
    agent.move(FORWARD, 1)
    agent.turn(RIGHT_TURN)
player.on_chat("run", on_on_chat)
def quadrat():
    for index3 in range(3):
        linie(6)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        linie(6)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)

In die Höhe bauen

Damit wir jetzt die Wände nach oben bauen, müssen wir das wiederholen.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
JavaScript
function linie(num: number) {
    for (let index = 0; index < num; index++) {
        agent.move(FORWARD, 1)
        agent.place(BACK)
    }
}
player.onChat("run", function on_on_chat() {
    agent.teleportToPlayer()
    agent.move(FORWARD, 5)
    agent.setItem(PLANKS_OAK, 64, 1)
    quadrat()
    agent.move(UP, 1)
    agent.move(RIGHT, 1)
    agent.setItem(WHITE_CONCRETE, 64, 1)
    for (let index2 = 0; index2 < 4; index2++) {
        for (let index3 = 0; index3 < 3; index3++) {
            linie(5)
            agent.turn(RIGHT_TURN)
        }
        linie(4)
        agent.move(UP, 1)
        agent.place(DOWN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
    }
})
function quadrat() {
    for (let index4 = 0; index4 < 3; index4++) {
        linie(6)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        linie(6)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
Python
def linie(num: number):
    for index in range(num):
        agent.move(FORWARD, 1)
        agent.place(BACK)
def on_on_chat():
    agent.teleport_to_player()
    agent.move(FORWARD, 5)
    agent.set_item(PLANKS_OAK, 64, 1)
    quadrat()
    agent.move(UP, 1)
    agent.move(RIGHT, 1)
    agent.set_item(WHITE_CONCRETE, 64, 1)
    for index2 in range(4):
        for index3 in range(3):
            linie(5)
            agent.turn(RIGHT_TURN)
        linie(4)
        agent.move(UP, 1)
        agent.place(DOWN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
player.on_chat("run", on_on_chat)
def quadrat():
    for index4 in range(3):
        linie(6)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        linie(6)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)

Dach bauen

Das Dach ist nichts anderes als ein Fußboden. Wir müssen nur schauen, dass wir an der richtigen Position sind und den richtigen Block haben.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
JavaScript
function linie (num: number) {
    for (let index = 0; index < num; index++) {
        agent.move(FORWARD, 1)
        agent.place(BACK)
    }
}
player.onChat("run", function () {
    agent.teleportToPlayer()
    agent.move(FORWARD, 5)
    agent.setItem(PLANKS_OAK, 64, 1)
    quadrat()
    agent.move(UP, 1)
    agent.move(RIGHT, 1)
    agent.setItem(WHITE_CONCRETE, 64, 1)
    for (let index = 0; index < 4; index++) {
        for (let index = 0; index < 3; index++) {
            linie(5)
            agent.turn(RIGHT_TURN)
        }
        linie(4)
        agent.move(UP, 1)
        agent.place(DOWN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
    }
    agent.move(RIGHT, 5)
    agent.setItem(BRICKS, 1, 1)
    quadrat()
})
function quadrat () {
    for (let index = 0; index < 3; index++) {
        linie(6)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        linie(6)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
Python
def linie(num: number):
    for index in range(num):
        agent.move(FORWARD, 1)
        agent.place(BACK)
def on_on_chat():
    agent.teleport_to_player()
    agent.move(FORWARD, 5)
    agent.set_item(PLANKS_OAK, 64, 1)
    quadrat()
    agent.move(UP, 1)
    agent.move(RIGHT, 1)
    agent.set_item(WHITE_CONCRETE, 64, 1)
    for index2 in range(4):
        for index3 in range(3):
            linie(5)
            agent.turn(RIGHT_TURN)
        linie(4)
        agent.move(UP, 1)
        agent.place(DOWN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
    agent.move(RIGHT, 5)
    agent.set_item(BRICKS, 1, 1)
    quadrat()
player.on_chat("run", on_on_chat)
def quadrat():
    for index4 in range(3):
        linie(6)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD, 1)
        linie(6)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)
        agent.turn(RIGHT_TURN)
        agent.move(FORWARD, 1)

Erweiterungsmöglichkeiten

Der Code kann jetzt beliebig erweitert und verändert werden. Hier einige Ideen:

  • Senke das Haus um eins ab. Hierzu muss eine Grube für den Fußboden erstellt werden. (evtl. braucht ihr eine Funktion grabeMitLinie)
  • Entferne Blöcke für Tür und Fenster
  • Baue mehrere Stockwerke
  • Entferne Hindernisse vor dem Bau