Built out a lot of the GameMap node, as well a laid the skeleton for the Editor node. Kinda learned I need a map editor, so, figured I'd just roll that into the GameMap.

game/nodes.py

     def __init__(self, name="Interface", parent=None):
         try:
             gbe.nodes.NodeSurface.__init__(self, name, parent)
-        except NodeError as e:
+        except gbe.nodes.NodeError as e:
             raise e
 
     def on_render(self):
     def __init__(self, name="GameMap", parent=None):
         try:
             gbe.nodes.Node2D.__init__(self, name, parent)
-        except NodeError as e:
+        except gbe.nodes.NodeError as e:
             raise e
+        self._renderMode = 0 # 0 = Top-down | 1 = Perspective
+        self._layer = {}
+        self._currentLayer = ""
+        self._res = {
+            "environment":"",
+            "walls":""
+        }
+        self._topdown = {
+            "size":8, # Pixels square
+            "wall_color":pygame.Color(255, 255, 255),
+            "blocked_color":pygame.Color(255, 0, 0)
+        }
+        self._orientation = "n"
+
+    @property
+    def environment_resource(self):
+        return self._res["horizon"]
+
+    @property
+    def wall_resource(self):
+        return self._res["walls"]
+
+    @property
+    def layer_count(self):
+        return len(self._layer)
+
+    @property
+    def current_layer(self):
+        return self._currentLayer
+
+    @property
+    def current_layer_width(self):
+        if self._currentLayer != "":
+            return self._layer[self._currentLayer]["w"]
+        return 0
+
+    @property
+    def current_layer_height(self):
+        if self._currentLayer != "":
+            return self._layer[self._currentLayer]["h"]
+        return 0
+
+    @property
+    def layer_names(self):
+        names = []
+        for key in self._layer:
+            names.append(names)
+        return names
+
+
+    def set_resources(self, environment, walls):
+        res = self.resource
+        if environment != self._res["environment"]:
+            if res.is_valid("graphic", environment):
+                self._res["environment"] = environment
+        if walls != self._res["walls"]:
+            if res.is_valid("graphic", walls):
+                self._res["walls"] = walls
+
+
+    def add_layer(self, name, w, h):
+        if name == "" or name in self._layers:
+            return
+        self._layer[name] = {
+            "w":w,
+            "h":h,
+            "cells":[]
+        }
+        for c in range(0, w*h):
+            self._layer[name]["cells"][c] = {
+                "c":0, # Sky / Ceiling
+                "g":0, # Ground
+                "n":[-1,False], # North Wall | [<graphic index, -1 = None>, <blocking>]
+                "s":[-1,False], # South Wall
+                "e":[-1,False], # East Wall
+                "w":[-1,False] # West Wall
+            }
+        if self._currentLayer == "":
+            self._currentLayer = name
+
+    def set_cell_env(self, x, y, ceiling=-1, ground=-1):
+        if self._currentLayer == "":
+            return
+        layer = self._layer[self._currentLayer]
+        if x >= 0 and x < layer["w"] and y >= 0 and y < layer["h"]:
+            index = (y * layer["w"]) + x
+            cell = layer["cells"]
+            if ceiling >= 0:
+                cell[index]["c"] = ceiling
+            if ground >= 0:
+                cell[index]["g"] = ground
+
+    def fill_cell_env(self, x1, y1, x2, y2, ceiling=-1, ground=-1):
+        if self._currentLayer == "":
+            return
+        for y in range(y1, y2+1):
+            for x in range(x1, x2+1):
+                self.set_cell_env(x, y, ceiling, ground)
+
+    def set_cell_face(self, x, y, face, gi=-2, blocking=None):
+        if self._currentLayer == "" or not (face == "n" or face == "s" or face == "w" or face == "e"):
+            return
+        layer = self._layer[self._currentLayer]
+        if x >= 0 and x < layer["w"] and y >= 0 and y < layer["h"]:
+            index = (y * layer["w"]) + x
+            cell = layer["cells"]
+            if gi >= -1:
+                cell[index][face][0] = gi
+                if blocking is not None:
+                    cell[index][face][1] = (blocking == True)
+                else:
+                    if gi == -1: # If gi = -1, there is no wall, so, by default, there is no blocking.
+                        cell[index][face][1] = False
+                    else: # Otherwise, blocking is assumed :)
+                        cell[index][face][1] = True
+            elif blocking is not None:
+                blocking = (blocking == True) # Forcing a boolean
+                cell[index][face][1] = blocking  
+
+    def turn_left(self):
+        onum = self._d_s2n(self._orientation)
+        onum -= 1
+        if onum < 0:
+            onum = 3
+        self._orientation = self._d_n2s(onum)
+
+    def turn_right(self):
+        onum = self._d_s2n(self._orientation)
+        onum += 1
+        if onum > 3:
+            onum = 0
+        self._orientation = self._d_n2s(onum)
+
+
+    def is_passible(self, x, y, d):
+        """
+        Returns true if it's possible to move forward from the x, y map position in the direction given.
+        d - 0 = North, 1 = East, 2 = South, 3 = West
+        """
+        if self._currentLayer == "" or d < 0 or d >= 4:
+            return False
+        layer = self._layer[self._currentLayer]
+        if x >= 0 and x < layer["w"] and y >= 0 and y < layer["h"]:
+            index = (y * layer["w"]) + x
+            d = self._d_n2s(d)
+            return not layer["cells"][index][d][1]
+        return False
+
+
+    def _d_n2s(self, d): # _(d)irection_(n)umber_to_(s)tring
+        if d == 0:
+            return "n"
+        elif d == 1:
+            return "e"
+        elif d == 2:
+            return "s"
+        elif d == 3:
+            return "w"
+        return ""
+
+    def _d_s2n(self, d):
+        if d == "n":
+            return 0
+        elif d == "e":
+            return 1
+        elif d == "s":
+            return 2
+        elif d == "w":
+            return 3
+        return -1
+
+    def _indexFromPos(self, x, y):
+        if x >= 0 and x < self.current_layer_width and y >= 0 and y < self.current_layer_height:
+            return (y * self.current_layer_width) + x
+        return -1
+
+    def _getCell(self, x, y):
+        index = self._indexFromPos(x, y)
+        if index < 0:
+            return None
+        return self._layer[self._currentLayer]["cells"][index]
+
+
+    def _RenderTopDown(self):
+        cell_size = self._topdown["size"]
+        size = self.resolution
+        pos = self.position
+        lsize = (self.current_layer_width, self.current_layer_height)
+        hcells = int(size[0] / cell_size)
+        vcells = int(size[1] / cell_size)
+        cx = pos[0] - int(hcells * 0.5)
+        cy = pos[1] - int(vcells * 0.5)
+        ry = -4
+        for j in range(0, vcells+1):
+            y = cy + j
+            if y >= 0 and y < lsize[1]:
+                rx = -1
+                for i in range(0, hcells+1):
+                    x = cx + i
+                    if x >= 0 and x < lsize[0]:
+                        cell = self._getCell(x, y)
+                        if cell["n"][0] >= 0:
+                            self.draw_rect((rx, ry, cell_size, 2), self._topdown["wall_color"], 0, self._topdown["wall_color"])
+                        if cell["e"][0] >= 0:
+                            self.draw_rect((rx+(cell_size-2), ry, 2, cell_size), self._topdown["wall_color"], 0, self._topdown["wall_color"])
+                        if cell["s"][0] >= 0:
+                            self.draw_rect((rx, ry+(cell_size-2), cell_size, 2), self._topdown["wall_color"], 0, self._topdown["wall_color"])
+                        if cell["w"][0] >= 0:
+                            self.draw_rect((rx, ry, 2, cell_size), self._topdown["wall_color"], 0, self._topdown["wall_color"])
+
+                        if cell["n"][1] == True:
+                            self.draw_lines([(rx+1, ry+1), (rx+(cell_size-1), ry+1)], self._topdown["blocked_color"], 1)
+                        if cell["e"][1] == True:
+                            self.draw_lines([(rx+(cell_size-2), ry+1), (rx+(cell_size-2), ry+(cell_size-2))], self._topdown["blocked_color"], 1)
+                        if cell["s"][1] == True:
+                            self.draw_lines([(rx+1, ry+(cell_size-2)), (rx+(cell_size-2), ry+(cell_size-2))], self._topdown["blocked_color"], 1)
+                        if cell["w"][1] == True:
+                            self.draw_lines([(rx+1, ry+1), (rx+1, ry+(cell_size-2))], self._topdown["blocked_color"], 1)
+                    rx += cell_size    
+            ry += cell_size
+
+
+
+    def _RenderPerspective(self):
+        pass
 
     def on_render(self):
+        if self._renderMode == 0:
+            self._RenderTopDown()
+        else:
+            self._RenderPerspective()
+
+
+
+class MapEditor(gbe.nodes.Node2D):
+    def __init__(self, name="MapEditor", parent=None):
+        try:
+            gbe.nodes.Node2D.__init__(self, name, parent)
+        except gbe.nodes.Node2D as e:
+            raise e
+
+    def on_start(self):
+        pass
+
+    def on_pause(self):
         pass
+
+
+
+
+
+
+
+