Das deutsche Python-Forum

Code: Alles auswählen

class Keys:
    def __init__(self):
        self.list = dict()
        
    def add(self, key):
        self.list[key.char] = key

    def generatetext(self):
        listkeys = self.list.keys()
        listkeys.sort()
        out = ""
        for listkey in listkeys:
            if self.list[listkey].visible:
                out = out + self.list[listkey].char + "." + "\t\t" + self.list[listkey].chartext + "\n"
        return out


class Key:
    def __init__(self, char, chartext, do, visible):
        self.char = char
        self.chartext = chartext
        self.do = do
        self.visible = visible

class Screens:
    def __init__(self):
        self.list = dict()

    def add(self, screen):
        self.list[screen.name] = screen

class Screen:
    def __init__(self, name, text, keys):
        self.name = name
        self.text = text
        self.keys = keys


import wx
import wx.richtext
class Engine(wx.Frame):
    def __init__(self, title = "Test", GameScreens = None, GameStart = None):
        self.app = wx.App()
        wx.Frame.__init__(self, None, -1, title, style= wx.SYSTEM_MENU | wx.CAPTION | wx.CLOSE_BOX, size=(745,425))
        self.title = title
        self.panel = wx.Panel(self, -1)
        self.output = wx.richtext.RichTextCtrl(self.panel, wx.ID_ANY, value="", size=(740,420), style = wx.TE_READONLY)
        self.output.SetEditable = False
        self.output.BeginTextColour(wx.Colour(255,255,0))
        self.output.BeginFontSize(11)
        self.output.BeginBold()
        self.output.SetBackgroundColour(wx.Colour(0,0,128))
        self.Centre()
        self.output.EnableScrolling(False, False)
        self.Show(True)
        self.Bind(wx.EVT_CHAR, self.onCharEvent)
        self.Screen = None
        self.Screens = Screens()
        self.output.Enabled = False
        if Screen is None:
            #Default Screens
            default = Screens()
            b = Keys()
            b.add(Key("ALL", "No Keys pressent", ("load", "test"), False))
            b.add(Key("1", "Testscreen", ("load", "test"), True))
            a = Screen("default", "<(255,0,0)>Engine loaded </(255,0,0)>\nDefault Screen loaded!", b)
            default.add(a)
                
            #Test Screen
            b = Keys()
            c = Key("B", "Back", ("load", "default"), True)
            b.add(c)
            a = Screen("test", "Test loaded!", b)
            default.add(a)

            self.Screens = default
            self.load("default")
        else:
            self.Screens = GameScreens
            self.load(GameStart)
        self.app.MainLoop()

    def onCharEvent(self, event):
        try:
            a = chr(event.GetKeyCode())
        except ValueError:
            a = ""
        try:
            key = self.Screen.keys.list[a]
        except KeyError:
            try:
                key = self.Screen.keys.list['ALL']
            except KeyError:
                return False
        if key.do[0] == "load":
            self.load(key.do[1])
        if key.do[0] == "quit":
            pass
            # hier quit rein!

    def load(self, screenname):
        self.Screen = self.Screens.list[screenname]
        self.output.Clear()
        #text = self.Screen.text
        text = []
        text.extend(parser(self.Screen.text))
        text.extend("\n\n")
        text.extend(parser(self.Screen.keys.generatetext()))
        for l in text:
            if l == "center":
                self.output.BeginAlignment(2) 
            elif l == "/center":
                self.output.EndAlignment()
            elif l == "!left":
                self.output.BeginAlignment(1) 
            elif l == "!/left":
                self.output.EndAlignment()
            elif l == "!right":
                self.output.BeginAlignment(3) 
            elif l == "!/right":
                self.output.EndAlignment() 
            elif l[:1] == "(" and l[-1:] == ")":
                self.output.BeginTextColour(colourparser(l[1:-1]))
            elif l[:2] == "/(" and l[-1:] == ")":
                self.output.EndTextColour()
            else:
                self.output.WriteText(l)

        #self.output.WriteText(self.Screen.text)
        #self.output.WriteText("\n \n")
        #self.output.WriteText(self.Screen.keys.generatetext())
                
def parser(string):
    out = []
    stringlist = string.split("<")
    for k in stringlist:
        out.extend(k.split(">"))
    return out

def colourparser(string):
    stringlist = string.split(",")
    return wx.Colour(int(stringlist[0]),int(stringlist[1]),int(stringlist[2]))

