code optimizations. brightness control was deprecated so it got removed.

Author: XenGi

emulator.py

@@ -5,8 +5,8 @@
 pymlgame - Mate Light emulator
 ==============================
 
-This little program emulates the awesome Mate Light, just in case you're not
-at c-base but want to code something for it.
+This little program emulates the awesome Mate Light, just in case you're not on c-base space station but want to send
+something to it.
 """
 
 __author__ = 'Ricardo Band'
@@ -28,31 +28,36 @@ class Emu(object):
     """
     The Emulator is a simple pygame game.
     """
-    def __init__(self, width=50, height=28, ip='127.0.0.1', port=1337):
+    def __init__(self, width=40, height=16, ip='127.0.0.1', port=1337):
         """
-        Creates a screen with the given size, generates the matrix for the
-        Mate bottles and binds the socket for incoming frames.
+        Creates a screen with the given size, generates the matrix for the Mate bottles and binds the socket for
+        incoming frames.
         """
         self.width = width
         self.height = height
         pygame.init()
-        self.screen = pygame.display.set_mode([self.width * 10,
-                                               self.height * 10])
+        # one mate bottle is 10x10px
+        self.screen = pygame.display.set_mode([self.width * 10, self.height * 10])
         pygame.display.set_caption("Mate Light Emu")
         self.clock = pygame.time.Clock()
         self.matrix = []
         for c in range(self.width * self.height * 3):
+            # fill matrix with black color
             self.matrix.append(0)
 
         self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         self.sock.bind((ip, port))
+        # size is width * height * 3 (rgb) + 4 (checksum)
+        self.packetsize = self.width * self.height * 3 + 4
 
     def recv_data(self):
         """
         Grab the next frame and put it on the matrix.
         """
-        data, addr = self.sock.recvfrom(self.width * self.height * 3 + 4)
-        self.matrix = map(ord, data.strip())[:-4]
+        data, addr = self.sock.recvfrom(self.packetsize)
+        matrix = map(ord, data.strip())
+        if len(matrix) == self.packetsize:
+            self.matrix = matrix[:-4]
 
     def update(self):
         """
@@ -64,9 +69,8 @@ def update(self):
                 pixel = y * self.width * 3 + x * 3
                 #TODO: sometimes the matrix is not as big as it should
                 if pixel < pixels:
