General cleanup and fixes

Author: CoolCat467

gameobjects/__init__.py

@@ -1,13 +1,15 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
 __all__ = [
-'vector2',
-'vector3',
-'util',
-'sphere',
-'matrix44',
-'color',
-'gametime',
-'grid'
+    'vector2',
+    'vector3',
+    'util',
+    'sphere',
+    'matrix44',
+    'color',
+    'gametime',
+    'grid'
 ]
 
-
-__version__ = "0.0.3"
+__version__ = '0.0.3'

gameobjects/color.py

@@ -1,23 +1,27 @@
-from math import *
-from util import format_number
-
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Color Module
 
-class ColorRGBA(object):
+"Color module"
 
-    __slots__ = ('_c',)
+__title__ = 'color'
 
+from util import format_number
 
+class ColorRGBA:
+    "Color with red, green, blue, and alpha components."
+    __slots__ = ('_c',)
+    
     def __init__(self, *args):
-
-        """Creates a color object."""
-
+        "Creates a color object."
+        
         if not args:
             self._c = [0.0, 0.0, 0.0, 1.0]
             return
-
+        
         if len(args) == 1:
             args = args[0]
-
+        
         if len(args) == 3:
             r, g, b = args
             self._c = [float(r), float(g), float(b), 1.0]
@@ -26,26 +30,23 @@ def __init__(self, *args):
             r, g, b, a = args
             self._c = [float(r), float(g), float(b), float(a)]
             return
-
-        raise ValueError("0, 1, 3 or 4 values required")
-
+        
+        raise ValueError('0, 1, 3 or 4 values required')
+    
     def __str__(self):
-
-        return "(" + ", ".join(format_number(c) for c in self._c) + ")"
+        return '(' + ', '.join(format_number(c) for c in self._c) + ')'
         #return "(" + ", ".join(map(str, self._c)) + ")"
 
     def __repr__(self):
-
+        
         return "ColorRGBA(" + ", ".join(map(str, self._c)) + ")"
 
     @classmethod
     def black(cls):
-
-        """Create a color object representing black."""
-
-        c = cls.__new__(cls, object)
-        c._c = [0.0, 0.0, 0.0, 1.0]
-        return c
+        "Create a color object representing black."
+        self = cls.__new__(cls, object)
+        self._c = [0.0, 0.0, 0.0, 1.0]
+        return self
 
     @classmethod
     def white(cls):
@@ -996,10 +997,7 @@ def mul_alpha(self):
     'lightgreen' : (0.564705882353, 0.933333333333, 0.564705882353),
 }
 
-
-
-if __name__ == "__main__":
-
+def test():
     c1 = Color(.5, .2, .8)
     c2 = Color(1., 0., .2)
     print(c1)
@@ -1010,3 +1008,6 @@ def mul_alpha(self):
     print(c1('rrrgggbbbaaa'))
     print(Color.from_palette('magenta').rgba8)
     #palette.red += palette.blue
+
+if __name__ == "__main__":
+    test()

gameobjects/gametime.py

@@ -1,17 +1,22 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Game Time Module
 
+"Game Time Module"
 
-class GameClock(object):
-    
-    """Manages time in a game."""
-    
+__title__ = "gametime"
+
+import time as _time
+
+class GameClock:
+    "Manages time in a game."
     def __init__(self, game_ticks_per_second=20):
-        
         """Create a Game Clock object.
         
         game_ticks_per_second -- The number of logic frames a second.
         
         """
-            
+        
         self.game_ticks_per_second = float(game_ticks_per_second)
         self.game_tick = 1. / self.game_ticks_per_second        
         self.speed = 1.        
@@ -30,11 +35,10 @@ def __init__(self, game_ticks_per_second=20):
         self.fps_sample_start_time = 0.0
         self.fps_sample_count = 0
         self.average_fps = 0
-        
-        
+    
+    
     def start(self):
-        
-        """Starts the Game Clock. Must be called once."""
+        "Starts the Game Clock. Must be called once."
 
         if self.started:
             return
@@ -54,7 +58,6 @@ def start(self):
 
 
     def set_speed(self, speed):
