X-Git-Url: https://git.yukkurigames.com/?p=python-bulletml.git;a=blobdiff_plain;f=bulletml%2Fparser.py;h=a07cc2dab61f7cb74ba3bbeec0f91d83df08f744;hp=8bea044914be3701d9edf6d99bc447a7cea23fd6;hb=16023be19df43f8b8acc4671e0fabdeffb0e720a;hpb=a7295f6fd71242322dd1bad19a90462c188f153f diff --git a/bulletml/parser.py b/bulletml/parser.py index 8bea044..a07cc2d 100644 --- a/bulletml/parser.py +++ b/bulletml/parser.py @@ -1,10 +1,16 @@ """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: @@ -15,6 +21,8 @@ except ImportError: 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,18 +36,18 @@ 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): - new_params = [param(params, rank) for param in self.params] - while len(new_params) < len(params): - new_params.append(params[len(new_params)]) - return new_params + return [param(params, rank) for param in self.params] def __repr__(self): return "%s(%r)" % (type(self).__name__, self.params) @@ -47,12 +55,21 @@ 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 + + @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)" % ( @@ -61,17 +78,23 @@ 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 + + @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) @@ -83,9 +106,18 @@ 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 + + @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) @@ -96,17 +128,23 @@ 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 + + @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) @@ -117,8 +155,14 @@ 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 + + @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) @@ -128,29 +172,40 @@ class Wait(object): 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 + + @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) @@ -164,18 +219,28 @@ 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 + + @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 @@ -195,24 +260,33 @@ 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) + + @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, element)) + actions.append(ActionDef.FromElement(doc, subelem)) elif tag == "actionRef": - self.actions.append(ActionRef(doc, element)) + 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 = [] - for action in self.actions: - actions.append(action(params, rank)) + actions = [action(params, rank) for action in self.actions] return ( self.direction and self.direction(params, rank), self.speed and self.speed(params, rank), @@ -225,10 +299,16 @@ 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 = params or ParamList() + + @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) @@ -238,29 +318,35 @@ class BulletRef(object): type(self).__name__, self.params, self.bullet) class ActionDef(object): - """Action definition.""" + """Action definition. - def __init__(self, doc, element): - doc.actions[element.get("label")] = self - self.actions = [] + 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) + + @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 @@ -271,10 +357,16 @@ 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() + + @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) @@ -283,28 +375,71 @@ 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 + + @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 + + @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) + 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) @@ -312,7 +447,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)" % ( @@ -321,13 +456,18 @@ 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() + + @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): @@ -339,6 +479,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( @@ -347,27 +493,31 @@ class BulletML(object): fire=FireDef, ) - def __init__(self, source): - self.bullets = {} - self.actions = {} - self.fires = {} - - self._bullet_refs = [] - self._action_refs = [] - self._fire_refs = [] + 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 + @classmethod + def FromDocument(cls, source): + """Return a BulletML instance based on a string or file-like.""" if isinstance(source, (str, unicode)): 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: @@ -383,6 +533,12 @@ 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 + @property def top(self): """Get a list of all top-level actions.""" @@ -393,3 +549,15 @@ class BulletML(object): 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, + action=ActionDef, + actionRef=ActionRef)