Anhang B
Materialien

In diesem Kapitel findest du eine Liste aller Materialien in Minecraft und der dazu gehörigen Bezeichner, die du benötigst, um sie in einem Plugin verwenden zu können. Die Liste der Materialien umfasst sowohl alle Blöcke als auch alle Gegenstände. Unter Blöcken versteht man dabei im Gegensatz zu Gegenständen nur solche Dinge, die man auch in der Welt platzieren kann. Ein Schwert oder ein Schneeball gehören also zum Beispiel nicht dazu. Die meisten Materialien existieren sowohl als Gegenstand als auch als Block, wie zum Beispiel Treppen oder Holzblöcke. Bei einigen wenigen Materialien gibt es unterschiedliche Einträge für Gegenstände und Blöcke, so zum Beispiel bei allen Gegenständen, die in der Welt aus zwei Blöcken bestehen, im Inventar aber nur ein Gegenstand sind, wie zum Beispiel Türen und Betten.

Bezeichner

Material

Ackerboden

FARMLAND

Aktivierungsschiene

ACTIVATOR_RAIL

Amboss

ANVIL

Angel

FISHING_ROD

Antriebsschiene

POWERED_RAIL

Apfel

APPLE

Apfel (Gold)

GOLDEN_APPLE

Axt (Diamant)

DIAMOND_AXE

Axt (Eisen)

IRON_AXE

Axt (Gold)

GOLD_AXE

Axt (Holz)

WOOD_AXE

Axt (Stein)

STONE_AXE

Banner (stehend, blau)

BLUE_BANNER

Banner (Wand, blau)

BLUE_WALL_BANNER

Barriere

BARRIER

Befehlsblock

COMMAND

Befehlsblock (ketten)

COMMAND_CHAIN

Befehlsblock (wiederholen)

COMMAND_REPEATING

Befehlsblocklore

COMMAND_MINECART

Beinschutz (Diamant)

DIAMOND_LEGGINGS

Beinschutz (Eisen)

IRON_LEGGINGS

Beinschutz (Gold)

GOLD_LEGGINGS

Beinschutz (Ketten)

CHAINMAIL_LEGGINGS

Beinschutz (Leder)

LEATHER_LEGGINGS

Bett (rot)

RED_BED

Blätter (Eiche)

OAK_LEAVES

Blume (Löwenzahn)

DANDELION

Blumentopf

FLOWER_POT

Blumentopf (Gegenstand)

FLOWER_POT_ITEM

Bogen

BOW

Boot (Eiche)

OAK_BOAT

Boot (Akazienholz)

ACACIA_BOAT

Boot (Birkenholz)

BIRCH_BOAT

Boot (Fichtenholz)

SPRUCE_BOAT

Boot (Schwarzeichenholz)

DARK_OAK_BOAT

Boot (Tropenholz)

JUNGLE_BOAT

Braustand

BREWING_STAND

Braustand (Gegenstand)

BREWING_STAND_ITEM

Brot

BREAD

Bruchstein

COBBLESTONE

Bruchstein (bemoost)

MOSSY_COBBLESTONE

Brustpanzer (Diamant)

DIAMOND_CHESTPLATE

Brustpanzer (Eisen)

IRON_CHESTPLATE

Brustpanzer (Gold)

GOLD_CHESTPLATE

Brustpanzer (Ketten)

CHAINMAIL_CHESTPLATE

Brustpanzer (Leder)

LEATHER_CHESTPLATE

Buch

BOOK

Buch (geschrieben)

WRITTEN_BOOK

Buch (verzaubert)

ENCHANTED_BOOK

Buch und Feder

BOOK_AND_QUILL

Bücherregal

BOOKSHELF

Bruchsteinmauer

COBBLE_WALL

Busch

DEAD_BUSH

Chorusblüte

CHORUS_FLOWER

Chorusfrucht

CHORUS_FRUIT

Chorusfrucht (geplatzt)

CHORUS_FRUIT_POPPED

Choruspflanze

CHORUS_PLANT

Diamant

DIAMOND

Diamantblock

DIAMOND_BLOCK

Diamanterz

DIAMOND_ORE

Drachenatem

DRAGONS_BREATH

Drachenei

DRAGON_EGG

Druckplatte (Holz)

WOOD_PLATE

Druckplatte (Stein)

STONE_PLATE

Ei

EGG

Eimer

BUCKET

Eis

ICE

Eis (brüchig)

FROSTED_ICE

Eisenbarren

IRON_INGOT

Eisenblock

IRON_BLOCK

Eisenerz

IRON_ORE

Eisentür

IRON_DOOR

Eisentür (Gegenstand)

IRON_DOOR_BLOCK

Elytren

ELYTRA

Enderauge

EYE_OF_ENDER

Enderperle

ENDER_PEARL

Enderportal

ENDER_PORTAL

Enderportalrahmen

ENDER_PORTAL_FRAME

Enderstein

ENDER_STONE

Endertruhe

ENDER_CHEST

Endkristall

END_CRYSTAL

Endstab

END_ROD

Endstein

END_BRICKS

Endtransitportal

END_GATEWAY

Erde

DIRT

Erfahrungstrank

EXP_BOTTLE

Fackel

TORCH

Faden

STRING

Falltür

TRAP_DOOR

Falltür (Eisen)

IRON_TRAPDOOR

Feder

FEATHER

Feuer

FIRE

Feuerkugel

FIREBALL

Feuerstein

FLINT

Feuerwerk

FIREWORK

Feuerwerksstern

FIREWORK_CHARGE

Feuerzeug

FLINT_AND_STEEL

Fisch (roh)

RAW_FISH

Fleisch (verrottet)

ROTTEN_FLESH

Gebratener Fisch

COOKED_FISH

Gebratener Hase

COOKED_RABBIT

Gebratenes Hammelfleisch

COOKED_MUTTON

Gebratenes Hühnchen

COOKED_CHICKEN

Gebratenes Schweinefleisch

GRILLED_PORK

Gemälde

PAINTING

Ghastträne

GHAST_TEAR

Glas

GLASS

Glas (dünn)

THIN_GLASS

Glas (gefärbt)

STAINED_GLASS

Glasflasche

GLASS_BOTTLE

Glasscheibe (gefärbt)

STAINED_GLASS_PANE

Glowstone

GLOWSTONE

Glowstonestaub

GLOWSTONE_DUST

Goldbarren

GOLD_INGOT

Goldblock

GOLD_BLOCK

Golderz

GOLD_ORE

Goldnugget

GOLD_NUGGET

Gras

GRASS

Gras (lang)

LONG_GRASS

Grundgestein

BEDROCK

Güterlore

STORAGE_MINECART

Hacke (Diamant)

DIAMOND_HOE

Hacke (Eisen)

IRON_HOE

Hacke (Gold)

GOLD_HOE

Hacke (Holz)

WOOD_HOE

Hacke (Stein)

STONE_HOE

Haken

TRIPWIRE_HOOK

Hammelfleisch

MUTTON

Hebel

LEVER

Helm (Diamant)

