X-Git-Url: https://git.yukkurigames.com/?p=python-bulletml.git;a=blobdiff_plain;f=bulletml%2Fimpl.py;h=f0e8964d806351cd9a2e876db194730da44bc4f9;hp=fcb3aab34ea99da4e76f2c6fdee77b1fd7ded9ce;hb=bf5ff1d116840e1330c80894132919ec515596e4;hpb=c1021a77feb2c7b29572f77d83f81840dd339d91 diff --git a/bulletml/impl.py b/bulletml/impl.py index fcb3aab..f0e8964 100644 --- a/bulletml/impl.py +++ b/bulletml/impl.py @@ -1,23 +1,29 @@ -"""BulletML implementation. - -http://www.asahi-net.or.jp/~cs8k-cyu/bulletml/index_e.html -""" +"""BulletML implementation.""" from __future__ import division -import math +from math import atan2, sin, cos from bulletml import parser -# TODO(jfw): This is very non-Pythonic, it's pretty much just the -# BulletML reference ActionImpl translated to Python. - -PI_2 = math.pi * 2 +__all__ = ["Action", "Bullet"] class Action(object): - """Running action implementation.""" + """Running action implementation. + + To implement new actions, add a new element/class pair to + parser.ActionDef.CONSTRUCTORS. It should support FromXML, + __getstate__, and __setstate__, and 5-ary __call__: + + def __call__(self, owner, action, params, rank, created) - def __init__(self, owner, parent, actions, params, rank, repeat=1): + Which will be called to execute it. This function should modify + owner, action, and created in-place, and return true if action + execution should stop for this bullet this frame. + + """ + + def __init__(self, parent, actions, params, rank, repeat=1): self.actions = actions self.parent = parent self.repeat = repeat @@ -29,12 +35,10 @@ class Action(object): self.aiming = False self.mx = 0 self.my = 0 - self.owner = owner self.accel_frames = 0 self.previous_fire_direction = 0 self.previous_fire_speed = 0 self.params = params - self.rank = rank self.pc = -1 self.finished = False if parent: @@ -44,6 +48,9 @@ class Action(object): return "%s(pc=%r, actions=%r)" % ( type(self).__name__, self.pc, self.actions) + def Child(self, actions, params, rank, repeat=1): + return type(self)(self, actions, params, rank, repeat) + def vanish(self): """End this action and its parents.""" if self.parent: @@ -64,36 +71,34 @@ class Action(object): self.previous_fire_direction = other.previous_fire_direction self.previous_fire_speed = other.previous_fire_speed - def step(self): + def step(self, owner, created): """Advance by one frame.""" - created = [] + s_params = self.params + rank = owner.rank if self.speed_frames > 0: self.speed_frames -= 1 - self.owner.speed += self.speed + owner.speed += self.speed if self.direction_frames > 0: - # The Noiz implementation was a little weird here, I think - # there was a bug in it that prevented it from working if - # the frame count was 1. I'm still not sure what the aim - # check is supposed to do, exactly. + # I'm still not sure what the aim check is supposed to do. self.direction_frames -= 1 if self.aiming and self.direction_frames <= 0: - self.owner.direction += self.owner.aim + owner.direction += owner.aim else: - self.owner.direction += self.direction + owner.direction += self.direction if self.accel_frames > 0: self.accel_frames -= 1 - self.owner.mx += self.mx - self.owner.my += self.my + owner.mx += self.mx + owner.my += self.my if self.pc is None: - return created + return if self.wait_frames > 0: self.wait_frames -= 1 - return created + return while True: self.pc += 1 @@ -107,130 +112,48 @@ class Action(object): self.finished = True if self.parent is not None: self.parent.copy_state(self) - self.owner.replace(self, self.parent) + owner.replace(self, self.parent) break else: self.pc = 0 action = self.actions[self.pc] - if isinstance(action, parser.Repeat): - repeat, (actions, params) = action(self.params, self.rank) - child = Action( - self.owner, self, actions, params, self.rank, repeat) - self.owner.replace(self, child) - created.extend(child.step()) - break - - elif isinstance(action, (parser.ActionDef, parser.ActionRef)): - actions, params = action(self.params, self.rank) - child = Action(self.owner, self, actions, params, self.rank) - self.owner.replace(self, child) - created.extend(child.step()) - break - - elif isinstance(action, (parser.FireDef, parser.FireRef)): - direction, speed, actions = action(self.params, self.rank) - if direction: - direction, type = direction - if type == "aim" or type is None: - direction += self.owner.aim - elif type == "sequence": - direction += self.previous_fire_direction - elif type == "relative": - direction += self.owner.direction - else: - direction = self.owner.aim - self.previous_fire_direction = direction - - if speed: - speed, type = speed - if type == "sequence": - speed += self.previous_fire_speed - elif type == "relative": - # The reference Noiz implementation uses - # prvFireSpeed here, but the standard is - # pretty clear -- "0 means that the direction - # of this fire and the direction of the bullet - # are the same". - speed += self.owner.speed - else: - speed = 1 - self.previous_fire_speed = speed - - bullet = Bullet(self.owner.x, self.owner.y, direction, speed, - self.owner.target, actions, self) - created.append(bullet) - - elif isinstance(action, parser.ChangeSpeed): - frames, (speed, type) = action(self.params, self.rank) - self.speed_frames = frames - if type == "sequence": - self.speed = speed - elif type == "relative": - self.speed = speed / frames - else: - self.speed = (speed - self.owner.speed) / frames - - elif isinstance(action, parser.ChangeDirection): - frames, (direction, type) = action(self.params, self.rank) - self.direction_frames = frames - self.aiming = False - if type == "sequence": - self.direction = direction - else: - if type == "absolute": - self.direction = ( - direction - self.owner.direction) % PI_2 - elif type == "relative": - self.direction = direction - else: - self.aiming = True - self.direction = ( - direction - + self.owner.aim - - self.owner.direction) % PI_2 - - if self.direction > math.pi: - self.direction -= PI_2 - if self.direction < -math.pi: - self.direction += PI_2 - self.direction /= self.direction_frames - - elif isinstance(action, parser.Accel): - frames, horizontal, vertical = action(self.params, self.rank) - self.accel_frames = frames - if horizontal: - mx, type = horizontal - if type == "sequence": - self.mx = mx - elif type == "absolute": - self.mx = (mx - self.owner.mx) / frames - elif type == "relative": - self.mx = mx / frames - if vertical: - my, type = vertical - if type == "sequence": - self.my = my - elif type == "absolute": - self.my = (my - self.owner.my) / frames - elif type == "relative": - self.my = my / frames - - elif isinstance(action, parser.Wait): - self.wait_frames = action(self.params, self.rank) + if isinstance(action, (parser.ActionDef, parser.ActionRef)): + actions, params = action(s_params, rank) + child = self.__class__(self, actions, params, rank) + owner.replace(self, child) + child.step(owner, created) break - elif isinstance(action, parser.Vanish): - self.owner.vanish() + elif action(owner, self, s_params, rank, created): break - return created - class Bullet(object): - """Simple bullet implementation.""" + """Simple bullet implementation. + + Attributes: + x, y - current X/Y position + px, py - X/Y position prior to the last step + mx, my - X/Y axis-oriented speed modifier ("acceleration") + direction - direction of movement, in radians + speed - speed of movement, in units per frame + target - object with .x and .y fields for "aim" directions + vanished - set to true by a action + rank - game difficulty, 0 to 1, default 0.5 + tags - string tags set by the running actions + appearance - string used to set bullet appearance + + Contructor Arguments: + x, y, direction, speed, target, rank, tags, appearance + - same as the above attributes + actions - internal action list + Action - custom Action constructor + + """ def __init__(self, x=0, y=0, direction=0, speed=0, target=None, - actions=(), parent=None, rank=None): + actions=(), rank=0.5, tags=(), appearance=None, + Action=Action): self.x = self.px = x self.y = self.py = y self.mx = 0 @@ -239,38 +162,56 @@ class Bullet(object): self.speed = speed self.vanished = False self.target = target - if rank is None: - rank = parent.rank if parent else 0.5 + self.rank = rank + self.tags = set(tags) + self.appearance = appearance # New bullets reset the parent hierarchy. - self._actions = [Action(self, None, action, params, rank) + self.actions = [Action(None, action, params, rank) for action, params in actions] + @classmethod + def FromDocument(cls, doc, x=0, y=0, direction=0, speed=0, target=None, + params=(), rank=0.5, Action=Action): + """Construct a new Bullet from a loaded BulletML document.""" + actions = [a(params, rank) for a in doc.actions] + return cls(x=x, y=y, direction=direction, speed=speed, + target=target, actions=actions, rank=rank, Action=Action) + def __repr__(self): return ("%s(%r, %r, accel=%r, direction=%r, speed=%r, " - "actions=%r, target=%r, vanished=%r)") % ( + "actions=%r, target=%r, appearance=vanished=%r)") % ( type(self).__name__, self.x, self.y, (self.mx, self.my), - self.direction, self.speed, self._actions, self.target, - self.vanished) + self.direction, self.speed, self.actions, self.target, + self.appearance, self.vanished) @property def aim(self): - """Angle to the target.""" - if self.target is None: - return self.direction + """Angle to the target, in radians. + + If the target does not exist or cannot be found, return 0. + """ + try: + target_x = self.target.x + target_y = self.target.y + except AttributeError: + return 0 else: - return math.atan2(self.target.x - self.x, self.y - self.target.y) + return atan2(target_x - self.x, target_y - self.y) @property def finished(self): """Check if this bullet is finished running. + A bullet is finished when it has vanished, and all its + actions have finished. + If this is true, the bullet should be removed from the screen. (You will probably want to cull it under other circumstances as well). """ if not self.vanished: return False - for action in self._actions: + for action in self.actions: if not action.finished: return False return True @@ -278,40 +219,38 @@ class Bullet(object): def vanish(self): """Vanish this bullet and stop all actions.""" self.vanished = True - for action in self._actions: + for action in self.actions: action.vanish() - self._actions = [] + self.actions = [] def replace(self, old, new): - """Replace an active action with another.""" + """Replace an active action with another. + + This is mostly used by actions internally to queue children. + """ try: - idx = self._actions.index(old) + idx = self.actions.index(old) except ValueError: pass else: - self._actions[idx] = new + self.actions[idx] = new def step(self): """Advance by one frame. - This updates the direction, speed, x, y, px, and py members, - and may set the vanished flag. + This updates the position and velocity, and may also set the + vanished flag. + + It returns any new bullets this bullet spawned during this step. """ created = [] - for action in self._actions: - created.extend(action.step()) + for action in self.actions: + action.step(self, created) self.px = self.x self.py = self.y - self.x += self.mx + math.sin(self.direction) * self.speed - self.y += self.my - math.cos(self.direction) * self.speed + self.x += self.mx + sin(self.direction) * self.speed + self.y += -self.my + cos(self.direction) * self.speed return created - - @classmethod - def FromDoc(cls, doc, params=(), x=0, y=0, speed=0, direction=0, - target=None, rank=0.5): - """Construct a bullet from top-level actions in a document.""" - actions = [act(params, rank) for act in doc.top] - return cls(x, y, direction, speed, target, actions, rank=rank)