-                    pygame.draw.circle(self.screen, (self.matrix[pixel],
-                                                     self.matrix[pixel + 1],
-                                                     self.matrix[pixel + 2]),
+                    pygame.draw.circle(self.screen,
+                                       (self.matrix[pixel], self.matrix[pixel + 1], self.matrix[pixel + 2]),
                                        (x * 10 + 5, y * 10 + 5), 5, 0)
 
     def render(self):
@@ -78,8 +82,7 @@ def render(self):
 
     def gameloop(self):
         """
-        Loop through all the necessary stuff and end execution when Ctrl+C
-        was hit.
+        Loop through all the necessary stuff and end execution when Ctrl+C was hit.
         """
         try:
             while True:
@@ -99,4 +102,4 @@ def gameloop(self):
 
 if __name__ == '__main__':
     EMU = Emu()
-    EMU.gameloop()
+    EMU.gameloop()

pymlgame/__init__.py

@@ -9,8 +9,74 @@
 __email__ = '[email protected]'
 __status__ = 'Development'
 
+import socket
+
 from pymlgame.locals import *
 from pymlgame.screen import Screen
 from pymlgame.clock import Clock
 from pymlgame.surface import Surface
-from pymlgame.controller import Controller
+from pymlgame.controller import Controller
+
+
+def init(host='127.0.0.1', port=1337):
+    """
+    Initialize pymlgame. This creates a controller thread that listens for game controllers and events.
+    """
+    global ctlr
+    ctlr = Controller(host, port + 1)
+    ctlr.start()
+
+
+def get_events(maximum=10):
+    """
+    Get all events since the last time you asked for them. You can define a maximum which is 10 by default.
+    """
+    events = []
+    for ev in range(0, maximum):
+        try:
+            if ctlr.queue.empty():
+                break
+            else:
+                events.append(ctlr.queue.get_nowait())
+        except NameError:
+            not_initialized()
+            events = False
+            break
+    return events
+
+
+def get_event():
+    """
+    Get the next event in the queue if there is one.
+    """
+    if not ctlr.queue.empty():
+        return ctlr.queue.get_nowait()
+    else:
+        return False
+
+
+def controller_send(uid, event, data):
+    """
+    Send an event to a connected controller. Use the pymlgame event type and the coorect data payload. For example is
+    you want to send a message to the controller use the event pymlgame.MESSAGE and a string payload.
+
+    It returns the number of bytes send when everything went fine or False when something went wrong.
+    """
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        if uid in ctlr.controllers.keys():
+            addr = ctlr.controllers[uid][0]
+            if event == E_MESSAGE:
+                return sock.sendto('/message/{}'.format(data).encode('utf-8'), (addr, 11338))
+            elif event == E_RUMBLE:
+                return sock.sendto('/rumble/{}'.format(data).encode('utf-8'), (addr, 11338))
+        else:
+            print('This UID ({}) doesn\'t exist.'.format(uid))
+            return False
+    except NameError:
+        not_initialized()
+        return False
+
+
+def not_initialized():
+    print('pymlgame is not initialized correctly. Use pymlgame.init() first.')

pymlgame/locals.py

@@ -14,10 +14,13 @@
 __status__ = 'Development'
 
 # event types
-KEYUP = 0
-KEYDOWN = 1
-NEWCTLR = 2
-PING = 3
+E_KEYUP = 0
+E_KEYDOWN = 1
+E_NEWCTLR = 2
+E_PING = 3
+E_DISCONNECT = 4
+E_MESSAGE = 5
+E_RUMBLE = 6
 
 # controller inputs
 CTLR_UP = 0
@@ -58,7 +61,4 @@
 GREY3 = (178, 178, 178)
 GREY2 = (204, 204, 204)
 GREY1 = (229, 229, 229)
-WHITE = (255, 255, 255)
-
-
-
+WHITE = (255, 255, 255)

pymlgame/surface.py

@@ -31,63 +31,57 @@ def __init__(self, width, height):
         self.matrix = None
         self.fill(pymlgame.BLACK)
 
-    def fill(self, color, brightness=0.1):
+    def fill(self, color):
         """
         Fill the whole screen with the given color.
         """
-        color = self.get_color(color, brightness)
-        self.matrix = [[color for _ in range(self.height)]
-                       for _ in range(self.width)]
+        self.matrix = [[color for _ in range(self.height)] for _ in range(self.width)]
 
-    def draw_dot(self, pos, color, brightness=0.1):
+    def draw_dot(self, pos, color):
         """
         Draw one single dot with the given color on the screen.
         """
-        realcolor = self.get_color(color, brightness)
         if 0 <= pos[0] < self.width and 0 <= pos[1] < self.height:
-            self.matrix[pos[0]][pos[1]] = realcolor
+            self.matrix[pos[0]][pos[1]] = color
 
-    def draw_line(self, start, end, color, brightness=0.1):
+    def draw_line(self, start, end, color):
         """
         Draw a line with the given color on the screen.
         """
         def dist(p, a, b):
-            return abs((b[0] - a[0]) * (a[1] - p[1]) - (a[0] - p[0]) *
-                       (b[1] - a[1])) / math.sqrt((b[0] - a[0])**2 +
-                                                  (b[1] - a[1])**2)
+            return (abs((b[0] - a[0]) * (a[1] - p[1]) - (a[0] - p[0]) * (b[1] - a[1])) /
+                    math.sqrt((b[0] - a[0])**2 + (b[1] - a[1])**2))
 
         points = []
         for x in range(min(start[0], end[0]), max(start[0], end[0]) + 1):
             for y in range(min(start[1], end[1]), max(start[1], end[1]) + 1):
                 if dist((x, y), start, end) < 0.5:
                     points.append((x, y))
         for point in points:
-            self.draw_dot(point, color, brightness)
+            self.draw_dot(point, color)
 
-    def draw_rect(self, pos, size, color, fillcolor=None, brightness=0.1):
+    def draw_rect(self, pos, size, color, fillcolor=None):
         """
         Draw a rectangle with the given color on the screen and optionally fill it with fillcolor.
         """
         # draw top and botton line
         for x in range(size[0]):
-            self.draw_dot((pos[0] + x, pos[1]), color, brightness)
-            self.draw_dot((pos[0] + x, pos[1] + size[1] - 1), color, brightness)
+            self.draw_dot((pos[0] + x, pos[1]), color)
+            self.draw_dot((pos[0] + x, pos[1] + size[1] - 1), color)
         # draw left and right side
         for y in range(size[1]):
-            self.draw_dot((pos[0], pos[1] + y), color, brightness)
-            self.draw_dot((pos[0] + size[0] - 1, pos[1] + y), color, brightness)
+            self.draw_dot((pos[0], pos[1] + y), color)
+            self.draw_dot((pos[0] + size[0] - 1, pos[1] + y), color)
         # draw filled rect
         #TODO: find out if the rect is at least 3x3 to actually have a filling
         if fillcolor:
             for x in range(size[0] - 2):
                 for y in range(size[1] - 2):
-                    self.draw_dot((pos[0] + 1 + x, pos[1] + 1 + y),
-                                  fillcolor, brightness)
+                    self.draw_dot((pos[0] + 1 + x, pos[1] + 1 + y), fillcolor)
 
-    def draw_circle(self, pos, radius, color, fillcolor=None, brightness=0.1):
+    def draw_circle(self, pos, radius, color, fillcolor=None):
         """
-        Draw a circle with the given color on the screen and optionally fill it
-        with fillcolor.
+        Draw a circle with the given color on the screen and optionally fill it with fillcolor.
         """
         #TODO: This still produces rubbish but it's on a good way to success
         def dist(d, p, r):
@@ -106,7 +100,7 @@ def dist(d, p, r):
                 pass
         # draw outline
         for point in points:
-            self.draw_dot(point, color, brightness)
+            self.draw_dot(point, color)
 
     def blit(self, surface, pos=(0, 0)):
         """
@@ -126,11 +120,4 @@ def replace_color(self, before, after):
         for x in range(self.width):
             for y in range(self.height):
                 if self.matrix[x][y] == before:
-                    self.matrix[x][y] = after
-
-    @staticmethod
-    def get_color(color, brightness=0.1):
-        """
-        Returns the color with applied brightness level
-        """
-        return tuple([math.floor(val * brightness) for val in color])
+                    self.matrix[x][y] = after

setup.py

@@ -47,4 +47,4 @@ def read(fname):
       platforms='any',
       license=__license__,
       packages=['pymlgame'],
-      requires=['jsonrpclib-pelix'])
+      requires=[,])