DIAMOND_HELMET

Helm (Eisen)

IRON_HELMET

Helm (Gold)

GOLD_HELMET

Helm (Ketten)

CHAINMAIL_HELMET

Helm (Leder)

LEATHER_HELMET

Hohes Gras

DOUBLE_PLANT

Holz (Eiche)

OAK_WOOD

Holzknopf

WOOD_BUTTON

Hühnchen (roh)

RAW_CHICKEN

Kakao

COCOA

Kaktus

CACTUS

Kaninchen

RABBIT

Kaninchenfell

RABBIT_HIDE

Kaninchenfleisch

RABBIT_FOOT

Kaninchenragout

RABBIT_STEW

Karotte

CARROT

Karotte (Gegenstand)

CARROT_ITEM

Karotte (Gold)

GOLDEN_CARROT

Karottenrute

CARROT_STICK

Karte

MAP

Karte (leer)

EMPTY_MAP

Kartoffel

POTATO

Kartoffel (Gegenstand)

POTATO_ITEM

Kartoffel (giftig)

POISONOUS_POTATO

Keks

COOKIE

Kessel

CAULDRON

Kessel (Gegenstand)

CAULDRON_ITEM

Kies

GRAVEL

Knochen

BONE

Kohle

COAL

Kohleblock

COAL_BLOCK

Kolben (klebrige Platte)

PISTON_STICKY_BASE

Kolben (Platte)

PISTON_BASE

Kompass

COMPASS

Konstruktionsblock

STRUCTURE_BLOCK

Kuchen

CAKE

Kuchenblock

CAKE_BLOCK

Kürbis

PUMPKIN

Kürbiskerne

PUMPKIN_SEEDS

Kürbiskuchen

PUMPKIN_PIE

Kürbislaterne

JACK_O_LANTERN

Kürbisstamm

PUMPKIN_STEM

Lapislazuliblock

LAPIS_BLOCK

Lapislazulierz

LAPIS_ORE

Lava

LAVA

Lava (stehend)

STATIONARY_LAVA

Lavaeimer

LAVA_BUCKET

Leder

LEATHER

Leine

LEASH

Leiter

LADDER

Leuchtfeuer

BEACON

Lohenrute

BLAZE_ROD

Lohenstaub

BLAZE_POWDER

Lore

MINECART

Lore (angetrieben)

POWERED_MINECART

Luft

AIR

Magmacreme

MAGMA_CREAM

Melone

MELON

Melone (Block)

MELON_BLOCK

Melone (glitzernd)

SPECKLED_MELON

Melonenkerne

MELON_SEEDS

Melonenstrunk

MELON_STEM

Milcheimer

MILK_BUCKET

Mob-Spawner

MOB_SPAWNER

Monsterei

MONSTER_EGG

Myzel

MYCEL

Nachtlichtsensor

DAYLIGHT_DETECTOR_INVERTED

Namensschild

NAME_TAG

Netherquarz

QUARTZ_ORE

Netherrack

NETHERRACK

Netherstern

NETHER_STAR

Netherwarze

NETHER_STALK

Netherwarze

NETHER_WARTS

Netherziegel

NETHER_BRICK

Netherziegel (Gegenstand)

NETHER_BRICK_ITEM

Notenblock

NOTE_BLOCK

Obsidian

OBSIDIAN

Ofen

FURNACE

Ofen (brennend)

BURNING_FURNACE

Ofenkartoffel

BAKED_POTATO

Packeis

PACKED_ICE

Papier

PAPER

Pfeil

ARROW

Pfeil (getränkt)

TIPPED_ARROW

Pferderüstung (Diamant)

DIAMOND_BARDING

Pferderüstung (Eisen)

IRON_BARDING

Pferderüstung (Gold)

GOLD_BARDING

Pilz (braun)

BROWN_MUSHROOM

Pilz (groß)

HUGE_MUSHROOM_1

Pilz (groß)

HUGE_MUSHROOM_2

Pilz (rot)

RED_MUSHROOM

Pilzsuppe

MUSHROOM_SOUP

Plattenspieler

JUKEBOX

Portal

PORTAL

Prismarin

PRISMARINE

Prismarinkristall

PRISMARINE_CRYSTALS

Prismarinscherbe

PRISMARINE_SHARD

Purpurblock

PURPUR_BLOCK

Purpursäule

PURPUR_PILLAR

Quarz

QUARTZ

Quarzblock

QUARTZ_BLOCK

Rahmen

ITEM_FRAME

Ranken

VINE

Redstone

REDSTONE

Redstone-Fackel (an)

REDSTONE_TORCH_ON

Redstone-Fackel (aus)

REDSTONE_TORCH_OFF

Redstone-Kabel

REDSTONE_WIRE

Redstone-Komparator (Block, an)

REDSTONE_COMPARATOR_ON

Redstone-Komparator (Block, aus)

REDSTONE_COMPARATOR_OFF

Redstone-Komparator (Gegenstand)

REDSTONE_COMPARATOR

Redstone-Lampe (an)

REDSTONE_LAMP_ON

Redstone-Lampe (aus)

REDSTONE_LAMP_OFF

Redstone-Verstärker (Block, an)

DIODE_BLOCK_ON

Redstone-Verstärker (Block, aus)

DIODE_BLOCK_OFF

Redstone-Verstärker (Gegenstand)

DIODE

Redstoneblock

REDSTONE_BLOCK

Redstoneerz

REDSTONE_ORE

Redstoneerz (leuchtend)

GLOWING_REDSTONE_ORE

Redstonetruhe

TRAPPED_CHEST

Rindfleisch (roh)

RAW_BEEF

Rose (rot)

RED_ROSE

Rote Bete

BEETROOT

Rote Bete Pflanze

BEETROOT_BLOCK

Rote Bete Samen

BEETROOT_SEEDS

Rote Bete Suppe

BEETROOT_SOUP

Rüstungsständer

ARMOR_STAND

Sand

SAND

Sandstein

SANDSTONE

Sandstein (rot)

RED_SANDSTONE

Sattel

SADDLE

Schädel

SKULL

Schädel (Gegenstand)

SKULL_ITEM

Schallplatte

RECORD_10

Schallplatte

RECORD_11

Schallplatte

RECORD_12

Schallplatte

RECORD_3

Schallplatte

RECORD_4

Schallplatte

RECORD_5

Schallplatte

RECORD_6

Schallplatte

RECORD_7

Schallplatte

RECORD_8

Schallplatte

RECORD_9

Schallplatte (Gold)

GOLD_RECORD

Schallplatte (Grün)

GREEN_RECORD

Schaufel (Diamant)

DIAMOND_SPADE

Schaufel (Eisen)

IRON_SPADE

Schaufel (Gold)

GOLD_SPADE

Schaufel (Holz)

WOOD_SPADE

Schaufel (Stein)

STONE_SPADE

Schere

SHEARS

Schiene

RAILS

Schild

SIGN

Schild (Kampf)

SHIELD

Schild (Pfosten)

SIGN_POST