-        
         """Sets the speed of the clock.
         
         speed -- A time factor (1 is normal speed, 2 is twice normal)
@@ -66,70 +69,53 @@ def set_speed(self, speed):
             raise ValueError("Negative speeds not supported")
 
         self.speed = speed
-        
-        
+    
     def pause(self):
-        
-        """Pauses the Game Clock."""
-        
+        "Pauses the Game Clock."
         self.pause = True
-        
+    
     def unpause(self):
-        
-        """Un-pauses the Game Clock."""
-        
+        "Un-pauses the Game Clock."
         self.pause = False
-        
-        
+    
     def get_real_time(self):
-        
         """Returns the real time, as reported by the system clock.
         This method may be overriden."""
-        
-        import time
-        return time.clock()        
-        
-        
+
+        return _time.time()
+    
     def get_fps(self):
-        
         """Retrieves the current frames per second as a tuple containing
         the fps and average fps over a second."""
-        
         return self.fps, self.average_fps
 
-    
     def get_between_frame(self):
-        
         """Returns the interpolant between the previous game tick and the
         next game tick."""
 
         return self.between_frame
 
-        
     def update(self, max_updates = 0):
-        
         """Advances time, must be called once per frame. Yields tuples of
         game frame count and game time.
         
         max_updates -- Maximum number of game time updates to issue.
-        
         """
 
-        assert self.started, "You must call 'start' before using a GameClock."        
-
+        assert self.started, "You must call 'start' before using a GameClock."
+        
         real_time_now = self.get_real_time()
 
         self.real_time_passed = real_time_now - self.real_time
         self.real_time = real_time_now
 
         self.clock_time += self.real_time_passed
-                
+        
         if not self.paused:
             self.virtual_time += self.real_time_passed * self.speed
 
         update_count = 0
-        while self.game_time + self.game_tick < self.virtual_time:
-                        
+        while self.game_time + self.game_tick < self.virtual_time:       
             self.game_frame_count += 1
             self.game_time = self.game_frame_count * self.game_tick
             yield (self.game_frame_count, self.game_time)
@@ -138,7 +124,7 @@ def update(self, max_updates = 0):
                 break
 
         self.between_frame = ( self.virtual_time - self.game_time ) / self.game_tick
-            
+        
         if self.real_time_passed != 0:
             self.fps = 1.0 / self.real_time_passed
         else:
@@ -151,22 +137,19 @@ def update(self, max_updates = 0):
             self.average_fps = self.fps_sample_count / (self.real_time - self.fps_sample_start_time)
             self.fps_sample_start_time = self.real_time
             self.fps_sample_count = 0
-    
-    
-if __name__ == "__main__":    
-    
-    import time
+
+def test():
     t = GameClock(20) # AI is 20 frames per second
     t.start()
 
     while t.virtual_time < 2.0:
-        
         for (frame_count, game_time) in t.update():            
-            
             print("Game frame #%i, %2.4f" % (frame_count, game_time))
-            
+        
         virtual_time = t.virtual_time
         print("\t%2.2f%% between game frame, time is %2.4f"%(t.between_frame*100., virtual_time))
 
-        
-        time.sleep(0.2) # Simulate time to render frame
+        _time.sleep(0.2) # Simulate time to render frame
+
+if __name__ == '__main__':    
+    test()

gameobjects/grid.py

@@ -1,15 +1,22 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Grid Module
 
-from locals import WRAP_REPEAT, WRAP_CLAMP, WRAP_ERROR
-from util import saturate
+"Grid module"
+
+__title__ = 'grid'
 
-class Grid(object):
+from locals import WRAP_REPEAT, WRAP_CLAMP, WRAP_ERROR, WRAP_NONE
+from util import saturate
 
+class Grid:
+    "Grid class"
     def __init__( self,  node_factory,
                          width,
                          height,
                          x_wrap = WRAP_ERROR,
                          y_wrap = WRAP_ERROR ):
-
+        
         """Create a grid object.
 
         node_factory -- Callable that takes the x and y coordinate of the node
