Wait: Actually don't do anything special for wait frames of 0, as break-now-continue...
[python-bulletml.git] / bulletml / impl.py
1 """BulletML implementation."""
2
3 from __future__ import division
4
5 import math
6
7 from bulletml import parser
8
9 # TODO(jfw): This is very non-Pythonic, it's pretty much just the
10 # BulletML reference ActionImpl translated to Python.
11
12 PI_2 = math.pi * 2
13
14 __all__ = ["Action", "Bullet"]
15
16 class Action(object):
17 """Running action implementation."""
18
19 def __init__(self, owner, parent, actions, params, rank, repeat=1):
20 self.actions = actions
21 self.parent = parent
22 self.repeat = repeat
23 self.wait_frames = 0
24 self.speed = 0
25 self.speed_frames = 0
26 self.direction = 0
27 self.direction_frames = 0
28 self.aiming = False
29 self.mx = 0
30 self.my = 0
31 self.accel_frames = 0
32 self.previous_fire_direction = 0
33 self.previous_fire_speed = 0
34 self.params = params
35 self.pc = -1
36 self.finished = False
37 if parent:
38 self.copy_state(parent)
39
40 def __repr__(self):
41 return "%s(pc=%r, actions=%r)" % (
42 type(self).__name__, self.pc, self.actions)
43
44 def vanish(self):
45 """End this action and its parents."""
46 if self.parent:
47 self.parent.vanish()
48 self.pc = None
49 self.finished = True
50
51 def copy_state(self, other):
52 """Copy fire/movement state from other to self."""
53 self.direction_frames = other.direction_frames
54 self.direction = other.direction
55 self.aiming = other.aiming
56 self.speed_frames = other.speed_frames
57 self.speed = other.speed
58 self.accel_frames = other.accel_frames
59 self.mx = other.mx
60 self.my = other.my
61 self.previous_fire_direction = other.previous_fire_direction
62 self.previous_fire_speed = other.previous_fire_speed
63
64 def step(self, owner, rank, created, sin=math.sin, cos=math.cos):
65 """Advance by one frame."""
66 s_params = self.params
67
68 if self.speed_frames > 0:
69 self.speed_frames -= 1
70 owner.speed += self.speed
71
72 if self.direction_frames > 0:
73 # The Noiz implementation was a little weird here, I think
74 # there was a bug in it that prevented it from working if
75 # the frame count was 1. I'm still not sure what the aim
76 # check is supposed to do, exactly.
77 self.direction_frames -= 1
78 if self.aiming and self.direction_frames <= 0:
79 owner.direction += owner.aim
80 else:
81 owner.direction += self.direction
82
83 if self.accel_frames > 0:
84 self.accel_frames -= 1
85 owner.mx += self.mx
86 owner.my += self.my
87
88 if self.pc is None:
89 return
90
91 if self.wait_frames > 0:
92 self.wait_frames -= 1
93 return
94
95 while True:
96 self.pc += 1
97
98 try:
99 action = self.actions[self.pc]
100 except IndexError:
101 self.repeat -= 1
102 if self.repeat <= 0:
103 self.pc = None
104 self.finished = True
105 if self.parent is not None:
106 self.parent.copy_state(self)
107 owner.replace(self, self.parent)
108 break
109 else:
110 self.pc = 0
111 action = self.actions[self.pc]
112
113 if isinstance(action, parser.Repeat):
114 repeat, (actions, params) = action(s_params, rank)
115 child = Action(owner, self, actions, params, rank, repeat)
116 owner.replace(self, child)
117 child.step(owner, rank, created, sin, cos)
118 break
119
120 elif isinstance(action, (parser.ActionDef, parser.ActionRef)):
121 actions, params = action(s_params, rank)
122 child = Action(owner, self, actions, params, rank)
123 owner.replace(self, child)
124 child.step(owner, rank, created, sin, cos)
125 break
126
127 elif isinstance(action, (parser.FireDef, parser.FireRef)):
128 direction, speed, actions, offset = action(s_params, rank)
129 if direction:
130 direction, type = direction
131 if type == "aim" or type is None:
132 direction += owner.aim
133 elif type == "sequence":
134 direction += self.previous_fire_direction
135 elif type == "relative":
136 direction += owner.direction
137 else:
138 direction = owner.aim
139 self.previous_fire_direction = direction
140
141 if speed:
142 speed, type = speed
143 if type == "sequence":
144 speed += self.previous_fire_speed
145 elif type == "relative":
146 # The reference Noiz implementation uses
147 # prvFireSpeed here, but the standard is
148 # pretty clear -- "In case of the type is
149 # "relative", ... the speed is relative to the
150 # speed of this bullet."
151 speed += owner.speed
152 else:
153 speed = 1
154 self.previous_fire_speed = speed
155
156 x, y = owner.x, owner.y
157 if offset:
158 off_x, off_y = offset(s_params, rank)
159 if offset.type == "relative":
160 s = sin(direction)
161 c = cos(direction)
162 x += c * off_x + s * off_y
163 y += s * off_x - c * off_y
164 else:
165 x += off_x
166 y += off_y
167
168 bullet = Bullet(
169 x, y, direction, speed, owner.target, actions, self, rank)
170 created.append(bullet)
171
172 elif isinstance(action, parser.ChangeSpeed):
173 frames, (speed, type) = action(s_params, rank)
174 self.speed_frames = frames
175 if frames <= 0:
176 if type == "absolute":
177 owner.speed = speed
178 elif type == "relative":
179 owner.speed += speed
180 elif type == "sequence":
181 self.speed = speed
182 elif type == "relative":
183 self.speed = speed / frames
184 else:
185 self.speed = (speed - owner.speed) / frames
186
187 elif isinstance(action, parser.ChangeDirection):
188 frames, (direction, type) = action(s_params, rank)
189 self.direction_frames = frames
190 self.aiming = False
191 if type == "sequence":
192 self.direction = direction
193 else:
194 if type == "absolute":
195 direction -= owner.direction
196 elif type != "relative": # aim or default
197 self.aiming = True
198 direction += owner.aim - owner.direction
199
200 # Normalize to [-pi, pi).
201 direction = (direction + math.pi) % PI_2 - math.pi
202 if frames <= 0:
203 owner.direction += direction
204 else:
205 self.direction = direction / frames
206
207 elif isinstance(action, parser.Accel):
208 frames, horizontal, vertical = action(s_params, rank)
209 self.accel_frames = frames
210 if horizontal:
211 mx, type = horizontal
212 if frames <= 0:
213 if type == "absolute":
214 owner.mx = mx
215 elif type == "relative":
216 owner.mx += mx
217 elif type == "sequence":
218 self.mx = mx
219 elif type == "absolute":
220 self.mx = (mx - owner.mx) / frames
221 elif type == "relative":
222 self.mx = mx / frames
223 if vertical:
224 my, type = vertical
225 if frames <= 0:
226 if type == "absolute":
227 owner.my = my
228 elif type == "relative":
229 owner.my += my
230 elif type == "sequence":
231 self.my = my
232 elif type == "absolute":
233 self.my = (my - owner.my) / frames
234 elif type == "relative":
235 self.my = my / frames
236
237 elif isinstance(action, parser.Tag):
238 owner.tags.add(action.tag)
239
240 elif isinstance(action, parser.Untag):
241 try:
242 owner.tags.remove(action.tag)
243 except KeyError:
244 pass
245
246 elif isinstance(action, parser.Wait):
247 self.wait_frames = action(s_params, rank)
248 break
249
250 elif isinstance(action, parser.Vanish):
251 owner.vanish()
252 break
253
254 class Bullet(object):
255 """Simple bullet implementation.
256
257 Attributes:
258 x, y - current X/Y position
259 px, py - X/Y position prior to the last step
260 mx, my - X/Y axis-oriented speed modifier ("acceleration")
261 direction - direction of movement, in radians
262 speed - speed of movement, in units per frame
263 target - object with .x and .y fields for "aim" directions
264 vanished - set to true by a <vanish> action
265 rank - game difficulty, 0 to 1, default 0.5
266 tags - string tags set by the running actions
267
268 Contructor Arguments:
269 x, y, direction, speed, target, rank - same as the attributes
270 actions - internal action list
271 parent - parent of actions, None for manually-created bullets
272
273
274 """
275
276 def __init__(self, x=0, y=0, direction=0, speed=0, target=None,
277 actions=(), parent=None, rank=0.5):
278 self.x = self.px = x
279 self.y = self.py = y
280 self.mx = 0
281 self.my = 0
282 self.direction = direction
283 self.speed = speed
284 self.vanished = False
285 self.target = target
286 self.rank = rank
287 self.tags = set()
288 # New bullets reset the parent hierarchy.
289 self._actions = [Action(self, None, action, params, rank)
290 for action, params in actions]
291
292 def __repr__(self):
293 return ("%s(%r, %r, accel=%r, direction=%r, speed=%r, "
294 "actions=%r, target=%r, vanished=%r)") % (
295 type(self).__name__, self.x, self.y, (self.mx, self.my),
296 self.direction, self.speed, self._actions, self.target,
297 self.vanished)
298
299 @property
300 def aim(self):
301 """Angle to the target, in radians."""
302 if self.target is None:
303 return self.direction
304 else:
305 return math.atan2(self.target.x - self.x, self.y - self.target.y)
306
307 @property
308 def finished(self):
309 """Check if this bullet is finished running.
310
311 A bullet is finished when it has vanished, and all its
312 actions have finished.
313
314 If this is true, the bullet should be removed from the screen.
315 (You will probably want to cull it under other circumstances
316 as well).
317 """
318 if not self.vanished:
319 return False
320 for action in self._actions:
321 if not action.finished:
322 return False
323 return True
324
325 def vanish(self):
326 """Vanish this bullet and stop all actions."""
327 self.vanished = True
328 for action in self._actions:
329 action.vanish()
330 self._actions = []
331
332 def replace(self, old, new):
333 """Replace an active action with another.
334
335 This is mostly used by actions internally to queue children.
336 """
337 try:
338 idx = self._actions.index(old)
339 except ValueError:
340 pass
341 else:
342 self._actions[idx] = new
343
344 def step(self, sin=math.sin, cos=math.cos):
345 """Advance by one frame.
346
347 This updates the position and velocity, and may also set the
348 vanished flag.
349
350 It returns any new bullets this bullet spawned during this step.
351 """
352 created = []
353
354 for action in self._actions:
355 action.step(self, self.rank, created, sin, cos)
356
357 self.px = self.x
358 self.py = self.y
359 self.x += self.mx + sin(self.direction) * self.speed
360 self.y += self.my - cos(self.direction) * self.speed
361
362 return created