Schild (Wand)

WALL_SIGN

Schleimball

SLIME_BALL

Schleimblock

SLIME_BLOCK

Schnee

SNOW

Schneeball

SNOWBALL

Schneeblock

SNOW_BLOCK

Schuhe (Eisen)

IRON_BOOTS

Schüssel

BOWL

Schwamm

SPONGE

Schwarzpulver

SULPHUR

Schweinefleisch

PORK

Schwert (Diamant)

DIAMOND_SWORD

Schwert (Eisen)

IRON_SWORD

Schwert (Gold)

GOLD_SWORD

Schwert (Holz)

WOOD_SWORD

Schwert (Stein)

STONE_SWORD

Seelaterne

SEA_LANTERN

Seelensand

SOUL_SAND

Seerose

WATER_LILY

Sensorschiene

DETECTOR_RAIL

Setzling

SAPLING

Smaragd

EMERALD

Smaragdblock

EMERALD_BLOCK

Smaragderz

EMERALD_ORE

Spektralpfeil

SPECTRAL_ARROW

Spender

DROPPER

Spinnenauge

SPIDER_EYE

Spinnenaugen (fermentiert)

FERMENTED_SPIDER_EYE

Spinnennetz

WEB

Spitzhacke (Diamant)

DIAMOND_PICKAXE

Spitzhacke (Eisen)

IRON_PICKAXE

Spitzhacke (Gold)

GOLD_PICKAXE

Spitzhacke (Holz)

WOOD_PICKAXE

Spitzhacke (Stein)

STONE_PICKAXE

Steak

COOKED_BEEF

Stein

STONE

Steinknopf

STONE_BUTTON

Steinkohle

COAL_ORE

Steinziegel (gemeißelt)

SMOOTH_BRICK

Stiefel (Diamant)

DIAMOND_BOOTS

Stiefel (Gold)

GOLD_BOOTS

Stiefel (Ketten)

CHAINMAIL_BOOTS

Stiefel (Leder)

LEATHER_BOOTS

Stock

STICK

Stolperdraht

TRIPWIRE

Strohballen

HAY_BLOCK

Stufe

STEP

Stufe (doppelt)

DOUBLE_STEP

Stufe (Holz, doppelt)

WOOD_DOUBLE_STEP

Stufe (Holz)

WOOD_STEP

Stufe (Purpur, doppelt)

PURPUR_DOUBLE_SLAB

Stufe (Purpur)

PURPUR_SLAB

Stufe (Stein, doppelt)

DOUBLE_STONE_SLAB2

Stufe (Stein)

STONE_SLAB2

Tageslichtsensor

DAYLIGHT_DETECTOR

Teppich

CARPET

Tintenbeutel

INK_SACK

TNT

TNT

TNT-Lore

EXPLOSIVE_MINECART

Ton

CLAY

Ton (gebrannt)

HARD_CLAY

Ton (gefärbt)

STAINED_CLAY

Tonklumpen

CLAY_BALL

Trampelpfad

GRASS_PATH

Trank

POTION

Trank (werfbar)

SPLASH_POTION

Treppe (Akazienholz)

ACACIA_STAIRS

Treppe (Birkenholz)

BIRCH_WOOD_STAIRS

Treppe (Bruchstein)

COBBLESTONE_STAIRS

Treppe (Fichtenholz)

SPRUCE_WOOD_STAIRS

Treppe (Holz)

WOOD_STAIRS

Treppe (Netherziegel)

NETHER_BRICK_STAIRS

Treppe (Purpur)

PURPUR_STAIRS

Treppe (Quarz)

QUARTZ_STAIRS

Treppe (Sandstein, rot)

RED_SANDSTONE_STAIRS

Treppe (Sandstein)

SANDSTONE_STAIRS

Treppe (Schwarzeichenholz)

DARK_OAK_STAIRS

Treppe (Steinziegel, gemeißelt)

SMOOTH_STAIRS

Treppe (Tropenholz)

JUNGLE_WOOD_STAIRS

Treppe (Ziegelsteine)

BRICK_STAIRS

Trichter

HOPPER

Trichterlore

HOPPER_MINECART

Truhe

CHEST

Tür (Akazienholz, Gegenstand)

ACACIA_DOOR_ITEM

Tür (Akazienholz)

ACACIA_DOOR

Tür (Birkenholz, Gegenstand)

BIRCH_DOOR_ITEM

Tür (Birkenholz)

BIRCH_DOOR

Tür (Fichtenholz)

SPRUCE_DOOR

Tür (Gegenstand, Fichtenholz)

SPRUCE_DOOR_ITEM

Tür (Holz)

WOOD_DOOR

Tür (Holz)

WOODEN_DOOR

Tür (Schwarzeichenholz, Gegenstand)

DARK_OAK_DOOR_ITEM

Tür (Schwarzeichenholz)

DARK_OAK_DOOR

Tür (Tropenholz, Gegenstand)

JUNGLE_DOOR_ITEM

Tür (Tropenholz)

JUNGLE_DOOR

Uhr

WATCH

Verweiltrank

LINGERING_POTION

Verzauberungstisch

ENCHANTMENT_TABLE

Wägeplatte (Eisen)

IRON_PLATE

Wägeplatte (Gold)

GOLD_PLATE

Wasser

WATER

Wasser (stehend)

STATIONARY_WATER

Wassereimer

WATER_BUCKET

Weizen

CROPS

Weizen

WHEAT

Weizenkörner

SEEDS

Werfer

DISPENSER

Werkbank

WORKBENCH

Wolle

WOOL

Zaun

FENCE

Zaun (Akazienholz)

ACACIA_FENCE

Zaun (Birkenholz)

BIRCH_FENCE

Zaun (Eisen)

IRON_FENCE

Zaun (Fichtenholz)

SPRUCE_FENCE

Zaun (Netherziegel)

NETHER_FENCE

Zaun (Schwarzeichenholz)

DARK_OAK_FENCE

Zaun (Tropenholz)

JUNGLE_FENCE

Zauntor

FENCE_GATE

Zauntor (Akazienholz)

ACACIA_FENCE_GATE

Zauntor (Birkenholz)

BIRCH_FENCE_GATE

Zauntor (Fichtenholz)

SPRUCE_FENCE_GATE

Zauntor (Schwarzeichenholz)

DARK_OAK_FENCE_GATE

Zauntor (Tropenholz)

JUNGLE_FENCE_GATE

Ziegel

CLAY_BRICK

Ziegelsteine

BRICKS

Zucker

SUGAR

Zuckerrohr (Block)

SUGAR_CANE_BLOCK

Zuckerrohr (Gegenstand)

SUGAR_CANE

Anhang A
Befehlsreferenz

In diesem Kapitel findest du eine Übersicht über alle Befehle, die dir im Verlaufe dieses Buches begegnet sind. Es kann dir als Nachschlagewerk dienen, selbst wenn du das letzte Kapitel des Buches schon lange abgeschlossen hast. Die Befehle sind nach Themen und innerhalb der Themen alphabetisch sortiert.