@@ -35,203 +42,175 @@ def __init__( self,  node_factory,
 
         self._wrap_functions = [ self._make_wrap(self._x_wrap, self.width),
                                  self._make_wrap(self._y_wrap, self.height) ]
-
-
+    
     def _get_x_wrap(self):
         return self._x_wrap
     def _set_x_wrap(self, x_wrap):
         self._x_wrap = x_wrap
         self._wrap_functions[0] = self._make_wrap(x_wrap, self.width)
     x_wrap = property(_get_x_wrap, _set_x_wrap, None, "X wrap")
-
+    
     def _get_y_wrap(self):
         return self._y_wrap
     def _set_y_wrap(self, y_wrap):
         self._y_wrap = y_wrap
         self._wrap_functions[1] = self._make_wrap(y_wrap, self.height)
     y_wrap = property(_get_y_wrap, _set_y_wrap, None, "Y wrap")
-
-
+    
     def _make_wrap(self, wrap, edge):
-
         if wrap == WRAP_NONE:
             def do_wrap(value):
                 return value
-
+        
         elif wrap == WRAP_REPEAT:
             def do_wrap(value):
                 return value % edge
-
+        
         elif wrap == WRAP_CLAMP:
             def do_wrap(value):
                 if value < 0:
                     return 0
                 if value >= edge:
                     value = edge
                 return value
-
+        
         elif wrap == WRAP_ERROR:
             def do_wrap(value):
                 if value < 0 or value >= edge:
-                    raise IndexError("coordinate out of range")
-
+                    raise IndexError("Coordinate out of range")
+                return value
         else:
             raise ValueError("Unknown wrap mode")
-
+        
         return do_wrap
-
-
+    
     def wrap(self, coord):
-
         x, y = coord
         wrap_x, wrap_y = self._wrap_functions
         return ( wrap_x(x), wrap_y(y) )
-
-
+    
     def wrap_x(self, x):
         """Wraps an x coordinate.
 
         x -- X Coordinate
 
         """
-
+        
         return self._wrap_functions[0](x)
-
+    
     def wrap_y(self, y):
         """Wraps a y coordinate.
 
         y -- Y Coordinate.
 
         """
-
+        
         return self._wrap_functions[1](y)
-
-
+    
     def get_size(self):
-
-        """Retrieves the size of the grid as a tuple (width, height)."""
-
+        "Retrieves the size of the grid as a tuple (width, height)."
         return self.width, self.height
-
-
+    
     def __getitem__(self, coord):
-
         x, y = coord
-
+        
         if isinstance(x, slice) or isinstance(y, slice):
             if isinstance(x, slice):
                 x_indices = x.indices(self.width)
             else:
                 x_indices = [x]
-
+            
             if isinstance(y, slice):
                 y_indices = y.indices(self.height)
             else:
                 y_indices = [y]
-
+            
             try:
                 wrap_x, wrap_y = self._wrap_functions
-
+                
                 ret = []
 
                 for y_index in range(*y_indices):
                     nodes_y = self.nodes[ wrap_y(y_index) ]
-
+                    
                     for x_index in range(*x_indices):
                         ret.append( nodes_y[ wrap_x(x_index) ] )
-
             except IndexError:
                 raise IndexError("Slice out of range")
-
+            
             return ret
-
-
+        
         x, y = self.wrap(coord)
-
+        
         if x < 0 or y < 0:
-            raise IndexError("coordinate out of range")
-
+            raise IndexError("Coordinate out of range")
         try:
             return self.nodes[y][x]
         except IndexError:
-            raise IndexError("coordinate out of range")
-
-
+            raise IndexError("Coordinate out of range")
+    
     def __iter__(self):
-
         for row in self.nodes:
             for node in row:
                 yield node
-
-
+    
     def __contains__(self, value):
-
         for row in self.nodes:
             if node in row:
                 return True
-
+        
         return False
-
-
+    
     def clear(self):
-
-        """Resets the grid."""
-
+        "Resets the grid."
+        
         node_factory = self.node_factory
-
+        
         self.nodes[:] = [ [node_factory(x, y) for x in range(width)] \
                                               for y in range(height)]
-
-
+    
     def get(self, coord, default=None):
-
         """Retrieves a node from the grid.
 
         coord -- Coordinate to retrieve
         default -- Default value to use if coord is out of range
 
         """
-
+        
         x, y = self.wrap(coord)
-
+        
         if x < 0 or y < 0 or x >= self.width or y >= self.height:
             if default is not None:
                 return default
             else:
                 raise IndexError("coordinate out of range")
-
+        
         return self.nodes[y][x]
-
-
+    
     def get_nodes(self, coord, size, wrap=False):
-
         width = self.width
         height = self.height
-
+        
         x1, y1 = coord
         x1 = saturate(x1, 0, width)
         y1 = saturate(y1, 0, height)
         w, h = size
-        x2, y2 = (x+w, y+h)
-        x = saturate(x, 0, width)
-        y = saturate(y, 0, height)
-
+        x2, y2 = (x1+w, y1+h)
+        x2 = saturate(x2, 0, width)
+        y2 = saturate(y2, 0, height)
+        
         if x1 > x2:
             x1, x2 = x2, x1
         if y1 > y2:
             y1, y2 = y2, y1
-
+        
         wrap_x, wrap_y = self._wrap_functions
-
+        
         nodes = self.nodes
         return [self.nodes[y_coord][x1:x2] for y_coord in range(y1, y2)]
 
-
-
-
-if __name__ == "__main__":
-
-    class Square(object):
+def test():
+    class Square:
         def __init__(self, x, y):
             self.coord = (x, y)
         def __str__(self):
@@ -240,9 +219,12 @@ def __repr__(self):
             return str(self.coord)
 
     g = Grid(Square, 100, 100, x_wrap = WRAP_REPEAT)
-
-    for square in g:
-        print(str(square))
-
+##    
+##    for square in g:
+##        print(str(square))
+    
     print(g[10:20, 10:20])
     print(g.get_nodes((-2, 0), (5, 5)))
+
+if __name__ == '__main__':
+    test()

gameobjects/locals.py

@@ -2,4 +2,5 @@
 
 ( WRAP_REPEAT,
   WRAP_CLAMP,
-  WRAP_ERROR ) = range(3)
+  WRAP_ERROR,
+  WRAP_NONE ) = range(4)