Code: Alles auswählen

    def __str__(self):
        result = list()
        for _char, key in sorted(self.char2key.iteritems()):
            if key.visible:
                result.append('%s.\t\t%s' % (key.char, key.chartext))
        return '\n'.join(result)

Code: Alles auswählen

<adventure version="0.1" title="Testadventure / Zweiraumwohnung" author="bj">
  <screens>
    <screen id="Startbildschirm">
      <description>
        <center>Einstiegs-Bildschirm</center>
        Hier geht das Spiel los.  Im Westen befindet sich eine Tür.
        <color value="red">Viel Spass!</color>
        <right>bj, 2010-09-22</right>
      </description>
      <keys>
        <key char="q" text="Beenden" command="quit" />
        <key char="w"
             text="Gehe durch die Tür"
             command="goto"
             target="Leerer Raum" />
      </keys>
    </screen>
    <screen id="Leerer Raum">
      <description>
        Ein fensterloser, leerer Raum mit einer Tür im Osten.
      </description>
      <keys>
        <key char="e"
             text="Gehe durch die Tür"
             command="goto"
             target="Startbildschirm" />
      </keys>
    </screen>
  </screens>
</adventure>

Code: Alles auswählen

        commands = {
            'center': partial(self.output.BeginAlignment, 2),
            '/center': self.output.EndAlignement,
            'left': partial(self.output.BeginAlignment, 1),
            '/left': self.output.EndAlignement,
            'right': partial(self.output.BeginAlignment, 3),
            '/right': self.output.EndAlignement,
        }
        
        # ...
        
        for segment in self.screen.text:
            command = segment.split(None, 1)[0]
            try:
                commands[command]()
            except:
                self.output.WriteText(segment)

Code: Alles auswählen

class Screen(object):

    # ...
    
    def display(self, display):
        display.set_title(self.name)
        for segment in self.text:
            parts = segment.split(None, 1)
            command = parts[0]
            arguments = '' if len(parts) == 1 else parts[1]
            if command in self.commands:
                if command.startswith('/'):
                    func_name = 'end_' + command[1:]
                else:
                    func_name = 'start_' + command
                getattr(display, func_name)(arguments)
            else:
                display.write_text(segment)

Code: Alles auswählen

screens = {
  "Startbildschirm": Screen(title="Einstiegsbildschirm", description="...", keys=[
    Key(char="q", text="Beenden", command="quit"),
    Key(char="w", text="Gehe durch die Tür", command="go", target="Leerer Raum")
  ]),
  "Leerer Raum": Screen(description="...", keys=[
    Key(char="e", "Gehe durch die Tür", command="go", target="Startbildschirm")
  ])
}

Code: Alles auswählen

Key(char="e", "Gehe durch die Tür", ..., condition=lambda state:state.has("Türschlüssel"))
Key(char="t", "Nimm Schlüssel", ..., condition=lambda state:state.screen.has("Türschlüssel"))

Code: Alles auswählen

#ending

keys = Keys()
keys.add(Key("1", "Ende", ("load", "quit"), True))
text='''Unten angekommen siehst du wie der Fön in einer unglaublichen Geschwindigkeit
davon fliegt... Erleichtert siehst du hinterher, bis der Fön die Atmosphäre
verlassen hat... Du wirst mit einer riesen Party als Welt-retter empfangen
und gefeiert !
DU HAST ES GESCHAFFT !
CONGRATULATIONS !'''
keyscreen = Screen("ending", text, keys)
S.add(keyscreen)
#letzter Raum in Spiel, nur um zu sehen wie das ganze aussieht
#S is übrigens von der Klasse Screens

#hier der Versuch des Exports
from xml.etree import ElementTree as ET
root_element = ET.Element("Quest - 1")
#erzeuge Root Element
Rooms = ET.SubElement(root_element, "Rooms")
#Erzeuge Subelemente (nenne Screens in Rooms um btw)
for screen in S.list:
    screen = S[screen]
    #iteriere über die Keys im dict, brauche aber die dazugehörigen Werte
    Room = ET.Element("Room", name=screen.name, text=screen.text)
    #Erzeuge ein Raumelemente das alles wichtige über einen screen enthalten soll.
    Options = ET.SubElement(Room, "Options")
    #keys werden zu optins umbenannt
    for lkey in screen.keys.list:
        lkey = screen.keys.list[lkey]
        #selbes spiel wie oben
        Option = ET.Element("Option", key=lkey.char, text=lkey.chartext, command=lkey.do[0], room=lkey.do[1], visible=lkey.visible)
        Options.append(Option)
    Rooms.append(Room)