A.1  Schleifen

Befehl

Parameter

Rückgabewert

Beschreibung

for element in liste:
    #Anweisung

liste: Liste eines beliebigen Typs

 

Wiederholt die Befehle im Schleifenrumpf für jedes Element der Liste.

while bedingung:
    #Anweisung

bedingung: Wahrheitswert

 

Wiederholt die Befehle im Schleifenrumpf, solange die Laufbedingung erfüllt ist.

A.2  Verzweigungen

Befehl

Parameter

Rückgabewert

Beschreibung

if bedingung1:
    #Anweisungen
elif bedingung2:
    #Anweisungen
else:
    #Anweisungen

bedingung1, bedingung2: Wahrheitswerte

 

Führt den if-Teil aus, falls bedingung1 True ist. Falls bedingung1 False ist und bedingung2 True, dann wird der elif-Teil ausgeführt. Sind bedingung1 und bedingung2 False, dann wird der else-Teil ausgeführt.

A.3  Variablen

Befehl

Parameter

Rückgabewert

Beschreibung

a[i]

a: Liste, i: Ganzzahl

i-tes Element der Liste a

Gibt das i-te Element der Liste a zurück.

global x

x: Variable

 

Macht eine globale Variable x innerhalb einer Funktion lokal verfügbar.

isinstance(var, klasse)

var: Variable, klasse: Klasse / Typ

Wahrheitswert

Gibt True zurück, falls die Variable ein Objekt der angegebenen Klasse ist, ansonsten False.

len(a)

a: Liste

Ganzzahl

Gibt die Länge der Liste a zurück.

string.lower()

string: String

String

Wandelt den String in Kleinbuchstaben um.

string.upper()

string: String

String

Wandelt den String in Großbuchstaben um.

x = []

   

Erzeugt eine neue, leere Liste.

x = [a, b, c]

a, b, c: beliebige Werte oder Objekte

 

Erzeugt eine neue Liste mit dem Namen x und den Elementen a, b und c.

x = y

y: beliebiger Wert oder beliebiges Objekt

 

Erzeugt eine neue Variable mit dem Namen x und dem Wert y.

x.append(a)

a: beliebiger Wert oder beliebiges Objekt

 

Fügt das Element a der Liste x hinzu.

x.remove(i)

i: Ganzzahl

 

Löscht das Elemente an der i-ten Stelle der Liste.

A.4  Klassen und Objekte

Befehl

Parameter

Rückgabewert

Beschreibung

a = A()

   

Erzeugen eines neuen Objektes der Klasse A.

class A(B):
    #Inhalt

   

Grundgerüst einer Klasse mit dem Namen A, die von einer Klasse B erbt.

class A:
    #Inhalt

   

Grundgerüst einer Klasse mit dem Namen A.

def __init__(self):
    #Anweisungen

   

Grundgerüst einer init-Funktion.

import x

   

Importiert eine Datei x.

path.append(pfad)

pfad: String

 

Fügt einen Pfad zum Arbeitsverzeichnis hinzu.

A.5  Funktionen

Befehl

Parameter

Rückgabewert

Beschreibung

def onCommand(self, sender, command, label, args):
    #Anweisungen

self: Plugin-Objekt, sender: Absender des Chat-Befehls, command: ausgeführter Befehl, label: eingegebener Befehlsname, args: String-Array der Argumente

 

Diese Funktion wird aufgerufen, wenn ein Chat-Befehl eingegeben wird.

def onEnable(self):
    #Anweisungen

self: Plugin-Objekt

 

Diese Funktion wird beim Starten eines Plugins aufgerufen.

def x():
    return y

 

y

Mit dem return-Befehl lässt sich festlegen, welchen Wert eine Funktion zurückgeben soll.

A.6  Logische Operatoren und Vergleiche

Befehl

Parameter

Rückgabewert

Beschreibung

a & b

a, b: Wahrheitswert

Wahrheitswert

Liefert True zurück, wenn a und b True sind, ansonsten False.

a ˆ b

a, b: Wahrheitswert

Wahrheitswert

Liefert True zurück wenn entweder a oder b True ist, ansonsten False.

a | b

a, b: Wahrheitswert

Wahrheitswert

Liefert True zurück, wenn entweder a oder b oder a und b True sind, ansonsten False.

not a

a: Wahrheitswert

Wahrheitswert

Liefert True zurück, wenn a False ist, ansonsten True.

x != y

x, y: beliebige Variablen

Wahrheitswert

Liefert True zurück, wenn x ungleich y ist, ansonsten False.

x < y

x, y: beliebige Variablen

Wahrheitswert

Liefert True zurück, wenn x kleiner als y ist, ansonsten False.

x <= y

x, y: beliebige Variablen

Wahrheitswert

Liefert True zurück, wenn x kleiner oder gleich y ist, ansonsten False.

x <> y

x, y: beliebige Variablen

Wahrheitswert

Liefert True zurück, wenn x ungleich y ist, ansonsten False.

x == y

x, y: beliebige Variablen

Wahrheitswert

Liefert True zurück, wenn x gleich y ist, ansonsten False.

x > y

x, y: beliebige Variablen

Wahrheitswert

Liefert True zurück, wenn x größer als y ist, ansonsten False.

y >= y

x, y: beliebige Variablen

Wahrheitswert

Liefert True zurück, wenn x größer oder gleich y ist, ansonsten False.

A.7  Spieler

Befehl

Parameter

Rückgabewert

Beschreibung

spieler.getLineOfSight(ignorieren, maxEntfernung)

spieler: Spieler, ignorieren: Liste von Materialien, maxEntfernung: Zahl

Liste von Blöcken

Funktioniert wie getTargetBlock, allerdings werden alle Blöcke auf der Sichtlinie als Liste zurückgegeben statt nur ein Block.

spieler.getLocation()

spieler: Player

Location

Gibt die Position des Spielers zurück.

spieler.getTargetBlock(ignorieren, maxEntfernung)

spieler: Spieler, ignorieren: Liste von Materialien, maxEntfernung: Zahl

Block

Gibt den Block zurück, auf den der Spieler gerade schaut, falls dieser nicht weiter als maxEntfernung entfernt ist. Dabei werden alle Blöcke, deren Material in der Liste ignorieren vorkommt, wie Luft behandelt.

A.8  Positionen

Befehl

Parameter

Rückgabewert

Beschreibung

position.getX()

position: Location

Zahl

Gibt die X-Koordinate der Position zurück.

position.getY()

position: Location

Zahl

Gibt die Y-Koordinate der Position zurück.

position.getYaw()

position: Location

Zahl

Gibt die Rotation eines Spielers, Gegenstandes oder Monsters zurück.

position.getZ()

position: Location

Zahl

Gibt die Z-Koordinate der Position zurück.

position.setX(x)

position: Location, x: Zahl

 

Setzt die X-Koordinate der Position auf x.

position.setY(y)

position: Location, y: Zahl

 

Setzt die Y-Koordinate der Position auf y.

position.setZ(z)

position: Location, z: Zahl

 