gameobjects/sphere.py

@@ -1,14 +1,21 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Sphere Module
+
+"Sphere module"
+
+__title__ = 'sphere'
+
 import vector3
 from util import format_number
 
-class Sphere(object):
+class Sphere:
+    __slots__ = '_position', '_radius'
 
     def __init__(self, position=(0,0,0), radius= 1.):
-        
         self._position = vector3.Vector3(position)
         self._radius = float(radius)
-        
-        
+    
     def get_position(self):
         return self._position
     def set_position(self, position):
@@ -20,51 +27,33 @@ def get_radius(self):
     def set_radius(self, radius):
         self._radius = float(radius)
     radius = property(get_radius, set_radius, None, "Radius of the sphere.")
-        
-        
-    def __str__(self):
-        
-        return "( position %s, radius %s )" % (self.position, format_number(self.radius))
 
+    def __str__(self):
+        return 'f( position {self.position}, radius {format_number(self.radius)} )'
 
     def __repr__(self):
-        
-        return "Sphere(%s, %s)" % (tuple(self.position), self.radius)
-        
-        
+        return f'Sphere({tuple(self.position)}, {self.radius})'
+    
     def __contains__(self, shape):
-        
-        try:
-            return shape.in_sphere(self)
-        except AttributeError:
+        if not hasattr(shape, 'in_sphere'):
             raise TypeError( "No 'in_sphere' method supplied by %s" % type(shape) )
-            
-            
+        return shape.in_sphere(self)
+    
     def contains(self, shape):
-        
         return shape in self
-            
-            
+    
     def in_sphere(self, sphere):
-        
         return self.position.get_distance(sphere.position) + self.radius <= sphere.radius
-        
-        
+    
     def intersects(self, shape):
-        
-        try:
-            return shape.intersects_sphere(self)
-        except AttributeError:
+        if not hasattr(shape, 'intersects_sphere'):
             raise TypeError( "No 'intersects_sphere' method supplied by %s" % type(shape) )
-    
+        return shape.intersects_sphere(self)
 
     def intersects_sphere(self, sphere):
-        
         return self.position.get_distance(sphere.position) < self.radius + sphere.radius
-
 
 if __name__ == "__main__":
-    
     s1 = Sphere()
     s2 = Sphere( (1,1,1) )
     s3 = Sphere( radius=10 )
@@ -79,7 +68,7 @@ def intersects_sphere(self, sphere):
 
     big = Sphere(radius=1)
     small = Sphere(position=(.8, 0, 0), radius=.2)
-     
+    
 
     print(small, big)
     print(small in big)

gameobjects/test_vector3.py

@@ -1,23 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
 import unittest
 
 from vector3 import Vector3
 
 class TestVector3(unittest.TestCase):
-
     def test_add(self):
         v1 = Vector3(1, 2, 3)
         v2 = Vector3(4, 5, 6)
         self.assertEqual(v1+v2, (5, 7, 9))
         self.assertEqual((1, 2, 3)+v2, (5, 7, 9))
