import math
-from bulletml import parser, errors
+from bulletml import parser
# TODO(jfw): This is very non-Pythonic, it's pretty much just the
# BulletML reference ActionImpl translated to Python.
def __init__(self, owner, parent, actions, params, rank):
self.actions = actions
self.parent = parent
- self.repeat = 0
+ self.repeat = 1
self.wait_frames = 0
self.speed = 0
self.speed_frames = 0
self.params = params
self.rank = rank
self.pc = -1
+ self.finished = False
if parent:
self.copy_state(parent)
+ def __repr__(self):
+ return "%s(pc=%r, actions=%r)" % (
+ type(self).__name__, self.pc, self.actions)
+
def vanish(self):
+ """End this action and its parents."""
if self.parent:
self.parent.vanish()
- self.repeat = 0
self.pc = None
+ self.finished = True
def copy_state(self, other):
+ """Copy fire/movement state from other to self."""
self.direction_frames = other.direction_frames
self.direction = other.direction
self.aiming = other.aiming
self.previous_fire_speed = other.previous_fire_speed
def step(self):
+ """Advance by one frame."""
created = []
if self.speed_frames > 0:
self.speed_frames -= 1
self.owner.speed += self.speed
+
if self.direction_frames > 0:
self.direction_frames -= 1
if self.direction_frames <= 0:
self.owner.direction += self.owner.aim
else:
self.owner.direction += self.direction
+
if self.accel_frames > 0:
self.accel_frames -= 1
self.owner.mx += self.mx
while True:
self.pc += 1
+
if self.pc >= len(self.actions):
self.repeat -= 1
if self.repeat <= 0:
+ self.pc = None
+ self.finished = True
if self.parent is not None:
self.parent.copy_state(self)
self.owner.replace(self, self.parent)
break
elif isinstance(action, (parser.ActionDef, parser.ActionRef)):
- action, params = action(self.params, self.rank)
+ 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())
direction, speed, actions = action(self.params, self.rank)
if direction:
direction, type = direction
- if type == "aim":
+ if type == "aim" or type is None:
direction += self.owner.aim
elif type == "sequence":
direction += self.previous_fire_direction
if type == "sequence":
self.mx = mx
elif type == "absolute":
- self.mx = (mx - bullet.mx) / frames
+ self.mx = (mx - self.owner.mx) / frames
elif type == "relative":
self.mx = mx / frames
if vertical:
if type == "sequence":
self.my = my
elif type == "absolute":
- self.my = (my - bullet.my) / frames
+ self.my = (my - self.owner.my) / frames
elif type == "relative":
self.my = my / frames
"""Simple bullet implementation."""
def __init__(self, x=0, y=0, direction=0, speed=0, target=None,
- actions=(), parent=None):
+ actions=(), parent=None, rank=None):
self.x = self.px = x
self.y = self.py = y
self.mx = 0
self.vanished = False
self.target = target
self.actions = []
- if actions and not parent:
- raise errors.Error
- for action, params in actions:
- self.actions.append(
- Action(self, parent, action, params, parent.rank))
+ if rank is None:
+ rank = parent.rank if parent else 0.5
+ # New bullets reset the parent hierarchy.
+ self.actions = [Action(self, None, action, params, rank)
+ for action, params in actions]
def __repr__(self):
return ("%s(%r, %r, accel=%r, direction=%r, speed=%r, "
if self.target is None:
return self.direction
else:
- return math.atan2(self.target.x - self.x, self.target.y - self.y)
+ return math.degrees(
+ math.atan2(self.target.x - self.x, self.y - self.target.y))
+
+ @property
+ def finished(self):
+ """Check if this bullet is finished running."""
+ for action in self.actions:
+ if not action.finished:
+ return False
+ return self.vanished
def vanish(self):
"""Vanish this bullet and stop all actions."""
self.actions = []
def replace(self, old, new):
+ """Replace an active action with another."""
try:
idx = self.actions.index(old)
except ValueError:
self.actions[idx] = new
def step(self):
+ """Advance by one frame."""
created = []
for action in self.actions:
created.extend(action.step())
- direction = math.degrees(self.direction)
+ direction = math.radians(self.direction)
+ self.px = self.x
+ self.py = self.y
self.x += self.mx + math.sin(direction) * self.speed
- self.y += self.my + math.cos(direction) * self.speed
+ self.y += self.my - math.cos(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)
+
projects / python-bulletml.git / blobdiff