Setzt die Z-Koordinate der Position auf z.

A.9  Welt

Befehl

Parameter

Rückgabewert

Beschreibung

spieler.getWorld()

spieler: Player

Welt

Gibt die aktuelle Welt als Variable zurück.

welt.getBlockAt(position)

welt: World, position: Location

Block

Gibt den Block an der übergebenen Position zurück.

A.10  Blöcke

A.10.1  Allgemein

Befehl

Parameter

Rückgabewert

Beschreibung

block.getState()

block: Block

BlockState

Gibt den Gegenstand zurück, der aktuell an dieser Stelle steht (zum Beispiel ein Schild).

block.getType()

block: Block

Material

Gibt den Typ eines Blocks zurück.

block.setData(data)

block: Block, data: Zahl

 

Setzt die Meta-Daten des Blocks auf den Wert von data.

block.setType(material)

block: Block, material: Material

 

Kurzschreibweise für block.setType(material, True).

block.setType(material, physik)

block: Block, material: Material, physik: Wahrheitswert

 

Legt den Typ des Blocks fest. Der Wahrheitswert entscheidet, ob die Gesetze der Physik kurz ignoriert werden sollen, zum Beispiel, um den oberen Teil einer Tür zu bauen.

block.setFacing(blockface)

block: Block, blockface: BlockFace.WEST, BlockFace.EAST, BlockFace.SOUTH, BlockFace.NORTH

 

Legt fest, in welche Richtung der Block ausgerichtet wird (zum Beispiel bei Betten oder Fackeln).

block.setHalf(haelfte)

block: Block, haelfte: Bisected.Half.BOTTOM, Bisected.Hald.TOP

 

Legt fest, ob es sich bei dem Block um die obere oder untere Hälfte einer Tür handelt.

A.10.2  Schilder

Befehl

Parameter

Rückgabewert

Beschreibung

schild.setLine(i, string)

schild: Schild-Block, i: Ganzzahl, string: String

 

Schreibt den übergebenen String in die i-te Zeile des Schildes.

schild.update()

schild: Schild

 

Wendet Änderungen, zum Beispiel im Text, auf ein Schild an.

A.11  Logging

Befehl

Parameter

Rückgabewert

Beschreibung

self.getLogger().info(string)

self: Plugin-Objekt, string: String

 

Schreibt einen Log-Eintrag mit dem angegebenen String als Text.

A.12  Gegenstände

Befehl

Parameter

Rückgabewert

Beschreibung

gegenstand.addUnsafeEnchantment(verzauberung, stufe)

verzauberung: Enchantment, stufe: Ganzzahl

 

Verzaubert den Gegenstand mit der angegebenen Verzauberung auf der angegebenen Stufe.

gegenstand.getItemMeta()

gegenstand: ItemStack

ItemMeta

Gibt die Meta-Daten eines Gegenstandes zurück.

gegenstand.setAmount(i)

i: Ganzzahl

 

Legt die Anzahl der Gegenstände im Stapel fest.

gegenstand.setItemMeta(metaData)

gegenstand: ItemStack, metaData: ItemMeta

 

Weist einem Gegenstand Meta-Daten zu.

ItemStack(material)

material: Material

ItemStack

Erzeugt einen neuen Stapel von Gegenständen des angegebenen Typs.

metaData.setDisplayName(string)

metaData: ItemMeta, string: String

 

Legt den Anzeigenamen des Gegenstandes fest.

A.13  Inventar

Befehl

Parameter

Rückgabewert

Beschreibung

inventar.addItem(gegenstand)

inventar: Inventory, gegenstand: ItemStack

 

Fügt dem Inventar den übergebenen Gegenstand hinzu.

inventar.contains(material)

inventar: Inventory, material: Material

Wahrheitswert

Gibt True zurück, falls der übergebene Gegenstand im Inventar mindestens einmal vorhanden ist.

inventar.first(material)

inventar: Inventory, material: Material

ItemStack

Gibt den ersten Stapel im Inventar zurück, der den übergebenen Gegenstand enthält.

inventar.firstEmpty()

inventar: Inventory

Ganzzahl

Gibt die Nummer des ersten freien Slots im Inventar zurück.

inventar.getItem(i)

inventar: Inventory, i: Ganzzahl

ItemStack

Gibt den Stapel von Gegenständen im i-ten Slot des Inventars zurück.

inventar.remove(gegenstand)

inventar: Inventory, gegenstand: ItemStack

 

Entfernt den übergebenen Gegenstand aus dem Inventar.

spieler.getInventory()

spieler: Spieler

Inventory

Gibt das Inventar eines Spielers zurück.

A.14  Crafting-Rezepte

Befehl

Parameter

Rückgabewert

Beschreibung

rezept.addIngredient(material)

rezept: ShapelessRecipe, material: Material

 

Fügt eine Zutat zu einem Rezept ohne feste Anordnung hinzu.

rezept.setIngredient(b, material)

rezept: ShapedRecipe, b: String, material: Material

 

Fügt einem Rezept mit fester Anordnung eine Zutat hinzu.

rezept.shape(reihe1, reihe2, reihe3)

rezept: ShapedRecipe, reihe1, reihe2, reihe3: String

 

Legt die Form eines Rezeptes mit fester Anordnung fest.

self.getServer().addRecipe(rezept)

self: Plugin-Klasse, rezept: Recipe

 

Fügt dem Server ein Rezept hinzu.

ShapedRecipe(gegenstand)

gegenstand: ItemStack

ShapedRecipe

Erzeugt ein neues Rezept mit fester Anordnung.

ShapelessRecipe(gegenstand)

gegenstand: ItemStack

ShapelessRecipe

Erzeugt ein neues Rezept ohne feste Anordnung.

A.15  Rechnen

Befehl

Parameter

Rückgabewert

Beschreibung

float(a)

a: String

Kommazahl

Wandelt a in eine Kommazahl um.

int(a)

a: String

Ganzzahl

Wandelt a in eine Ganzzahl um.

pow(x, y)

x, y: Zahl

Zahl

Berechnet xy

range(x, y)

x,y: Ganzzahlen

Liste mit Ganzzahlen

Erstellt eine Liste aller Ganzzahlen von x (einschließlich) bis y (ausschließlich)

round(a)

a: Zahl

Zahl

Rundet a (kaufmännisch) auf die nächste ganze Zahl.

str(a)

a: beliebiger Wert oder Objekt

String

Wandelt a in einen String um.

x - y

x, y: Zahlen

Zahl

Subtrahiert y von x.

x % y

x, y: Zahlen

Zahl

Berechnet den Rest beim Teilen von x durch y.

x * y

x, y: Zahlen

Zahl

Multipliziert die beiden Zahlen x und y.

x / y

x, y: Zahlen

Zahl

Teilt x durch y.

x + y

x, y: Zahlen

Zahl

Addiert die beiden Zahlen x und y.

x + y

x, y: String

String

Konkateniert (verbindet) die beiden Strings x und y.

A.16  Chat-Nachrichten

Befehl

Parameter