-
-
+    
     def test_sub(self):
         v1 = Vector3(1, 2, 3)
         v2 = Vector3(4, 5, 6)
         self.assertEqual(v1-v2, (-3, -3, -3))
         self.assertEqual((1, 2, 3)-v2, (-3, -3, -3))
-
-
+    
     def test_mul(self):
         v1 = Vector3(1, 2, 3)
         v2 = Vector3(4, 5, 6)
@@ -27,7 +27,7 @@ def test_mul(self):
         self.assertEqual(v1*(3, 3, 3), (3, 6, 9))
         v1 *= 2
         self.assertEqual(v1, (2, 4, 6))
-
+    
     def test_div(self):
         v1 = Vector3(1, 2, 3)
         v2 = Vector3(4, 5, 6)
@@ -37,19 +37,19 @@ def test_div(self):
         self.assertEqual(v1/(3, 3, 3), (1./3, 2/3., 3/3.))
         v1 /= 2
         self.assertEqual(v1, (.5, 1., 1.5))
-
+    
     def test_length(self):
         v1 = Vector3(3., 4., 0.)
         self.assertEqual(v1.length, 5.)
         v1.length = 10.
         self.assertEqual(v1, (6, 8, 0))
         v1.normalise()
-        assert(v1.length, 1.)
-
+        self.assertEqual(v1.length, 1.)
+    
     def test_copy(self):
         v1 = Vector3(3., 4., 0.)
-        assert(v1.copy(), (3, 4, 0))
-
+        self.assertEqual(v1.copy(), (3, 4, 0))
+    
     def test_properties(self):
         v1 = Vector3(1, 2, 3)
         self.assertEqual(v1.x, 1)
@@ -61,7 +61,7 @@ def test_properties(self):
         self.assertEqual(v1.x, 2)
         self.assertEqual(v1.y, 4)
         self.assertEqual(v1.z, 6)
-
+    
     def test_swizzle(self):
         v1 = Vector3(1, 2, 3)
         self.assertEqual(v1('xxxyyyzzz'), (1, 1, 1, 2, 2, 2, 3, 3, 3))

gameobjects/util.py

@@ -1,61 +1,56 @@
-from math import *
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Utils module
+
+"Util module"
+
+__title__ = 'util'
+
+import math
 
 def format_number(n, accuracy=6):
     """Formats a number in a friendly manner
     (removes trailing zeros and unneccesary point."""
-
-    fs = "%."+str(accuracy)+"f"
-    str_n = fs%float(n)
+    
+    fs = f'%.{accuracy}f'
+    str_n = fs % (float(n) + 0)# convert -0 to 0
     if '.' in str_n:
         str_n = str_n.rstrip('0').rstrip('.')
-    if str_n == "-0":
-        str_n = "0"
-    #str_n = str_n.replace("-0", "0")
     return str_n
 
-
 def lerp(a, b, i):
-    """Linear enterpolate from a to b."""
+    "Linear enterpolate from a to b."
     return a+(b-a)*i
 
-
 def range2d(range_x, range_y):
-
-    """Creates a 2D range."""
-
+    "Creates a 2D range."
     range_x = list(range_x)
     return [ (x, y) for y in range_y for x in range_x ]
 
-
 def xrange2d(range_x, range_y):
-
-    """Iterates over a 2D range."""
-
+    "Iterates over a 2D range."
     range_x = list(range_x)
     for y in range_y:
         for x in range_x:
             yield (x, y)
 
-
 def saturate(value, low, high):
+    "Ensure value is within bounds, min of low, max of high."
     return min(max(value, low), high)
 
-
 def is_power_of_2(n):
-    """Returns True if a value is a power of 2."""
-    return log(n, 2) % 1.0 == 0.0
-
+    "Returns True if a value is a power of 2."
+    return not math.log(n, 2) % 1
 
 def next_power_of_2(n):
-    """Returns the next power of 2 that is >= n"""
-    return int(2 ** ceil(log(n, 2)))
-
-if __name__ == "__main__":
+    "Returns the next power of 2 that is >= n"
+    return int(2 ** math.ceil(math.log(n, 2)))
 
+if __name__ == '__main__':
     print(list( xrange2d(range(3), range(3)) ))
     print(range2d(range(3), range(3)))
     print(is_power_of_2(7))
     print(is_power_of_2(8))
     print(is_power_of_2(9))
-
+    
     print(next_power_of_2(7))

gameobjects/vector.py

@@ -2,16 +2,12 @@
 # -*- coding: utf-8 -*-
 # Vector Module
 
