--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/data/level1	Sun Sep 01 18:28:33 2013 +0200
@@ -0,0 +1,28 @@
+X-Size: 1200
+Y-Size: 900
+Base tile: tiles/floor.png
+Polygon 1 : 12
+Point: 220 770
+Point: 550 770
+Point: 550 470
+Point: 430 350
+Point: 200 350
+Point: 90 460
+Point: 90 670
+Point: 40 720
+Point: 40 800
+Point: 100 860
+Point: 190 770
+Point: 220 770
+Polygon 2 : 11
+Point: 620 830
+Point: 620 750
+Point: 720 650
+Point: 620 550
+Point: 620 430
+Point: 780 430
+Point: 940 590
+Point: 790 740
+Point: 790 840
+Point: 620 840
+Point: 620 830

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/nagslang/level.py	Sun Sep 01 18:28:33 2013 +0200
@@ -0,0 +1,111 @@
+import pygame
+import pygame.locals as pgl
+
+from nagslang.resources import resources
+
+POLY_COLORS = {
+        1: pygame.color.THECOLORS['red'],
+        2: pygame.color.THECOLORS['green'],
+        3: pygame.color.THECOLORS['yellow'],
+        4: pygame.color.THECOLORS['blue'],
+        5: pygame.color.THECOLORS['lightblue'],
+        6: pygame.color.THECOLORS['magenta']
+        }
+
+
+class Level(object):
+
+    def __init__(self, name):
+        self.name = name
+        # defaults
+        self.x = 800
+        self.y = 600
+        self.polygons = {}
+        self.basetile = 'tiles/floor.png'
+        self._tile_image = None
+        self._surface = None
+
+    def load(self):
+
+        def add_polygon(polygon, index, num_points):
+            self.polygons[index] = polygon
+            if len(polygon) != num_points:
+                print 'Error - incorrect polygon size'
+                print 'Expected: %d, got %d' % (num_points, len(polygon))
+
+        levelfile = resources.get_resource_path(self.name)
+        inpoly = False
+        polygon = []
+        index = 0
+        num_points = 0
+        with file(levelfile, 'rU') as f:
+            for line in f:
+                if inpoly:
+                    if not line.startswith('Point:'):
+                        add_polygon(polygon, index, num_points)
+                        polygon = []
+                        inpoly = False
+                        index = 0
+                    else:
+                        point = line.split(':', 1)[1]
+                        x, y = [int(i) for i in point.split()]
+                        polygon.append((x, y))
+                if line.startswith('X-Size:'):
+                    self.x = int(line.split(':', 1)[1])
+                elif line.startswith('Y-Size:'):
+                    self.y = int(line.split(':', 1)[1])
+                elif line.startswith('Base tile:'):
+                    self.basetile = line.split(':', 1)[1].strip()
+                elif line.startswith('Polygon'):
+                    rest = line.split(' ', 1)[1]
+                    index, num_points = [int(x) for x in rest.split(':', 1)]
+                    inpoly = True
+        if index:
+            add_polygon(polygon, index, num_points)
+
+    def get_size(self):
+        return self.x, self.y
+
+    def set_base_tile(self, new_tile):
+        self.basetile = new_tile
+        self._tile_image = None
+
+    def point_to_pygame(self, pos):
+        # Convert a point from pymunk (which is what we store)
+        # to pygame for drawing
+        return (pos[0], self.y - pos[1])
+
+    def get_walls(self):
+        return self.polygons[1]
+
+    def _draw_walls(self):
+        for index, polygon in self.polygons.items():
+            color = POLY_COLORS[index]
+            if len(polygon) > 1:
+                pointlist = [self.point_to_pygame(p) for p in polygon]
+                pygame.draw.lines(self._surface, color, False, pointlist, 2)
+
+    def get_background(self):
+        self._draw_background()
+        # Draw polygons
+        self._draw_walls()
+        return self._surface
+
+    def _draw_background(self, force=False):
+        if self._tile_image is None:
+            self._tile_image = resources.get_image(self.basetile)
+        if self._surface is not None and not force:
+            # We assume we don't change
+            return self._surface
+        self._surface = pygame.surface.Surface((self.x, self.y), pgl.SRCALPHA)
+        self._surface.fill(pygame.color.THECOLORS['black'])
+        x_step = self._tile_image.get_rect().width
+        y_step = self._tile_image.get_rect().height
+        x_count = self.x // x_step + 1
+        y_count = self.y / y_step + 1
+        for x in range(x_count):
+            for y in range(y_count):
+                tile_rect = pygame.rect.Rect(x * x_step, y * y_step,
+                        x_step, y_step)
+                self._surface.blit(self._tile_image, tile_rect)
+        return self._surface

--- a/nagslang/screens/area.py	Sun Sep 01 18:26:15 2013 +0200
+++ b/nagslang/screens/area.py	Sun Sep 01 18:28:33 2013 +0200
@@ -5,6 +5,7 @@
 import pymunk.pygame_util
 
 from nagslang.screens.base import Screen
+from nagslang.level import Level
 from nagslang.events import ScreenChange
 
 
@@ -83,14 +84,16 @@
 
     def setup(self):
         self.keys = ControlKeys()
+        self._level = Level(self.name)
+        self._level.load()
         self.add_walls()
         self.add_protagonist()
 
     def add_walls(self):
         self.walls = []
         body = pymunk.Body()
-        body.position = (400, 300)
-        corners = [(-200, -150), (-200, 150), (200, 150), (200, -150)]
+        body.position = (0, -300)
+        corners = self._level.get_walls()
         corner = corners[-1]
         for next_corner in corners:
             wall = pymunk.Segment(body, corner, next_corner, 50)
@@ -112,8 +115,10 @@
         self.keys.handle_event(ev)
 
     def render(self, surface):
-        surface.fill(pygame.color.Color(0, 0, 0))
-        pymunk.pygame_util.draw(surface, *self.walls)
+        #surface.fill(pygame.color.Color(0, 0, 0))
+        background = self._level.get_background()
+        surface.blit(background, (0, 0))
+        #pymunk.pygame_util.draw(surface, *self.walls)
         self.protagonist.render(surface)
 
     def tick_protagonist(self):