Rückgabewert

Beschreibung

self.getServer().broadcastMessage(string)

self: Plugin-Objekt, string: String

 

Sendet den übergebenen String als Chat-Nachricht an alle Spieler.

spieler.sendMessage(string)

spieler: Spieler, string: String

 

Sender den übergebenen String als Chat-Nachricht an den Spieler.

A.17  Listener

Befehl

Parameter

Rückgabewert

Beschreibung

class ListenerPlugin (PythonListener):
    @PythonEventHandler(Event, EventPriority.NORMAL)
    def onEvent(self, event):
        #Anweisungen

   

Grundgerüst einer Listener-Klasse.

pluginManager = self.getServer().getPluginManager()
listener = ListenerPlugin()pluginManager.registerEvents(listener, self)

   

Registrierung eines Listeners.

A.18  Dateien

Befehl

Parameter

Rückgabewert

Beschreibung

open(pfad, "rb")

pfad: String

File

Öffnet die Datei unter dem angegebenen Pfad zum Lesen.

open(pfad, "wb")

pfad: String

File

Öffnet die Datei unter dem angegebenen Pfad zum Schreiben.

pickle.dump(objekt, datei)

objekt: beliebiges Objekt, datei: File

 

Speichert das übergebene Objekt in der übergebenen Datei.

pickle.load(datei)

datei: File

Objekt

Gibt das in der übergebenen Datei gespeicherte Objekt zurück.

self.getDataFolder().exists()

self: Plugin-Klasse

Wahrheitswert

Überprüft, ob für das Plugin bereits ein Daten-Ordner existiert.

self.getDataFolder().getPath()

self: Plugin-Klasse

String

Gibt den Pfad zum Daten-Ordner des Plugins zurück.

self.getDataFolder().mkdirs()

self: Plugin-Klasse

 

Erzeugt einen Daten-Ordner für das Plugin.

A.19  Konfigurationen

Befehl

Parameter

Rückgabewert

Beschreibung

config.getBoolean(name)

config: FileConfiguration, name: String

Wahrheitswert

Gibt einen Wahrheitswert aus der Konfiguration zurück, der unter dem Namen name gespeichert wurde.

config.getDouble(name)

config: FileConfiguration, name: String

Kommazahl

Gibt einen Kommazahl-Wert aus der Konfiguration zurück, der unter dem Namen name gespeichert wurde.

config.getInt(name)

config: FileConfiguration, name: String

Ganzzahl

Gibt einen Ganzzahl-Wert aus der Konfiguration zurück, der unter dem Namen name gespeichert wurde.

config.getList(name)

config: FileConfiguration, name: String

Liste

Gibt eine Liste aus der Konfiguration zurück, der unter dem Namen name gespeichert wurde.

config.getString(name)

config: FileConfiguration, name: String

String

Gibt einen String-Wert aus der Konfiguration zurück, der unter dem Namen name gespeichert wurde.

config.save(datei)

config: FileConfiguration, datei: File

 

Speichert die Konfiguration in der angegebenen Datei.

config.setBoolean(name, wert)

config: FileConfiguration, name: String, wert: Wahrheitswert

 

Speichert den übergebenen Wert in der Konfigurationsdatei unter dem angegebenen Namen.

config.setDouble(name, wert)

config: FileConfiguration, name: String, wert: Kommazahl

 

Speichert den übergebenen Wert in der Konfigurationsdatei unter dem angegebenen Namen.

config.setInt(name, wert)

config: FileConfiguration, name: String, wert: Ganzzahl

 

Speichert den übergebenen Wert in der Konfigurationsdatei unter dem angegebenen Namen.

config.setList(name, wert)

config: FileConfiguration, name: String, wert: Liste

 

Speichert den übergebenen Wert in der Konfigurationsdatei unter dem angegebenen Namen.

config.setString(name, wert)

config: FileConfiguration, name: String, wert: String

 

Speichert den übergebenen Wert in der Konfigurationsdatei unter dem angegebenen Namen.

self.getConfig()

self: Plugin-Klasse

FileConfiguration

Liest die Datei config.yml ein.

self.saveResource(dateiname, ueberschreiben)

self: Plugin-Klasse, dateiname: String, ueberschreiben: Wahrheitswert

 

Kopiert die angegebene Datei aus dem Plugin- in das Daten-Verzeichnis. Wenn ueberschreiben auf True gesetzt ist, wird eine eventuell bereits vorhandene gleichnamige Datei überschrieben.

YamlConfiguration.loadConfiguration(datei)

datei: File

FileConfiguration

Lädt eine Konfiguration aus der übergebenen Datei.

Kapitel 16
Eigenständige Python-Programme

Mit allem, was du inzwischen über Python gelernt hast, kannst du in Zukunft nicht nur Plugins programmieren, auch das Programmieren eigener Python-Programme, häufig auch Python-Skripte​ genannt, sollte dir leicht von der Hand gehen. Natürlich gibt es einige Unterschiede und Besonderheiten, die zu beachten sind, aber die grundsätzlichen Regeln bleiben dieselben. Dieses Kapitel soll dir einen kleinen Ausblick darauf geben, wie du in Zukunft deine Python-Kenntnisse auch außerhalb von Minecraft einsetzen könntest.

Solltest du dich dafür interessieren, so seien dir auch die Bücher »Python für Kids« und »Python 3 – Lernen und professionell anwenden«, die ebenfalls im mitp-Verlag erschienen sind, ans Herz gelegt. Dort wird, nicht nur für Kids, ausführlich erklärt, wie du eigene Programme mit Python erstellen kannst.

16.1  Python einrichten

Nutzer von GNU/Linux und OS X können diesen Abschnitt überspringen, denn ihre Betriebssysteme kommen in der Regel schon mit einer vorinstallierten Version von Python. Das kannst du testen, indem du das Terminal öffnest und dort python --version eingibst. Daraufhin sollte dir die installierte Python-Version angezeigt werden. Windows-Nutzer müssen dagegen Python​ erst installieren. Einen Link zur Installationsdatei findest du auf der Website zum Buch. Nachdem du diese heruntergeladen hast, kannst du sie mit einem Doppelklick starten. Danach erscheint der in Abbildung 16.1 gezeigte Dialog.

Hier solltest du unbedingt das rot umrandete Häkchen setzen, wobei sich die Versionsnummer bei neueren Versionen ändern kann. Danach beginnst du die Installation mit einem Klick auf Install Now. Nun musst du nur noch etwas Geduld haben und damit ist die Installation auch bereits abgeschlossen. Wenn du nun die Eingabeaufforderung öffnest und dort python --version eingibst, sollte dort ebenfalls die installierte Python-Versionsnummer angezeigt werden.

Abb. 16.1: Startbildschirm Python-Installation

Hinweis

Für die Experten, die sich bereits mit Python auskennen, sei an dieser Stelle noch erwähnt, dass die Python-Plugins, die wir im Rahmen dieses Buches programmiert haben, die Python Version 2 verwenden, da diese vom PythonPluginLoader für Bukkit beziehungsweise Spigot verwendet wird. In diesem Kapitel werden wir dagegen die aktuellste Python-Version, also 3, einsetzen.

