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()