-"Vector module"
+"Game objects Vector module"
 
 # Programmed by CoolCat467
 
-__title__ = 'Vector'
+__title__ = 'Game objects Vector'
 __author__ = 'CoolCat467'
-__version__ = '0.0.0'
-_ver_major__ = 0
-_ver_minor__ = 0
-_ver_patch__ = 0
 
 import math
 from functools import wraps
@@ -25,7 +21,6 @@ def wrapped_op(self, rhs, *args, **kwargs):
                 return function(self, rhs, *args, **kwargs)
             raise TypeError('Operand length is not same as own')
         return function(self, [rhs]*len(self), *args, **kwargs)
-##        raise AttributeError('Operand has no length attribute')
     return wrapped_op
 
 def simpleop(function):
@@ -86,11 +81,9 @@ def __init__(self, *args, dims=None, dtype=tuple):
         if not hasattr(dtype, '__getitem__'):
             raise TypeError('Data type class is not subscriptable!')
         if dims is None:
-##            self._v = tuple(args)
             self._v = self.dtype(args)
         else:
             args = args[:dims]
-##            self._v = tuple(list(args) + [0]*(dims-len(args)))
             self._v = self.dtype(list(args) + [0]*(dims-len(args)))
 
     def __repr__(self):
@@ -150,9 +143,7 @@ def reverse(self):
     def normalize(self):
         "Normalize this vector."
         mag = self.magnitude
-##        self._v = tuple(map(lambda x:x/mag, self._v))
         self._v = self.dtype(map(lambda x:x/mag, self._v))
-##        self._v = list(map(lambda x:x/mag, self._v))
         return self
 
     def normalized(self):
@@ -234,30 +225,12 @@ def __rpow__(self, lhs):
     @boolop('all')
     def __eq__(self, rhs):
         return self == rhs
-##        return self._v == rhs
 
     @vmathop
     @boolop('any')
     def __ne__(self, rhs):
         print((self, '!=', rhs))
         return self != rhs
-##        return self._v != rhs
-    
-##    @vmagop
-##    def __gt__(x, y):
-##        return x > y
-##    
-##    @vmagop
-##    def _ge__(x, y):
-##        return x >= y
-##    
-##    @vmagop
-##    def __lt__(x, y):
-##        return x < y
-##    
-##    @vmagop
-##    def __le__(x, y):
-##        return x <= y
 
     def __hash__(self):
         return hash(self._v)
@@ -269,7 +242,7 @@ def set_length(self, new_length):
             mag = 0
         else:
             mag = new_length / cmag
-##        self._v = (self * ([mag]*len(self)))._v
+##        self._v = (self * mag)._v
         return self * mag
 
     @onlylen(3)
@@ -299,14 +272,14 @@ class Vector1(Vector):
     "Vector1. Same as Vector, but stuck being 1d and has x attribute."
     _gameobjects_vector = 1
     def __init__(self, x=0, **kwargs):
-##        kwargs['dims'] = 1
+        kwargs['dims'] = 1
         if not 'dtype' in kwargs:
             kwargs['dtype'] = list
         super().__init__(x, **kwargs)
 
     @classmethod
     def from_iter(cls, iterable, dtype=list):
-        "Return Vector2 from iterable."
+        "Return Vector1 from iterable."
         nxt = iter(iterable).__next__
         return cls(nxt(), dtype=dtype)
 
@@ -389,6 +362,7 @@ def get_normalised(self):
     def get_distance_to(self, point):
         "Return distance to point"
         return (point - self).magnitude
+    get_distance = get_distance_to
 
     def set(self, *args):
         for idx, val in enumerate(args):
@@ -398,7 +372,6 @@ def set(self, *args):
 
     def scalar_mul(self, scalar):
         self.__imul__(scalar)
-##        return self *= scalar
         return self
     vector_mul = scalar_mul
 
@@ -407,7 +380,6 @@ def get_scalar_mul(self, scalar):
     get_vector_mul = get_scalar_mul
 
     def scalar_div(self, scalar):
-##        return self /= scalar
         self.__idiv__(scalar)
         return self
     vector_div = scalar_div
@@ -427,7 +399,7 @@ class Vector2(Vector1):
     "Vector2. Same as Vector, but stuck being 2d and has x and y attributes."
     _gameobjects_vector = 2
     def __init__(self, x=0, y=0, **kwargs):