16.2  Grundgerüst

Das Grundgerüst von Minecraft-Plugins ist dir inzwischen mit Sicherheit mehr als vertraut. Plugins bestehen aus onEnable-, onDisable-, und onCommand-Funktionen, die Hauptklasse muss immer von der Klasse PythonPlugin erben und so weiter.

Ein solches starres Grundgerüst gibt es für eigenständige Python-Programme nicht, sie können deshalb sehr kurz sein, wie das »Hallo Welt«-Programm, das du bereits im zweiten Kapitel dieses Buches kennengelernt hast und in Listing 16.1 sehen kannst.

print("Hallo Welt!")

Listing 16.1: Ein besonders kurzes – aber funktionierendes – Python-Programm

Um das »Hallo Welt«-Programm auszuführen, speicherst du es zunächst auf deiner Festplatte, unter Windows könntest du dafür zum Beispiel einen Ordner C:\Python-Programme anlegen, unter OS X /Users/Benutzername/Python-Programme und unter GNU/Linux home/Benutzername/Python-Programme. In diesem Ordner speicherst du das Python-Programm dann unter einem beliebigen Namen mit der Dateieendung .py, also zum Beispiel hallo.py. Jetzt musst du nur noch die Eingabeaufforderung beziehungsweise das Terminal öffnen und dort mit cd in das neu geschaffene Verzeichnis wechseln. Dort kannst du dein Programm dann mit dem Befehl python hallo.py starten. Das Ergebnis sollte ungefähr wie in Abbildung 16.2 aussehen.

Abb. 16.2: »Hallo Welt«-Programm in der Eingabeaufforderung

16.3  Ein- und Ausgabe

Wenn wir heute an Computerprogramme denken, dann denken wir meist sofort an grafische Benutzeroberflächen, Buttons und Grafiken. In einer nicht allzu fernen Vergangenheit war das noch anders: Ein Computerprogramm bestand lediglich aus Text, der in der Kommandozeile ein- und ausgegeben werden konnte. Wenn du anfängst, deine ersten eigenen Programme zu schreiben, wirst du dich vorübergehend in diese Zeit zurückversetzt fühlen.

Wie du Informationen auf der Kommandozeile ausgeben kannst, hast du bereits im »Hallo Welt«-Programm gesehen. Der print-Befehl funktioniert in Plugins und »normalen« Python-Programmen. Andere Befehle wie sendMessage oder broadcastMessage funktionieren dagegen nur in Minecraft-Plugins.

Wie es schon bei den Plugins der Fall war, werden auch Programme erst richtig interessant, wenn sie Daten verarbeiten können, die der Nutzer eingibt. Glücklicherweise geht das, wie du in Listing 16.2 sehen kannst, sehr einfach.

1  name = input("Wie heisst du? ")
2  print("Hallo " + name)

Listing 16.2: Einlesen einer Eingabe

Hinweis

Solltest du eine Version 2.x von Python verwenden, dann lautet der Befehl raw_input​, statt input.

Der Befehl input​ wartet auf die Eingabe eines Spielers. In Klammern kann ihm ein Text übergeben werden, der dem Benutzer erklärt, welche Eingabe erwartet wird. Das Programm bleibt dann solange an dieser Stelle stehen, bis der Benutzer eine Eingabe vornimmt und diese mit Enter bestätigt. Diese Eingabe wird dann von der Funktion als Rückgabewert an dein Programm geliefert und die Ausführung geht ganz normal weiter. Die Ausgabe des Programmes sieht dann wie in Abbildung 16.3 gezeigt aus.

Abb. 16.3: Ausgabe einer eingelesenen Eingabe

Tipp

Besteht eine Eingabe aus Zahlen, so werden diese zunächst, wie du es bereits von den Plugins kennst, ebenfalls als String gespeichert und müssen umgewandelt werden, bevor zum Beispiel mit ihnen gerechnet werden kann.

16.4  Quiz programmieren

Damit sind wir auch schon fast am Ende unseres kurzen Ausflugs in die Welt der Python-Programme angekommen. Allerdings nicht, bevor wir nicht zumindest ein kleines Spiel selbst programmiert haben. Das nächste Minecraft werden wir an dieser Stelle wohl noch nicht entwickeln können, aber ein unterhaltsames Quiz sollte dir bereits problemlos gelingen.

Der Aufbau soll dabei ganz klassisch sein: Der Spieler bekommt eine Frage gestellt und wählt eine von vier Antwortmöglichkeiten aus, von denen selbstverständlich nur eine richtig ist.

Zu Beginn solltest du eine Klasse wie in Listing 16.3 anlegen, die für die Repräsentation einer Frage zuständig ist. Die Klasse muss den Fragetext, die richtige Antwort und drei falsche Antworten speichern. Diese Klasse kannst du in deinem eben erstellten Ordner in einer Datei mit dem Namen frage.py speichern.

 1  class Frage:
 2      def __init__(self, frage, richtige_antwort, falsche_antworten):
 3          self.__frage = frage
 4          self.__falsche_antworten = falsche_antworten
 5          self.__richtige_antwort = richtige_antwort
 6  
 7      def get_frage(self):
 8          return self.__frage
 9  
10      def get_falsche_antworten(self):
11          return self.__falsche_antworten
12  
13      def get_richtige_antwort(self):
14          return self.__richtige_antwort

Listing 16.3: Frage-Klasse

Hinweis

In Kapitel 5 wurden Konventionen für die Schreibung von Variablennamen eingeführt. Vielleicht erinnerst du dich noch daran, dass Variablen in Python eigentlich komplett kleingeschrieben werden und verschiedene Worte durch Unterstriche getrennt werden. Für die Programmierung von Plugins haben wir, da der Minecraft-Server in Java geschrieben ist, auf die Java-Konvention zurückgegriffen, die Binnenmajuskel verwendet. Da wir nun unabhängig vom Server arbeiten, können wir auch zur üblichen Python-Konvention zurückkehren und Unterstriche verwenden.

Für das eigentliche Quiz kannst du eine weitere Datei anlegen, die den Namen quiz.py trägt. Da sich beide Dateien im selben Ordner befinden, funktioniert der Import der Frage-Klasse innerhalb der Quiz-Datei, wie du in Listing 16.4 sehen kannst, denkbar einfach. Als from wird einfach der Dateiname ohne .py-Endung angegeben und als import der Klassenname.

 1  from frage import Frage
 2  
 3  fragen = []
 4  
 5  fragen.append(Frage("Wie heisst die Hauptstadt von Frankreich?", "Paris", ["Bruessel", "Lyon", "Marseille"]))
 6  
 7  fragen.append(Frage("Wie ist der Spitzname des Minecraft-Erfinders?", "notch", ["motch", "scotch", "botch"]))
 8  
 9  fragen.append (Frage("Wie viele Bundeslaender hat die Bundesrepublik Deutschland?", "16", ["15", "17", "18"]))
