X-Git-Url: https://git.yukkurigames.com/?p=python-bulletml.git;a=blobdiff_plain;f=bulletml%2Fparser.py;h=10b789ae83a801bc0dc538afc183f8194240f00c;hp=933be80847c0b31c186173b82c2ee418712f93a2;hb=70d25195d561d8b5d3126c6bbac0ecad2a502f06;hpb=9b5018cadee8ae1f5599b20095f47e4fa8b0bcc0 diff --git a/bulletml/parser.py b/bulletml/parser.py index 933be80..10b789a 100644 --- a/bulletml/parser.py +++ b/bulletml/parser.py @@ -1,20 +1,32 @@ """BulletML parser. -http://www.asahi-net.or.jp/~cs8k-cyu/bulletml/index_e.html +This is based on the format described at +http://www.asahi-net.or.jp/~cs8k-cyu/bulletml/bulletml_ref_e.html. + +Unless you are adding support for new tags, the only class you should +care about in here is BulletML. """ from __future__ import division +import math + from xml.etree.ElementTree import ElementTree try: - from cStringIO import StringIO + from io import StringIO except ImportError: - from StringIO import StringIO + try: + from cStringIO import StringIO + except ImportError: + from StringIO import StringIO from bulletml.errors import Error from bulletml.expr import NumberDef, INumberDef + +__all_ = ["ParseError", "BulletML"] + class ParseError(Error): """Raised when an error occurs parsing the XML structure.""" pass @@ -28,12 +40,15 @@ def realtag(element): class ParamList(object): """List of parameter definitions.""" - def __init__(self, element): - self.params = [] - if element: - for subelem in element: - if realtag(subelem) == "param": - self.params.append(NumberDef(subelem.text)) + + def __init__(self, params=()): + self.params = list(params) + + @classmethod + def FromElement(cls, doc, element): + """Construct using an ElementTree-style element.""" + return cls([NumberDef(subelem.text) for subelem in element + if realtag(subelem) == "param"]) def __call__(self, params, rank): return [param(params, rank) for param in self.params] @@ -44,12 +59,27 @@ class ParamList(object): class Direction(object): """Raw direction value.""" - def __init__(self, doc, element, type="absolute"): - self.type = element.get("type", type) - self.value = NumberDef(element.text) + VALID_TYPES = ["relative", "absolute", "aim", "sequence"] + + def __init__(self, type, value): + if type not in self.VALID_TYPES: + raise ValueError("invalid type %r" % type) + self.type = type + self.value = value + + def __getstate__(self): + return dict(type=self.type, value=self.value.expr) + + def __setstate__(self, state): + self.__init__(state["type"], NumberDef(state["value"])) + + @classmethod + def FromElement(cls, doc, element, default="absolute"): + """Construct using an ElementTree-style element.""" + return cls(element.get("type", default), NumberDef(element.text)) def __call__(self, params, rank): - return (self.value(params, rank), self.type) + return (math.radians(self.value(params, rank)), self.type) def __repr__(self): return "%s(%r, type=%r)" % ( @@ -58,17 +88,32 @@ class Direction(object): class ChangeDirection(object): """Direction change over time.""" - def __init__(self, doc, element): + def __init__(self, term, direction): + self.term = term + self.direction = direction + + def __getstate__(self): + return dict(frames=self.term.expr, + type=self.direction.type, + value=self.direction.value.expr) + + def __setstate__(self, state): + self.__init__(INumberDef(state["frames"]), + Direction(state["type"], NumberDef(state["value"]))) + + @classmethod + def FromElement(cls, doc, element): + """Construct using an ElementTree-style element.""" for subelem in element.getchildren(): tag = realtag(subelem) if tag == "direction": - self.direction = Direction(doc, subelem) + direction = Direction.FromElement(doc, subelem) elif tag == "term": - self.term = INumberDef(subelem.text) + term = INumberDef(subelem.text) try: - self.term, self.direction - except AttributeError: - raise ParseError + return cls(term, direction) + except UnboundLocalError as exc: + raise ParseError(str(exc)) def __call__(self, params, rank): return self.term(params, rank), self.direction(params, rank) @@ -80,9 +125,24 @@ class ChangeDirection(object): class Speed(object): """Raw speed value.""" - def __init__(self, doc, element, type="absolute"): - self.type = element.get("type", type) - self.value = NumberDef(element.text) + VALID_TYPES = ["relative", "absolute", "sequence"] + + def __init__(self, type, value): + if type not in self.VALID_TYPES: + raise ValueError("invalid type %r" % type) + self.type = type + self.value = value + + def __getstate__(self): + return dict(type=self.type, value=self.value.expr) + + def __setstate__(self, state): + self.__init__(state["type"], NumberDef(state["value"])) + + @classmethod + def FromElement(cls, doc, element): + """Construct using an ElementTree-style element.""" + return cls(element.get("type", "absolute"), NumberDef(element.text)) def __call__(self, params, rank): return (self.value(params, rank), self.type) @@ -93,17 +153,32 @@ class Speed(object): class ChangeSpeed(object): """Speed change over time.""" - def __init__(self, doc, element): + def __init__(self, term, speed): + self.term = term + self.speed = speed + + def __getstate__(self): + return dict(frames=self.term.expr, + type=self.speed.type, + value=self.speed.value.expr) + + def __setstate__(self, state): + self.__init__(INumberDef(state["frames"]), + Speed(state["type"], NumberDef(state["value"]))) + + @classmethod + def FromElement(cls, doc, element): + """Construct using an ElementTree-style element.""" for subelem in element.getchildren(): tag = realtag(subelem) if tag == "speed": - self.speed = Speed(doc, subelem) + speed = Speed.FromElement(doc, subelem) elif tag == "term": - self.term = INumberDef(subelem.text) + term = INumberDef(subelem.text) try: - self.term, self.speed - except AttributeError: - raise ParseError + return cls(term, speed) + except UnboundLocalError as exc: + raise ParseError(str(exc)) def __call__(self, params, rank): return self.term(params, rank), self.speed(params, rank) @@ -114,8 +189,20 @@ class ChangeSpeed(object): class Wait(object): """Wait for some frames.""" - def __init__(self, doc, element): - self.frames = INumberDef(element.text) + + def __init__(self, frames): + self.frames = frames + + def __getstate__(self): + return dict(frames=self.frames.expr) + + def __setstate__(self, state): + self.__init__(INumberDef(state["frames"])) + + @classmethod + def FromElement(cls, doc, element): + """Construct using an ElementTree-style element.""" + return cls(INumberDef(element.text)) def __call__(self, params, rank): return self.frames(params, rank) @@ -123,31 +210,82 @@ class Wait(object): def __repr__(self): return "%s(%r)" % (type(self).__name__, self.frames) +class Tag(object): + """Set a bullet tag.""" + + def __init__(self, tag): + self.tag = tag + + def __getstate__(self): + return dict(tag=self.tag) + + def __setstate__(self, state): + self.__init__(state["tag"]) + + @classmethod + def FromElement(cls, doc, element): + """Construct using an ElementTree-style element.""" + return cls(element.text) + +class Untag(object): + """Unset a bullet tag.""" + + def __init__(self, tag): + self.tag = tag + + def __getstate__(self): + return dict(tag=self.tag) + + def __setstate__(self, state): + self.__init__(state["tag"]) + + @classmethod + def FromElement(cls, doc, element): + """Construct using an ElementTree-style element.""" + return cls(element.text) + class Vanish(object): """Make the owner disappear.""" - def __init__(self, doc, element): + + def __init__(self): pass + @classmethod + def FromElement(cls, doc, element): + """Construct using an ElementTree-style element.""" + return cls() + def __repr__(self): return "%s()" % (type(self).__name__) class Repeat(object): """Repeat an action definition.""" - def __init__(self, doc, element): + def __init__(self, times, action): + self.times = times + self.action = action + + def __getstate__(self): + return dict(times=self.times.expr, action=self.action) + + def __setstate__(self, state): + self.__init__(INumberDef(state["times"]), state["action"]) + + @classmethod + def FromElement(cls, doc, element): + """Construct using an ElementTree-style element.""" for subelem in element.getchildren(): tag = realtag(subelem) if tag == "times": - self.times = INumberDef(subelem.text) + times = INumberDef(subelem.text) elif tag == "action": - self.action = ActionDef(doc, subelem) + action = ActionDef.FromElement(doc, subelem) elif tag == "actionRef": - self.action = ActionRef(doc, subelem) - + action = ActionRef.FromElement(doc, subelem) try: - self.times, self.action - except AttributeError: - raise ParseError + return cls(times, action) + except UnboundLocalError as exc: + raise ParseError(str(exc)) def __call__(self, params, rank): return self.times(params, rank), self.action(params, rank) @@ -161,18 +299,40 @@ class Accel(object): horizontal = None vertical = None - def __init__(self, doc, element): + def __init__(self, term, horizontal=None, vertical=None): + self.term = term + self.horizontal = horizontal + self.vertical = vertical + + def __getstate__(self): + state = dict(frames=self.term.expr) + if self.horizontal: + state["horizontal"] = self.horizontal + if self.vertical: + state["vertical"] = self.vertical + return state + + def __setstate__(self, state): + self.__init__(INumberDef(state["frames"]), state.get("horizontal"), + state.get("vertical")) + + @classmethod + def FromElement(cls, doc, element): + """Construct using an ElementTree-style element.""" + horizontal = None + vertical = None + for subelem in element.getchildren(): tag = realtag(subelem) if tag == "term": - self.term = INumberDef(subelem.text) + term = INumberDef(subelem.text) elif tag == "horizontal": - self.horizontal = Speed(doc, subelem) + horizontal = Speed.FromElement(doc, subelem) elif tag == "vertical": - self.vertical = Speed(doc, subelem) + vertical = Speed.FromElement(doc, subelem) try: - self.term + return cls(term, horizontal, vertical) except AttributeError: raise ParseError @@ -192,19 +352,43 @@ class BulletDef(object): direction = None speed = None - def __init__(self, doc, element): - self.actions = [] - doc.bullets[element.get("label")] = self + def __init__(self, actions=[], direction=None, speed=None): + self.direction = direction + self.speed = speed + self.actions = list(actions) + + def __getstate__(self): + state = dict() + if self.direction: + state["direction"] = self.direction + if self.speed: + state["speed"] = self.speed + if self.actions: + state["actions"] = self.actions + return state + + def __setstate__(self, state): + self.__init__(**state) + + @classmethod + def FromElement(cls, doc, element): + """Construct using an ElementTree-style element.""" + actions = [] + speed = None + direction = None for subelem in element.getchildren(): tag = realtag(subelem) if tag == "direction": - self.direction = Direction(doc, subelem) + direction = Direction.FromElement(doc, subelem) elif tag == "speed": - self.speed = Speed(doc, subelem) + speed = Speed.FromElement(doc, subelem) elif tag == "action": - self.actions.append(ActionDef(doc, subelem)) + actions.append(ActionDef.FromElement(doc, subelem)) elif tag == "actionRef": - self.actions.append(ActionRef(doc, subelem)) + actions.append(ActionRef.FromElement(doc, subelem)) + dfn = cls(actions, direction, speed) + doc.bullets[element.get("label")] = dfn + return dfn def __call__(self, params, rank): actions = [action(params, rank) for action in self.actions] @@ -220,10 +404,27 @@ class BulletDef(object): class BulletRef(object): """Create a bullet by name with parameters.""" - def __init__(self, doc, element): - self.bullet = element.get("label") - self.params = ParamList(element) - doc._bullet_refs.append(self) + def __init__(self, bullet, params=None): + self.bullet = bullet + self.params = ParamList() if params is None else params + + def __getstate__(self): + state = dict(bullet=self.bullet) + if self.params.params: + state["params"] = [param.expr for param in self.params.params] + return state + + def __setstate__(self, state): + bullet = state["bullet"] + params = [NumberDef(param) for param in state.get("params", [])] + self.__init__(bullet, ParamList(params)) + + @classmethod + def FromElement(cls, doc, element): + """Construct using an ElementTree-style element.""" + bullet = cls(element.get("label"), ParamList.FromElement(doc, element)) + doc._bullet_refs.append(bullet) + return bullet def __call__(self, params, rank): return self.bullet(self.params(params, rank), rank) @@ -233,29 +434,41 @@ class BulletRef(object): type(self).__name__, self.params, self.bullet) class ActionDef(object): - """Action definition.""" + """Action definition. + + To support parsing new actions, add tags to + ActionDef.CONSTRUCTORS. It maps tag names to classes with a + FromElement classmethod, which take the BulletML instance and + ElementTree element as arguments. + """ + + # This is self-referential, so it's filled in later. + CONSTRUCTORS = dict() + + def __init__(self, actions): + self.actions = list(actions) - def __init__(self, doc, element): - doc.actions[element.get("label")] = self - self.actions = [] + def __getstate__(self): + return dict(actions=self.actions) + + def __setstate__(self, state): + self.__init__(state["actions"]) + + @classmethod + def FromElement(cls, doc, element): + """Construct using an ElementTree-style element.""" + actions = [] for subelem in element.getchildren(): tag = realtag(subelem) try: - ctr = dict( - repeat=Repeat, - fire=FireDef, - fireRef=FireRef, - changeSpeed=ChangeSpeed, - changeDirection=ChangeDirection, - accel=Accel, - wait=Wait, - vanish=Vanish, - action=ActionDef, - actionRef=ActionRef)[tag] + ctr = cls.CONSTRUCTORS[tag] except KeyError: continue else: - self.actions.append(ctr(doc, subelem)) + actions.append(ctr.FromElement(doc, subelem)) + dfn = cls(actions) + doc.actions[element.get("label")] = dfn + return dfn def __call__(self, params, rank): return self.actions, params @@ -266,10 +479,27 @@ class ActionDef(object): class ActionRef(object): """Run an action by name with parameters.""" - def __init__(self, doc, element): - self.action = element.get("label") - self.params = ParamList(element) - doc._action_refs.append(self) + def __init__(self, action, params=None): + self.action = action + self.params = params or ParamList() + + def __getstate__(self): + state = dict(action=self.action) + if self.params.params: + state["params"] = [param.expr for param in self.params.params] + return state + + def __setstate__(self, state): + action = state["action"] + params = [NumberDef(param) for param in state.get("params", [])] + self.__init__(action, ParamList(params)) + + @classmethod + def FromElement(cls, doc, element): + """Construct using an ElementTree-style element.""" + action = cls(element.get("label"), ParamList.FromElement(doc, element)) + doc._action_refs.append(action) + return action def __call__(self, params, rank): return self.action(self.params(params, rank), rank) @@ -278,28 +508,103 @@ class ActionRef(object): return "%s(params=%r, action=%r)" % ( type(self).__name__, self.params, self.action) +class Offset(object): + """Provide an offset to a bullet's initial position.""" + + VALID_TYPES = ["relative", "absolute"] + + def __init__(self, type, x, y): + if type not in self.VALID_TYPES: + raise ValueError("invalid type %r" % type) + self.type = type + self.x = x + self.y = y + + def __getstate__(self): + state = dict(type=self.type) + if self.x: + state["x"] = self.x.expr + if self.y: + state["y"] = self.y.expr + return state + + def __setstate__(self, state): + self.__init__(state["type"], state.get("x"), state.get("y")) + + @classmethod + def FromElement(cls, doc, element): + """Construct using an ElementTree-style element.""" + type = element.get("type", "relative") + x = None + y = None + for subelem in element: + tag = realtag(subelem) + if tag == "x": + x = NumberDef(subelem.text) + elif tag == "y": + y = NumberDef(subelem.text) + return cls(type, x, y) + + def __call__(self, params, rank): + return (self.x(params, rank) if self.x else 0, + self.y(params, rank) if self.y else 0) + class FireDef(object): """Fire definition (creates a bullet).""" - direction = None - speed = None + def __init__(self, bullet, direction=None, speed=None, offset=None): + self.bullet = bullet + self.direction = direction + self.speed = speed + self.offset = offset + + def __getstate__(self): + try: + params = self.bullet.params + except AttributeError: + state = dict(bullet=self.bullet) + else: + if params.params: + state = dict(bullet=self.bullet) + else: + state = dict(bullet=self.bullet.bullet) + if self.direction: + state["direction"] = self.direction + if self.speed: + state["speed"] = self.speed + if self.offset: + state["offset"] = self.offset + return state + + def __setstate__(self, state): + self.__init__(**state) + + @classmethod + def FromElement(cls, doc, element): + """Construct using an ElementTree-style element.""" + direction = None + speed = None + offset = None - def __init__(self, doc, element): - doc.fires[element.get("label")] = self for subelem in element.getchildren(): tag = realtag(subelem) if tag == "direction": - self.direction = Direction(doc, subelem, "aim") + direction = Direction.FromElement(doc, subelem, "aim") elif tag == "speed": - self.speed = Speed(doc, subelem) + speed = Speed.FromElement(doc, subelem) elif tag == "bullet": - self.bullet = BulletDef(doc, subelem) + bullet = BulletDef.FromElement(doc, subelem) elif tag == "bulletRef": - self.bullet = BulletRef(doc, subelem) + bullet = BulletRef.FromElement(doc, subelem) + elif tag == "offset": + offset = Offset.FromElement(doc, subelem) try: - self.bullet - except AttributeError: - raise ParseError + fire = cls(bullet, direction, speed, offset) + except UnboundLocalError as exc: + raise ParseError(str(exc)) + else: + doc.fires[element.get("label")] = fire + return fire def __call__(self, params, rank): direction, speed, actions = self.bullet(params, rank) @@ -307,7 +612,7 @@ class FireDef(object): direction = self.direction(params, rank) if self.speed: speed = self.speed(params, rank) - return direction, speed, actions + return direction, speed, actions, self.offset def __repr__(self): return "%s(direction=%r, speed=%r, bullet=%r)" % ( @@ -316,13 +621,29 @@ class FireDef(object): class FireRef(object): """Fire a bullet by name with parameters.""" - def __init__(self, doc, element): - self.fire = element.get("label") - self.params = ParamList(element) - doc._fire_refs.append(self) + def __init__(self, fire, params=None): + self.fire = fire + self.params = params or ParamList() + + def __getstate__(self): + state = dict(fire=self.fire) + if self.params.params: + state["params"] = [param.expr for param in self.params.params] + return state + + def __setstate__(self, state): + fire = state["fire"] + params = [NumberDef(param) for param in state.get("params", [])] + self.__init__(fire, ParamList(params)) + + @classmethod + def FromElement(cls, doc, element): + """Construct using an ElementTree-style element.""" + fired = cls(element.get("label"), ParamList.FromElement(doc, element)) + doc._fire_refs.append(fired) + return fired def __call__(self, params, rank): - """Generate a Bullet from the FireDef and params.""" return self.fire(self.params(params, rank), rank) def __repr__(self): @@ -334,6 +655,12 @@ class BulletML(object): A BulletML document is a collection of bullets, actions, and firings, as well as a base game type. + + You can add tags to the BulletML.CONSTRUCTORS dictionary to extend + its parsing. It maps tag names to classes with a FromElement + classmethod, which take the BulletML instance and ElementTree + element as arguments. + """ CONSTRUCTORS = dict( @@ -342,27 +669,37 @@ class BulletML(object): fire=FireDef, ) - def __init__(self, source): - self.bullets = {} - self.actions = {} - self.fires = {} + def __init__(self, type="none", bullets=None, fires=None, actions=None): + self.type = type + self.bullets = {} if bullets is None else bullets + self.actions = {} if actions is None else actions + self.fires = {} if fires is None else fires - self._bullet_refs = [] - self._action_refs = [] - self._fire_refs = [] + def __getstate__(self): + return dict(type=self.type, actions=self.actions) - if isinstance(source, (str, unicode)): + def __setstate__(self, state): + self.__init__(state["type"], actions=state.get("actions")) + + @classmethod + def FromXML(cls, source): + """Return a BulletML instance based on XML.""" + if not hasattr(source, 'read'): source = StringIO(source) tree = ElementTree() root = tree.parse(source) - self.type = root.get("type", "none") + self = cls(type=root.get("type", "none")) + + self._bullet_refs = [] + self._action_refs = [] + self._fire_refs = [] for element in root.getchildren(): tag = realtag(element) if tag in self.CONSTRUCTORS: - self.CONSTRUCTORS[tag](self, element) + self.CONSTRUCTORS[tag].FromElement(self, element) try: for ref in self._bullet_refs: @@ -378,13 +715,66 @@ class BulletML(object): del(self._action_refs) del(self._fire_refs) + self.bullets.pop(None, None) + self.actions.pop(None, None) + self.fires.pop(None, None) + + return self + + @classmethod + def FromYAML(cls, source): + """Create a BulletML instance based on YAML.""" + + # Late import to avoid a circular dependency. + try: + import bulletml.bulletyaml + import yaml + except ImportError: + raise ParseError("PyYAML is not available") + else: + try: + return yaml.load(source) + except Exception, exc: + raise ParseError(str(exc)) + + @classmethod + def FromDocument(cls, source): + """Create a BulletML instance based on a seekable file or string. + + This attempts to autodetect if the stream is XML or YAML. + """ + if not hasattr(source, 'read'): + source = StringIO(source) + start = source.read(1) + source.seek(0) + if start == "<": + return cls.FromXML(source) + elif start == "!": + return cls.FromYAML(source) + else: + raise ParseError("unknown initial character %r" % start) + @property def top(self): """Get a list of all top-level actions.""" - return [dfn for name, dfn in self.actions.iteritems() + return [dfn for name, dfn in self.actions.items() if name and name.startswith("top")] def __repr__(self): return "%s(type=%r, bullets=%r, actions=%r, fires=%r)" % ( type(self).__name__, self.type, self.bullets, self.actions, self.fires) + +ActionDef.CONSTRUCTORS = dict( + repeat=Repeat, + fire=FireDef, + fireRef=FireRef, + changeSpeed=ChangeSpeed, + changeDirection=ChangeDirection, + accel=Accel, + wait=Wait, + vanish=Vanish, + tag=Tag, + untag=Untag, + action=ActionDef, + actionRef=ActionRef)