551 lines
18 KiB
Python
551 lines
18 KiB
Python
# Actionmdul - hier werden die Kommandos ausgeführt und die Spielwelt entsprend aktualisiert.
|
|
|
|
import logging
|
|
from ActionBasics import ActionBasics
|
|
|
|
class ActionModul(ActionBasics):
|
|
|
|
def isBlank(self,str):
|
|
logging.debug(f'isBlank(): str=*{str}*')
|
|
if str != None and len(str.strip()) == 0:
|
|
return True
|
|
return False
|
|
|
|
def __init__(self, world):
|
|
|
|
super().__init__(world)
|
|
|
|
def warte(self):
|
|
print('Du wartest')
|
|
|
|
|
|
def inventar(self):
|
|
|
|
self.world.stdscr.addstr(12,0,'Du besitzt folgende Gegenstände:')
|
|
zeile=13
|
|
for itemid in self.world.inventar:
|
|
item = self.world.inventar[itemid]
|
|
self.world.stdscr.addstr(zeile,0,item.name)
|
|
zeile = zeile +1
|
|
|
|
def klettere(self, parsedCommand):
|
|
item = self.world.findItemInAktuellerRaum(parsedCommand.gegenstand)
|
|
|
|
if item != None:
|
|
if item.id == self.world.ITEM_RANKGITTER:
|
|
self.rauf()
|
|
elif item.id == self.world.ITEM_BOHNENRANKE:
|
|
if item.zustand == item.GROSS:
|
|
self.rauf()
|
|
else:
|
|
self.setFehler('zum Klettern ist die Bohnenranke zu klein.')
|
|
else:
|
|
self.setFehler('Das sehe ich hier nicht.')
|
|
|
|
|
|
def vanishItem(self, item):
|
|
item.sichtbar = False
|
|
self.ausDemInventar(item)
|
|
|
|
def oeffne(self,parsedCommand):
|
|
item = self.world.findItemImInventarOderAktuellerRaum(parsedCommand.gegenstand);
|
|
|
|
logging.debug(f'öffne RaumId= {self.world.aktuellerRaum.id}')
|
|
logging.debug(f'öffne Item= {item}')
|
|
if item != None:
|
|
logging.debug(f'öffne ItemId= {item.id}')
|
|
if item.id == self.world.ITEM_TRUHE:
|
|
logging.debug('öffne Truhe')
|
|
schluessel = self.world.findItemImInventarById(self.world.ITEM_KLEINER_SCHLUESSEL)
|
|
|
|
self.vanishItem(schluessel)
|
|
|
|
if schluessel != None and item.zustand != item.OFFEN:
|
|
item.zustand = item.OFFEN
|
|
seil = self.world.findItemById(self.world.ITEM_SEIL)
|
|
seil.raumid = self.world.aktuellerRaum.id
|
|
seil.sichtbar = True
|
|
self.world.aktuellerRaum.items[seil.id] = seil
|
|
schwert = self.world.findItemById(self.world.ITEM_SCHWERT)
|
|
schwert.sichtbar = True
|
|
schwert.raumid = self.world.aktuellerRaum.id
|
|
self.world.aktuellerRaum.items[schwert.id] = schwert
|
|
self.setFehler('Aus der Truhe fallen ein Seil und ein Schwert. Der kleine Schlüssel löst sich auf.')
|
|
else:
|
|
self.setFehler('Die Truhe ist verschlossen und dir fehlt der passende Schlüssel.')
|
|
|
|
elif item.id == self.world.ITEM_HAUSTUER:
|
|
if self.isAktuellerRaum(self.world.RAUM_FLUR):
|
|
schluessel = self.world.findItemImInventarById(self.world.ITEM_HAUSTUERSCHLUESSEL)
|
|
|
|
logging.debug(f'öffne Haustür Schlüssel ist {schluessel}')
|
|
if schluessel != None:
|
|
item.zustand = item.OFFEN
|
|
self.vanishItem(schluessel)
|
|
self.setFehler('Die Haustür ist geöffnet,der Haustürschlüssel löst sich auf.')
|
|
self.world.aktuellerRaum.ausgaenge[self.world.SUED] = self.world.RAUM_GARTEN
|
|
else:
|
|
self.setFehler('Die Tür ist verschlossen.')
|
|
elif item.id == self.world.ITEM_GATTER:
|
|
logging.debug('Gatter öffnen')
|
|
if self.isAktuellerRaum(self.world.RAUM_WIESE):
|
|
stier = self.world.findPersonImAktuellenRaumById(self.world.PERSON_STIER)
|
|
|
|
logging.debug(f'Stier ist {stier}')
|
|
|
|
if stier == None:
|
|
item.zustand = item.OFFEN
|
|
self.macheWegFrei(self.world.SUED,self.world.RAUM_BRACHLAND)
|
|
self.setFehler('Das Gatter steht offen.')
|
|
else:
|
|
self.setFehler(f'Der Stier steht dir im Weg.')
|
|
elif item.id == self.world.ITEM_SCHACHTEL:
|
|
karte = self.world.findItemById(self.world.ITEM_KARTE)
|
|
logging.debug('Schachtel öffnen')
|
|
item.zustand = item.OFFEN
|
|
self.macheItemSichtbar(karte)
|
|
|
|
|
|
|
|
def isAktuellerRaum(self, raumid):
|
|
return self.world.aktuellerRaum.id == raumid
|
|
|
|
def benutze(self, parsedCommand):
|
|
item = self.world.findItemImInventarOderAktuellerRaum(parsedCommand.gegenstand);
|
|
|
|
if item.id ==self.world.ITEM_JACKE:
|
|
self.setFehler('Also du die Jacke anziehst, findest du einen kleine Schlüssel in der Tasche.')
|
|
self.findeTruhenschluessel()
|
|
elif item.id == self.world.ITEM_LEITER:
|
|
if(self.world.aktuellerRaum.id == self.world.RAUM_ESSZIMMER):
|
|
logging.debug(f'aktuellerRaum ist {self.world.aktuellerRaum.id}')
|
|
self.rauf()
|
|
elif item.id == self.world.ITEM_PLANKE:
|
|
if self.isAktuellerRaum(self.world.RAUM_BACH):
|
|
self.baueBruecke()
|
|
self.setFehler('Du legst die Planke über den Bach und es ensteht eine Brücke.')
|
|
else:
|
|
self.setFehler('Das macht hier keinen Sinn.')
|
|
|
|
|
|
def baueBruecke(self):
|
|
bach = self.world.sucheRaum(self.world.RAUM_BACH)
|
|
bach.ausgaenge[self.world.OST] = self.world.RAUM_TEICH
|
|
|
|
|
|
def verliere(self,parsedCommand):
|
|
item = self.world.findItemImInventar(parsedCommand.gegenstand);
|
|
|
|
|
|
logging.debug(f'verliere Item {item}')
|
|
if item != None:
|
|
|
|
if self.isAktuellerRaum(self.world.RAUM_BACH):
|
|
if item.id == self.world.ITEM_PLANKE:
|
|
self.baueBruecke()
|
|
self.setFehler('Du legst die Planke über den Bach und es ensteht eine Brücke über den Bach')
|
|
|
|
self.ausDemInventar(item)
|
|
else:
|
|
self.setFehler("Diesen Gegenstand besitzt du nicht.")
|
|
|
|
|
|
|
|
def stelle(self,parsedCommand):
|
|
item = self.world.findItemImInventar(parsedCommand.gegenstand);
|
|
|
|
if item != None:
|
|
logging.debug('stelle() item.id=' + str(item.id))
|
|
if item.id == self.world.ITEM_KRUG:
|
|
self.world.aktuellerRaum.ausgaenge[self.world.NORD] = '5'
|
|
self.verliere(parsedCommand)
|
|
self.world.printText('1')
|
|
else:
|
|
self.setFehler("Diesen Gegenstand besitzt du nicht.")
|
|
|
|
def untersucheAktuellenRaum(self, parsedCommand):
|
|
raum = self.world.sucheRaumName(parsedCommand.gegenstand)
|
|
|
|
logging.debug(f'raumId {raum.id}')
|
|
logging.debug(f'untersucheAktuellenRaum() {parsedCommand.gegenstand} in {self.world.aktuellerRaum.id}')
|
|
if self.isAktuellerRaum(raum.id):
|
|
logging.debug(f'untersuche aktuellen Raum {raum.name}')
|
|
|
|
def untersuchePerson(self,person):
|
|
|
|
if person.id == self.world.PERSON_ZWERG:
|
|
self.world.printText(f'npc-{person.id}-beschr')
|
|
|
|
def findeTruhenschluessel(self):
|
|
schluessel = self.world.findItemById(self.world.ITEM_KLEINER_SCHLUESSEL)
|
|
|
|
logging.debug(f'Schlüssel ist sichtbar {schluessel.sichtbar}')
|
|
if not schluessel.sichtbar:
|
|
logging.debug('mache Schlüssel sichtbar')
|
|
self.setFehler('In der Jackentasche findest du einen kleinen Schlüssel.')
|
|
schluessel.sichtbar = True
|
|
self.insInventar(schluessel)
|
|
|
|
def schlage(self, parsedCommand):
|
|
item = self.world.findItemInAktuellerRaum(parsedCommand.gegenstand)
|
|
|
|
if item.id == self.world.ITEM_BOXSACK:
|
|
self.setFehler('Der Boxsack sagt: Hmm, hmm?')
|
|
|
|
def leere(self, parsedCommand):
|
|
item = self.world.findItemImInventar(parsedCommand.gegenstand)
|
|
|
|
if item.id == self.world.ITEM_KRUG:
|
|
if self.isAktuellerRaum(self.world.RAUM_BRACHLAND):
|
|
if item.zustand == item.VOLL:
|
|
ranke = self.world.findItemById(self.world.ITEM_BOHNENRANKE)
|
|
fisch = self.world.findItemImInventarById(self.world.ITEM_FISCH)
|
|
|
|
logging.debug(f'Fisch ist {fisch}')
|
|
|
|
if fisch != None:
|
|
logging.debug('Krug leeren löst den Fisch auf.')
|
|
self.vanishItem(fisch)
|
|
self.setFehler('Der Fisch löst sich auf.')
|
|
|
|
if ranke.zustand < ranke.GROSS:
|
|
ranke.zustand = ranke.zustand +1
|
|
meldung = 'Die Bohnenranke wächst.'
|
|
|
|
if fisch != None:
|
|
meldung = meldung + ' Der Fisch löst sich auf.'
|
|
|
|
self.setFehler(meldung)
|
|
if ranke.zustand == ranke.GROSS:
|
|
self.world.aktuellerRaum.ausgaenge[self.world.RAUF] = self.world.RAUM_BOHNENRANKE
|
|
self.setFehler('Die Bohnenranke reicht jetzt bis in die Wolken hinein.')
|
|
else:
|
|
self.setFehler('Der Krug ist leer')
|
|
else:
|
|
item.zustand = item.LEER
|
|
|
|
def fuelle(self, parsedCommand):
|
|
item = self.world.findItemImInventar(parsedCommand.gegenstand)
|
|
|
|
if item.id == self.world.ITEM_KRUG:
|
|
if self.isAktuellerRaum(self.world.RAUM_TEICH):
|
|
item.zustand = item.VOLL
|
|
self.setFehler('Der Krug ist jetzt voll')
|
|
|
|
def zeigeItemBeschreibung(self,item):
|
|
textid = f'item-{item.id}'
|
|
if item.id == self.world.ITEM_BOHNENRANKE:
|
|
textid = f'item-{item.id}-{item.zustand}'
|
|
else:
|
|
textid = f'item-{item.id}'
|
|
self.world.printText(textid)
|
|
|
|
def untersuche(self,parsedCommand):
|
|
logging.debug(f'untersuche() suche nach Gegenstand: {parsedCommand.gegenstand}')
|
|
if parsedCommand.gegenstand == None:
|
|
self.untersucheAktuellenRaum()
|
|
|
|
return
|
|
|
|
item = self.world.findItemImInventarOderAktuellerRaum(parsedCommand.gegenstand)
|
|
if item == None:
|
|
self.setFehler('Das sehe ich hier nicht')
|
|
return
|
|
|
|
if item != None:
|
|
if item.id == self.world.ITEM_PFLANZE:
|
|
krug = self.world.findRaumItemById(self.world.ITEM_KRUG)
|
|
logging.debug(f'mache Gegenstand {krug.name} sichtbar')
|
|
krug.sichtbar = True
|
|
self.setFehler('Die Pflanze ist in einen Krug gepflanzt.')
|
|
elif item.id == self.world.ITEM_BETT:
|
|
# Falltür sichtbar machen
|
|
self.world.aktuellerRaum.ausgaenge[self.world.RUNTER] = self.world.RAUM_KELLER
|
|
logging.debug('untersuche(): Keller ist jetzt zugänglich')
|
|
self.setFehler('Im Boden unter dem Bett findest du eine Falltür, die nach unten führt.')
|
|
elif item.id == self.world.ITEM_NACHTSCHRANK:
|
|
self.setFehler('In der Schublade findest du einen Schlüssel')
|
|
schluessel = self.world.findRaumItemById(self.world.ITEM_HAUSTUERSCHLUESSEL)
|
|
schluessel.sichtbar = True
|
|
elif item.id == self.world.ITEM_TEICH:
|
|
fisch = self.world.findItemById(self.world.ITEM_FISCH)
|
|
|
|
|
|
if fisch.raumid == self.world.RAUM_TEICH:
|
|
fisch.sichtbar = True
|
|
self.setFehler('Im Teich schwimmt ein kleiner Fisch')
|
|
fisch = self.world.findItemById(self.world.ITEM_FISCH)
|
|
fisch.sichtbar = True
|
|
elif item.id == self.world.ITEM_JACKE:
|
|
self.findeTruhenschluessel()
|
|
elif item.id == self.world.ITEM_FISCH:
|
|
self.zeigeItemBeschreibung(item)
|
|
item.sichtbar = False
|
|
self.ausDemInventar(item)
|
|
elif self.isItem(item,self.world.ITEM_KARTE):
|
|
self.world.printKarte()
|
|
else:
|
|
self.zeigeItemBeschreibung(item)
|
|
|
|
else:
|
|
person = self.world.findPersonImAktuellenRaum(self.world.PERSON_ZWERG)
|
|
|
|
logging.debug('Kein Item gefunden, suche nach Raum')
|
|
self.untersucheAktuellenRaum(parsedCommand)
|
|
|
|
def ziehe(self,parsedCommand):
|
|
item = self.world.findItemInAktuellerRaum(parsedCommand.gegenstand)
|
|
|
|
if item != None:
|
|
#alter Code!
|
|
if item.id == 8:
|
|
self.world.stdscr.addstr('Du ziehst den Hebel und es passiert.... nichts!')
|
|
else:
|
|
self.setFehler('Das sehe ich hier nicht.')
|
|
|
|
def fange(self, parsedCommand):
|
|
skip
|
|
|
|
def wirf(self,parsedCommand):
|
|
item = self.world.findItemImInventar(parsedCommand.gegenstand)
|
|
|
|
if item == None:
|
|
self.setFehler('Das besitzt du nicht.')
|
|
return
|
|
|
|
if self.isItemAndAktRaum(item, self.world.ITEM_SEIL,self.world.RAUM_BAUM):
|
|
self.world.printText('seilwurf')
|
|
self.macheWegFrei(self.world.RAUF,self.world.RAUM_BAUMHAUS)
|
|
self.ausDemInventar(item)
|
|
item.zustand = item.HAENGEND
|
|
elif self.isAktuellerRaum(self.world.RAUM_BOHNENRANKE):
|
|
if self.isItem(item, self.world.ITEM_MAUS):
|
|
|
|
elefant = self.findItemInAktuellerRaumById(self.world.ITEM_ELEFANT)
|
|
|
|
logging.debug(f'Elefant - {elefant}')
|
|
if elefant != None:
|
|
self.world.printText('mauswurf')
|
|
self.ausDemInventar(item)
|
|
self.macheWegFrei(self.world.SUED,self.world.RAUM_PFAD)
|
|
del self.world.aktuellerRaum.items[elefant.id]
|
|
else:
|
|
self.setFehler('Der Elefant ist schon geflohen.')
|
|
else:
|
|
self.setFehler('Das besitzt du nicht')
|
|
elif self.isItemAndAktRaum(item, self.world.ITEM_JACKE, self.world.RAUM_WIESE):
|
|
logging.debug('Jackenwurf')
|
|
stier = self.world.findPersonImAktuellenRaumById(self.world.PERSON_STIER)
|
|
jacke = self.world.findItemImInventarById(self.world.ITEM_JACKE)
|
|
|
|
logging.debug(f'Stier {stier},Jacke {jacke}')
|
|
if stier != None:
|
|
if jacke != None:
|
|
self.world.printText('jackewurf')
|
|
logging.debug(f'1:Jacke im Raum {self.liegtItemInRaum(jacke.id, self.world.aktuellerRaum)}')
|
|
self.personVonRaumNachRaum(stier,self.world.aktuellerRaum.id, self.world.RAUM_FELD)
|
|
logging.debug(f'2:Jacke im Raum {self.liegtItemInRaum(jacke.id, self.world.aktuellerRaum)}')
|
|
self.moveItemVonInventarNachRaum(jacke, self.world.RAUM_FELD)
|
|
logging.debug(f'3:Jacke im Raum {self.liegtItemInRaum(jacke.id, self.world.aktuellerRaum)}')
|
|
else:
|
|
self.setFehler('Die trägst du nicht bei dir.')
|
|
else:
|
|
logging.debug(f'verliere Jacke (kein Stier)')
|
|
self.verliere(parsedCommand)
|
|
else:
|
|
logging.debug(f'verliere Jacke (falscher Raum, nicht Jacke)')
|
|
self.verliere(parsedCommand)
|
|
|
|
|
|
|
|
|
|
def klettere(self, parsedCommand):
|
|
item = self.world.findItemInAktuellerRaum(parsedCommand.gegenstand)
|
|
geklettert = False
|
|
|
|
if item == None:
|
|
self.setFehler('Das sehe ich hier nicht')
|
|
return
|
|
if item.id == self.world.ITEM_LEITER:
|
|
if self.isAktuellerRaum(self.world.RAUM_ESSZIMMER):
|
|
logging.debug(f'aktuellerRaum ist {self.world.aktuellerRaum.id}')
|
|
self.rauf()
|
|
geklettert = True
|
|
elif self.isAktuellerRaum(self.world.RAUM_BRACHLAND):
|
|
ranke = self.findItemImInventarOderAktuellerRaum(self.world.ITEM_BOHNENRANKE)
|
|
|
|
if ranke.zustand == Gegenstand.GROSS:
|
|
self.ac.rauf()
|
|
geklettert = True
|
|
else:
|
|
self.setFehler('Die Bohnenranke ist zu klein, um daran hoch zu klettern.')
|
|
elif item.id == self.world.ITEM_SEIL:
|
|
logging.debug(f'klettere am Seil: {item.zustand}')
|
|
if item.zustand == item.HAENGEND:
|
|
self.rauf()
|
|
geklettert = True
|
|
else:
|
|
self.setFehler('So kannst nicht daran klettern.')
|
|
|
|
if not geklettert:
|
|
self.setFehler('Klettern ist nicht möglich.')
|
|
|
|
|
|
|
|
|
|
|
|
def nimm(self,parsedCommand):
|
|
item = self.world.findItemInAktuellerRaum(parsedCommand.gegenstand)
|
|
|
|
logging.debug(f'nimm(): item == {item}')
|
|
if item != None:
|
|
if item.imobil:
|
|
text = self.world.msg[item.pickupmsg]
|
|
|
|
if self.isBlank(item.pickupmsg):
|
|
self.setFehler('Das kannst du nicht mitnehmen')
|
|
else:
|
|
text = self.world.msg[item.pickupmsg]
|
|
self.setFehler(text)
|
|
else:
|
|
|
|
aufnehmen = True
|
|
|
|
logging.debug(f'nimm(): RaumId== {self.world.aktuellerRaum.id}')
|
|
if self.isAktuellerRaum(self.world.RAUM_BACH):
|
|
logging.debug(f'nimm(): ItemId == {item.id}')
|
|
if item.id == self.world.ITEM_PLANKE:
|
|
logging.debug('nehme Planke am Bach')
|
|
self.world.aktuellerRaum.ausgaenge[self.world.SUED] = '-1'
|
|
elif self.isAktuellerRaum(self.world.RAUM_TEICH):
|
|
if item.id == self.world.ITEM_FISCH:
|
|
krug = self.world.findItemImInventarById(self.world.ITEM_KRUG)
|
|
|
|
if krug != None:
|
|
krug.zustand = krug.VOLL
|
|
self.setFehler('Du schöpfst mit dem Krug und der Fisch ist drin.')
|
|
else:
|
|
self.setFehler('Der Fisch ist zu glitschig, um ihn mit der Hand zu fangen.')
|
|
aufnehmen = False
|
|
|
|
if aufnehmen:
|
|
self.moveItemVonRaumNachInventar(item)
|
|
|
|
|
|
|
|
else:
|
|
self.setFehler("diesen Gegenstand sehe ich hier nicht.")
|
|
|
|
|
|
|
|
def sprich(self,parsedCommand):
|
|
person = self.world.findPersonImAktuellenRaum(parsedCommand.gegenstand)
|
|
|
|
if person != None:
|
|
self.world.printText(f'npc-{person.id}')
|
|
else:
|
|
self.setFehler(f'{parsedCommand.gegenstand} ist nicht im Raum.')
|
|
|
|
def hilfe(self,parsedCommand):
|
|
if parsedCommand.gegenstand == 'befehle':
|
|
self.world.printBefehle()
|
|
else:
|
|
self.world.printText('hilfe')
|
|
|
|
def geheNachItem(parsedCommand):
|
|
item = self.world.findItemInAktuellerRaum(parsedCommand.gegenstand)
|
|
|
|
if item == None:
|
|
self.setFehler('Das gibts hier nicht.')
|
|
return
|
|
if self.isItemAndAktRaum(item, self.world.ITEM_LEITER, self.world.RAUM_ESSZIMMER):
|
|
self.rauf()
|
|
else:
|
|
self.setFehler('Das gibt\'s hier nicht.')
|
|
|
|
def gehe(self,parsedCommand):
|
|
richtung = parsedCommand.gegenstand.lower()
|
|
logging.debug("gehe nach " + richtung)
|
|
|
|
if richtung == 'nord':
|
|
self.geheNach(richtung)
|
|
elif richtung == 'süd':
|
|
self.geheNach(richtung)
|
|
elif richtung == 'west':
|
|
self.geheNach(richtung)
|
|
elif richtung == 'ost':
|
|
self.geheNach(richtung)
|
|
elif richtung == 'rauf':
|
|
self.rauf()
|
|
else:
|
|
self.geheNachItem(parsedCommand)
|
|
|
|
def gib(self, parsedCommand):
|
|
item = self.world.findItemImInventar(parsedCommand.gegenstand)
|
|
|
|
if item == None:
|
|
self.setFehler('Das besitzt du nicht')
|
|
return
|
|
|
|
if item.id == self.world.ITEM_JACKE:
|
|
zwerg = self.world.findPersonImAktuellenRaumById(self.world.PERSON_ZWERG)
|
|
|
|
logging.debug(f'gib() Zwerg {zwerg}')
|
|
|
|
if zwerg != None:
|
|
schachtel = self.world.findItemById(self.world.ITEM_SCHACHTEL)
|
|
self.setFehler('Der Zwerg zieht sich die Jacke an, grinst erleichtert und verschwindet.')
|
|
del self.world.aktuellerRaum.personen[zwerg.id]
|
|
self.macheItemSichtbar(schachtel)
|
|
|
|
|
|
def geheNach(self,richtung):
|
|
logging.debug(f'Richtung {richtung}')
|
|
raum = self.world.aktuellerRaum
|
|
|
|
if raum.ausgaenge[richtung]:
|
|
ausgang = raum.sucheRaumAusgang(richtung)
|
|
logging.debug(f'gefundener Ausgang: {ausgang}')
|
|
if ausgang != None:
|
|
raum = self.world.sucheRaum(ausgang)
|
|
else:
|
|
logging.warn('Keine AusgandId gefunde')
|
|
self.setFehler("In diese Richtung gibt's keine Ausgang!")
|
|
|
|
if raum != None:
|
|
self.wechsleRaum(raum)
|
|
else:
|
|
logging.debug('Kein Raum zur AusgangId')
|
|
self.setFehler("In diese Richtung gibt's keine Ausgang!")
|
|
else:
|
|
self.setFehler("In diese Richtung kannst du nicht gehen")
|
|
|
|
def nord(self):
|
|
self.geheNach(self.world.NORD)
|
|
|
|
def sued(self):
|
|
self.geheNach(self.world.SUED)
|
|
|
|
def west(self):
|
|
self.geheNach(self.world.WEST)
|
|
|
|
def ost(self):
|
|
self.geheNach(self.world.OST)
|
|
|
|
def rauf(self):
|
|
self.geheNach(self.world.RAUF)
|
|
|
|
def runter(self):
|
|
self.geheNach(self.world.RUNTER)
|
|
|
|
def about(self):
|
|
print("Tomb Version " + self.world.VERSION)
|
|
self.world.waitForCR
|
|
|
|
def raumaction(self):
|
|
raumid = self.world.aktuellerRaum.id
|
|
|
|
print('Raumaction für Raum: ' + raumid)
|
|
|
|
|