10  
11  fragen.append (Frage("Wie heisst die Hauptstadt der Steiermark?", "Graz", ["Wien", "Hartberg", "Eisenstadt"]))

Listing 16.4: Grundgerüst des Quiz

Ist die Klasse erst einmal importiert, so kannst du, wie ebenfalls in Listing 16.4 gezeigt, sehr einfach neue Fragen hinzufügen. Nun müssen die Fragen aber natürlich auch noch ausgegeben und auf die Antwort gewartet werden.

Du kannst die Fragen entweder in der Reihenfolge anzeigen, in der sie eingegeben wurden, oder in einer zufälligen Reihenfolge, wenn du eine etwas ausgeklügeltere Umsetzung wählst. Für letzteres kannst du wie in Listing 16.5 auf den dir bereits bekannten Zufallsgenerator zurückgreifen. Um zu verhindern, dass Fragen doppelt angezeigt werden, kannst du sie einfach mit dem dir bereits aus Kapitel 5 bekannten remove-Befehl aus der Liste der Fragen löschen, nachdem sie angezeigt wurden.

1  while(len(fragen) > 0):
2      zufallszahl = random.randint(0, len(fragen)-1)
3      frage = fragen[zufallszahl]
4      fragen.remove(zufallszahl)
5      print(frage.get_frage())

Listing 16.5: Randomisierte Anzeige der Fragen

Neben dem Fragetext selbst müssen dem Nutzer als nächstes noch die Antwortmöglichkeiten angezeigt werden. Hier solltest du wie in Listing 16.6 auf jeden Fall auf eine zufällige Reihenfolge setzen, denn wenn die richtige Antwort auf jede Frage immer die erste Antwortmöglichkeit ist, verliert das Quiz schnell seinen Reiz.

 1  while(len(fragen) > 0):
 2      zufallszahl = random.randint(0, len(fragen)-1)
 3      frage = fragen[zufallszahl]
 4      fragen.remove(zufallszahl)
 5      print(frage.get_frage())
 6  
 7      antworten = frage.get_falsche_antworten()
 8  
 9      antworten.append(frage.get_richtige_antwort())
10      random.shuffle(antworten)
11  
12      for i in range(0, len(antworten)):
13          print(str(i) + ": " + antworten[i], end=" ")
14      print("")

Listing 16.6: Anzeige der Antwortmöglichkeiten

Die zufällige Reihenfolge wird in Listing 16.6 durch den Befehl shuffle sichergestellt, der die Elemente eines Arrays zufällig durcheinander würfelt. Neu ist auch, dass der print-Befehl noch den Zusatz end=" " bekommt. Dieser sorgt dafür, dass die Antwortmöglichkeiten alle in einer Reihe stehen und nicht, wie normal, nach jedem print-Befehl eine neue Reihe begonnen wird. Dafür brauchen wir dann aber in der letzten Reihe einen zusätzlichen print-Befehl, der die Reihe mit den Antwortmöglichkeiten beendet.

Als nächstes muss nun noch die Antwort des Spielers eingelesen werden. Genau der richtige Einsatz für die input-Funktion also. Dabei solltest du bedenken, dass deine Nutzer möglicherweise nicht immer eine der Antwortmöglichkeiten, 0, 1, 2 oder 3, eingeben, sondern beliebigen anderen Text oder Zahlen. Deshalb solltest du, bevor du »Falsch« oder »Richtig« ausgibst, zunächst auf jeden Fall prüfen, ob es sich überhaupt um eine gültige Eingabe handelt. Mit der Funktion isdigit kannst du prüfen, ob es sich bei einem String um eine positive Zahl handelt. Das reicht allerdings noch nicht ganz aus, deshalb solltest du im nächsten Schritt auch noch überprüfen, ob diese Zahl kleiner als vier ist.

 1  while(len(fragen) > 0):
 2      zufallszahl = random.randint(0, len(fragen)-1)
 3      frage = fragen[zufallszahl]
 4      fragen.remove(zufallszahl)
 5      print(frage.get_frage())
 6  
 7      antworten = frage.get_falsche_antworten()
 8  
 9      antworten.append(frage.get_richtige_antwort())
10      random.shuffle(antworten)
11  
12      for i in range(0, len(antworten)):
13          print(str(i) + ": " + antworten[i], end=" ")
14      print("")
15  
16      antwort = input("Bitte waehle deine Antwort: ")
17      if antwort.isdigit() & int(antwort) < 4:
18          if antworten[int(antwort)] == frage.get_richtige_antwort():
19              print("Richtig!")
20          else:
21              print("Falsch")
22      else:
23          print("Bitte gib eine Zahl zwischen 0 und 3 als Antwort ein.")

Listing 16.7: Einlesen der Antwort

Nun musst du nur noch die einzelnen Teile des Quiz zusammenführen und die erforderlichen Importe hinzufügen. Wie das Endergebnis aussehen sollte, kannst du in Listing 16.8 sehen.

 1  import random
 2  from frage import Frage
 3  
 4  fragen = []
 5  
 6  fragen.append(Frage("Wie heisst die Hauptstadt von Frankreich?", "Paris", ["Bruessel", "Lyon", "Marseille"]))
 7  
 8  fragen.append(Frage("Wie ist der Spitzname des Minecraft-Erfinders?", "notch", ["motch", "scotch", "botch"]))
 9  
10  fragen.append (Frage("Wie viele Bundeslaender hat die Bundesrepublik Deutschland?", "16", ["15", "17", "18"]))
11  
12  fragen.append (Frage("Wie heisst die Hauptstadt der Steiermark?", "Graz", ["Wien", "Hartberg", "Eisenstadt"]))
13  
14  while(len(fragen) > 0):
15      zufallszahl = random.randint(0, len(fragen)-1)
16      frage = fragen[zufallszahl]
17      fragen.remove(zufallszahl)
18      print(frage.get_frage())
19  
20      antworten = frage.get_falsche_antworten()
21  
22      antworten.append(frage.get_richtige_antwort())
23      random.shuffle(antworten)
24  
25      for i in range(0, len(antworten)):
26          print(str(i) + ": " + antworten[i], end=" ")
27      print("")
28  
29      antwort = input("Bitte waehle deine Antwort: ")
30      if antwort.isdigit() & int(antwort) < 4:
31          if antworten[int(antwort)] == frage.get_richtige_antwort():
32              print("Richtig!")
33          else:
34              print("Falsch")
35      else:
36          print("Bitte gib eine Zahl zwischen 0 und 3 als Antwort ein.")

Listing 16.8: Komplettes Quiz

Damit sind wir auch schon am Ende dieses Buches und unseres kurzen Ausflugs in die Welt der Python-Programme angekommen. Ich hoffe, er hat dich auf die Möglichkeiten neugierig gemacht, die du als Python-Programmierer nun hast. Denn wenn du weiter am Ball bleibst und mehr über das Programmieren lernst, ist das, was du in diesem Buch gesehen und gelernt hast, erst der Anfang. Viel Spaß dabei!