#bis hier bekomme ich auch noch keinen Fehler
print ET.tostring(root_element)
#macht dann alles kaputt.
#Dachte da würde so was rauskommen wie bei BlackJack aber ich bekomme nur Seitenweise #Fehler angezeigt.

Code: Alles auswählen

<root><key>Hallo</key></root>

Code: Alles auswählen

<root>
<key>Hallo</key>
</root>

Code: Alles auswählen

Constant Story "INSIDE HACK";
Constant Headline "^An Inform sample adventure.^";

Include "Parser";
Include "VerbLib";

[ Initialise;
  location = Router;
];

Include "Grammar";

Object Router "Router NP-462",
  has light,
  with
    description
        "This little data interchange is run-down, shabby, and
        rather sad. You can't see any traffic -- besides yourself --
        and cobwebs of noisy static hang in the dusty corners. The
        meat-side that this router serves must be a bare hallway,
        almost no hardware.^^
        A broad network connection leads east, and a serial line runs
        south. The network connection is barred by a fierce-eyed access
        controller.",
    s_to Scanner;

Object Scanner "Scanner South-9",
  has light,
  with
    description
        "The firmware here is tight and clean; this device, at
        least, is well-maintained. You can see image-analysis nets
        strung in their neat rows around the sensor fountain which
        dominates this space. The only exit is the serial line to the
        north.",
    n_to Router;

Code: Alles auswählen

from xml.etree import ElementTree as ET
from functools import partial
import sys

class Engine:
    def __init__(self, gamefile = "./page.xhtml"):
        temp = ET.parse(gamefile)
        
        self.gamedata = temp.getroot()
        self.Rooms = self.gamedata.find("Rooms")
        startroom = self.gamedata.find("Settings").attrib["startroom"]
        self.title = self.gamedata.find("Settings").attrib["titel"]
        self.actualroom = self.name2room(startroom)
        self.lastRoom = None
        self.commands = dict()
        self.commands["load"] = partial(self.load)
        self.commands["quit"] = partial(self.quit)
        self.commands["exit"] = partial(self.exit)
        self.commands["lastRoom"] = partial(self.load, self.lastRoom)

    def option(self, key):
        options = self.actualroom.find("Options")
        temp = None
        for option in options:
            if option.attrib["key"] == key:
                temp = option
                break
            if option.attrib["key"] == "ALL" and not key == "\n":
                print "Mu", key, "ha"
                temp = option

        if temp is None:
            return None
        command = temp.attrib["command"]
        arg = []
        i = 0
        try:
            while 1:
                i+=1
                arg.append(temp.attrib["arg" + str(i)])
        except:
            pass
        i = len(arg)
        #this is stupid but cant figure out how to do it!
        if i == 0:
            return self.commands[command]()
        if i == 1:
            return self.commands[command](arg[0])
        if i == 2:
            return self.commands[command](arg[1], arg[2])

        
        
        
    def exit(self):
        self.destroy()
        return None

    def quit(self, lastRoom = None):
        temp = self.name2room("quit")
        if temp is None:
            self.exit()
        self.load("quit")
        self.lastRoom = lastRoom

    def load(self, room):
        self.actualroom = self.name2room(room)
        return self.name2room(room)
        
        
        

    def name2room(self, name):
        return self.Rooms.find(name)
    

        


class Screen:
    def __init__(self, engine):
        self.engine = engine
        self.load(self.engine.actualroom)
        while 1:
            try:
                temp = sys.stdin.read(1)
            except IOError: temp = None
            k = self.engine.option(temp)
            self.load(self.engine.actualroom)
            temp = None



    def load(self, Room):
        if Room is None:
            return None
        print Room.find("Text").text
        print "\n"
        Options = Room.find("Options")
        for option in Options:
            if option.attrib["visible"] == "True":
                print option.attrib["key"], "\t", option.attrib["text"]
    



import aes
if __name__ == '__main__':
    Screen(Engine())

Code: Alles auswählen

<Room>
<Text>
<center> Hallo</center><rot>, hier ist der Mond!</rot>
</Text>
</Room>