Give bullets a radius by default. Use try/except rather than getattr during collision...

diff --git a/bulletml/bulletyaml.py b/bulletml/bulletyaml.py
index 2503c9d7fa757f97208ac2d3ea6b1744a919fcc0..2ec2f0849b6d12c8cdc80dc222ee6c875875e089 100644 (file)
--- a/bulletml/bulletyaml.py
+++ b/bulletml/bulletyaml.py
@@ -30,7 +30,7 @@ def register(Loader=None, Dumper=None):
                 parser.Repeat, parser.Accel, parser.BulletDef,
                 parser.BulletRef, parser.ActionDef, parser.ActionRef,
                 parser.FireDef, parser.FireRef, parser.Offset,
-                parser.BulletML]:
+                parser.Appearance, parser.If, parser.BulletML]:
 
         def add(cls, loader, dumper):
             """Register a class in a new variable scope."""

diff --git a/bulletml/collision.py b/bulletml/collision.py
index 1683e58f6ca70fa583e65e9e967835d2c6831472..8aa17d31725781c4cff175d11d339680785c4c14 100644 (file)
--- a/bulletml/collision.py
+++ b/bulletml/collision.py
@@ -30,7 +30,10 @@ def overlaps(a, b):
 
     dx = a.x - b.x
     dy = a.y - b.y
-    radius = getattr(a, 'radius', 0.5) + getattr(b, 'radius', 0.5)
+    try:
+        radius = a.radius + b.radius
+    except AttributeError:
+        radius = getattr(a, 'radius', 0.5) + getattr(b, 'radius', 0.5)
 
     return dx * dx + dy * dy <= radius * radius
 
@@ -53,27 +56,32 @@ def collides(a, b):
     yb = b.y
 
     # Treat b as a point, we only need one radius.
-    radius = getattr(a, 'radius', 0.5) + getattr(b, 'radius', 0.5)
+    try:
+        radius = a.radius + b.radius
+    except AttributeError:
+        radius = getattr(a, 'radius', 0.5) + getattr(b, 'radius', 0.5)
 
     # Previous frame locations.
-    pxa = getattr(a, 'px', xa)
-    pya = getattr(a, 'py', ya)
-    pxb = getattr(b, 'px', xb)
-    pyb = getattr(b, 'py', yb)
+    try: pxa = a.px
+    except KeyError: pxa = xa
+    try: pya = a.py
+    except KeyError: pya = ya
+    try: pxb = b.px
+    except KeyError: pxb = xb
+    try: pyb = b.py
+    except KeyError: pyb = yb
 
     # Translate b's final position to be relative to a's start.
     # And now, circle/line collision.
     dir_x = pxa + (xb - xa) - pxb
     dir_y = pya + (yb - ya) - pyb
 
-    if abs(dir_x) < 0.0001 and abs(dir_y) < 0.0001:
-        # b did not move relative to a, so do point/circle.
-        dx = pxb - pxa
-        dy = pyb - pya
-        return dx * dx + dy * dy < radius * radius
-
     diff_x = pxa - pxb
     diff_y = pya - pyb
+    if (dir_x < 0.0001 and dir_x > -0.0001
+        and dir_y < 0.0001 and dir_y > -0.0001):
+        # b did not move relative to a, so do point/circle.
+        return diff_x * diff_x + diff_y * diff_y < radius * radius
 
     # dot(diff, dir) / dot(dir, dir)
     t = (diff_x * dir_x + diff_y * dir_y) / (dir_x * dir_x + dir_y * dir_y)

diff --git a/bulletml/impl.py b/bulletml/impl.py
index f7edd5a458d05ca0399a70e3ac7ce4f1549f70d3..4785ef2c8c17094076b38e49ceef4486fb9910b7 100644 (file)
--- a/bulletml/impl.py
+++ b/bulletml/impl.py
@@ -131,9 +131,10 @@ class Bullet(object):
     rank - game difficulty, 0 to 1, default 0.5
     tags - string tags set by the running actions
     appearance - string used to set bullet appearance
+    radius - radius for collision
 
     Contructor Arguments:
-    x, y, direction, speed, target, rank, tags, appearance
+    x, y, direction, speed, target, rank, tags, appearance, radius
         - same as the above attributes
     actions - internal action list
     Action - custom Action constructor
@@ -141,9 +142,11 @@ class Bullet(object):
     """
 
     def __init__(self, x=0, y=0, direction=0, speed=0, target=None,
-                 actions=(), rank=0.5, tags=(), appearance=None):
+                 actions=(), rank=0.5, tags=(), appearance=None,
+                 radius=0.5):
         self.x = self.px = x
         self.y = self.py = y
+        self.radius = radius
         self.mx = 0
         self.my = 0
         self.direction = direction