-##        kwargs['dims'] = 2
+        kwargs['dims'] = 2
         if not 'dtype' in kwargs:
             kwargs['dtype'] = list
         Vector.__init__(self, x, y, **kwargs)
@@ -450,14 +422,14 @@ class Vector3(Vector2):
     "Vector3. Same as Vector, but stuck being 3d and has x, y, and z attributes."
     _gameobjects_vector = 3
     def __init__(self, x=0, y=0, z=0, **kwargs):
-##        kwargs['dims'] = 3
+        kwargs['dims'] = 3
         if not 'dtype' in kwargs:
             kwargs['dtype'] = list
         Vector.__init__(self, x, y, z, **kwargs)
 
     @classmethod
     def from_iter(cls, iterable, dtype=list):
-        "Return Vector2 from iterable."
+        "Return Vector3 from iterable."
         nxt = iter(iterable).__next__
         return cls(nxt(), nxt(), nxt(), dtype=dtype)
 
@@ -473,14 +445,14 @@ class Vector4(Vector3):
     "Vector4. Same as Vector, but stuck being 4d and has x, y, z, and w attributes."
     _gameobjects_vector = 4
     def __init__(self, x=0, y=0, z=0, w=0, **kwargs):
-##        kwargs['dims'] = 4
+        kwargs['dims'] = 4
         if not 'dtype' in kwargs:
             kwargs['dtype'] = list
         Vector.__init__(self, x, y, z, w, **kwargs)
 
     @classmethod
     def from_iter(cls, iterable, dtype=list):
-        "Return Vector2 from iterable."
+        "Return Vector4 from iterable."
         nxt = iter(iterable).__next__
         return cls(nxt(), nxt(), nxt(), nxt(), dtype=dtype)
 

gameobjects/vector2.py

@@ -1,10 +1,9 @@
-from math import sqrt
-from util import format_number
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 
 from vector import Vector2
 
-if __name__ == "__main__":
-
+if __name__ == '__main__':
     v1 = Vector2(1, 2)
     print(v1('yx'))
     print(Vector2.from_points((5,5), (10,10)))

gameobjects/vector3.py

@@ -1,4 +1,11 @@
-import math
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"Vector3 module"
+
+__title__ = 'vector3'
+
+from math import sqrt
 from util import format_number
 
 from vector import Vector3 as _Vector3
@@ -21,28 +28,24 @@ def distance3d_squared(p1, p2):
 
     return dx*dx + dy*dy +dz*dz
 
-
 def distance3d(p1, p2):
-
     x, y, z = p1
     xx, yy, zz = p2
     dx = x - xx
     dy = y - yy
     dz = z - zz
 
-    return math.sqrt(dx*dx + dy*dy +dz*dz)
+    return sqrt(dx*dx + dy*dy +dz*dz)
 
 def centre_point3d(points):
-
     return sum( Vector3.from_iter(p) for p in points ) / len(points)
 
-
 def test():
     v1 = Vector3(2.2323, 3.43242, 1.)
-
+    
     print(3*v1)
     print((2, 4, 6)*v1)
-
+    
     print((1, 2, 3)+v1)
     print(v1('xxxyyyzzz'))
     print(v1[2])
@@ -55,25 +58,24 @@ def test():
     print(v1.get_length())
     print(repr(v1))
     print(v1[1])
-
+    
     p1 = Vector3(1,2,3)
     print(p1)
     print(repr(p1))
-
+    
     for v in p1:
         print(v)
-
-    #print p1[6]
-
+    
+    #print(p1[6])
+    
     ptest = Vector3( [1,2,3] )
     print(ptest)
-
+    
     z = Vector3()
     print(z)
 
-    file = open
-    file("test.txt", "w").write( "\n".join(str(float(n)) for n in range(20)) )
-    f = map(float, file("test.txt").read().splitlines())
+    open("test.txt", "w").write( "\n".join(str(float(n)) for n in range(20)) )
+    f = map(float, open("test.txt").read().splitlines())
     v1 = Vector3.from_iter( f )
     v2 = Vector3.from_iter( f )
     v3 = Vector3.from_iter( f )
@@ -90,9 +92,9 @@ def test():
     #print(tuple(ptest))
     #p1.set( (4, 5, 6) )
     #print(p1)
-
+    
     print(Vector3(10,10,30)+v1)
-
+    
     print(Vector3((0,0,0,1)))
 
     print(Vector3(1, 2, 3).scale(3))