Refactored map loader and added a second map

Also tweaked the font for apostrophe, p, and q

10 files changed, 515 insertions, 370 deletions

@@ -21,4 +21,5 @@ XXX                         XXXXXXXXXXXX
           XXXXXXXXXXXXXXXXXXXX          
     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX      
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
\ No newline at end of file
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+Everything Is Embarrassing
\ No newline at end of file
@@ -0,0 +1,25 @@
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+XXXXXXXXXXXXXXXXXXXXXXXX    XXXXXXXXXXXX
+XXXXXXXXXXXXXXXXXXX              XXXXXXX
+XXXXXXXXXXXXXXX                       XX
+XXXXXXXXXXX                             
+XXXXXXXXXX                              
+XXXXXXXX                                
+XXXXXXXX                                
+XXXXXX                                  
+XXXX                                    
+XXXX                                    
+XXX                                     
+XXX                                     
+XXX                                     
+XXXX                                    
+XXXXXXXXX                               
+XXXXXXXXXXX                             
+XXXXXXXXXXXXXXXXX           XXXXXXXXXXXX
+XXXXXXXXXXXXXXXXX           XXXXXXXXXXXX
+It's A Trap!
\ No newline at end of file
@@ -1,16 +0,0 @@
-XXXXXXXXXXXXXXXX
-XXXXXX    XXXXXX
-XX             X
-X              X
-X           XXXX
-   PPPP         
-                
-   PPPP         
-                
-   PPPP         
-                
-                
-XXXXXXXX       X
-XXXP          XX
-XXXX         XXX
-XXXXXXXXXXXXXXXX
@@ -1,40 +1,26 @@
 #include <ctime>
 #include <list>
 #include "map.h"
+#include "state.h"
+#include "mapview.h"
 #include "renderer.h"
 
 using namespace::std;
 
-const int FRAMES_PER_SECOND = 60;
-bool holding_left = false;
-bool holding_right = false;
 bool quit = false;
-mob_t* player;
 
-// Initialize jump physics
-double jump_height = TILE_HEIGHT*3;
-double jump_length = 0.25 * FRAMES_PER_SECOND;
-double jump_velocity = -2 * jump_height / jump_length;
-double jump_gravity = -1 * jump_velocity / jump_length;
+State* curGameState;
 
 void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
 {
-  if (action == GLFW_PRESS)
+  if ((key == GLFW_KEY_ESCAPE) && (action == GLFW_PRESS))
   {
-    switch (key)
-    {
-      case GLFW_KEY_LEFT: holding_left = true; break;
-      case GLFW_KEY_RIGHT: holding_right = true; break;
-      case GLFW_KEY_UP: player->y_vel = jump_velocity; break;
-      case GLFW_KEY_ESCAPE: quit = true; break;
-    }
-  } else if (action == GLFW_RELEASE)
+    quit = true;
+  }
+  
+  if (curGameState != NULL)
   {
-    switch (key)
-    {
-      case GLFW_KEY_LEFT: holding_left = false; break;
-      case GLFW_KEY_RIGHT: holding_right = false; break;
-    }
+    curGameState->input(key, action);
   }
 }
 
@@ -44,63 +30,30 @@ int main()
   glfwSwapInterval(1);
   glfwSetKeyCallback(window, key_callback);
   
-  Texture* buffer = createTexture(GAME_WIDTH, GAME_HEIGHT);
+  Map* m = new Map("../maps/bigmap.txt");
+  Map* m2 = new Map("../maps/cozy.txt");
   
-  // Initialize player data
-  player = new mob_t();
-  player->x = 100;
-  player->y = 100;
-  player->x_vel = 0;
-  player->y_vel = 0;
-  player->x_accel = 0;
-  player->y_accel = jump_gravity;
-  player->w = 10;
-  player->h = 14;
+  m->setLeftMap(m2);
+  m2->setRightMap(m);
   
-  Map* map = new Map();
-
-  Texture* tiles = loadTextureFromBMP("../res/tiles.bmp");
+  curGameState = new MapView(m, 100, 100);
+  
+  Texture* buffer = createTexture(GAME_WIDTH, GAME_HEIGHT);
   
-  while (!quit)
+  while (!(quit || glfwWindowShouldClose(window)))
   {
-    if (holding_left && player->x_vel >= 0)
-    {
-      player->x_vel = -2;
-    } else if (holding_right && player->x_vel <= 0)
-    {
-      player->x_vel = 2;
-    } else if (!holding_left && !holding_right) {
-      player->x_vel = 0;
-    }
-    
-    player->x_vel += player->x_accel;
-    if (player->x_vel < -16) player->x_vel = -16;
-    if (player->x_vel > 16) player->x_vel = 16;
-    int playerx_next = player->x + player->x_vel;
-    
-    player->y_vel += player->y_accel;
-    if (player->y_vel > 16) player->y_vel = 16; // Terminal velocity
-    if (player->y_vel < -16) player->y_vel = -16;
-    int playery_next = player->y + player->y_vel;
-    
-    map->check_collisions(player, playerx_next, playery_next);
+    // Tick!
+    curGameState->tick();
     
     // Do rendering
-    map->render(buffer);
-    
-    //Rectangle src_rect(96, 0, 8, 8);
-    Rectangle dst_rect(player->x, player->y, player->w, player->h);
-    
-    //blitTexture(tiles, buffer, &src_rect, &dst_rect);
-    fillTexture(buffer, &dst_rect, 255, 255, 255);
-    
+    curGameState->render(buffer);
     renderScreen(buffer);
     
     glfwPollEvents();
   }
   
-  delete map;
-  delete player;
+  delete curGameState;
+  delete m;
   
   destroyRenderer();
   
@@ -1,252 +1,55 @@
 #include "map.h"
+#include "mapview.h"
 
-struct platform_t {
-  int x;
-  int y;
-  int w;
-  int h;
-  bool enter_from_left;
-  bool enter_from_right;
-  bool enter_from_top;
-  bool enter_from_bottom;
-  int r;
-  int g;
-  int b;
-  int a;
-};
-
-Map::Map()
+Map::Map(char* filename)
 {
-  add_collision(-6, 0, GAME_WIDTH, left, 1);
-  add_collision(GAME_WIDTH+6, 0, GAME_WIDTH, right, 1);
-  
-  FILE* f = fopen("../maps/bigmap.txt", "r");
-  char* mapbuf = (char*) malloc(MAP_WIDTH*(MAP_HEIGHT-1)*sizeof(char));
+  FILE* f = fopen(filename, "r");
+  m_mapdata = (char*) malloc(MAP_WIDTH*(MAP_HEIGHT-1)*sizeof(char));
   
   for (int i=0; i<MAP_HEIGHT-1; i++)
   {
-    fread(mapbuf + i*MAP_WIDTH, sizeof(char), MAP_WIDTH, f);
+    fread(m_mapdata + i*MAP_WIDTH, sizeof(char), MAP_WIDTH, f);
     fgetc(f);
   }
   
-  fclose(f);
-  
-  //Texture* tiles = loadTextureFromBMP("../res/tiles.bmp");
-  bg = createTexture(GAME_WIDTH, GAME_HEIGHT);
-  fillTexture(bg, NULL, 0, 0, 0);
-  
-  for (int i=0; i<MAP_WIDTH*(MAP_HEIGHT-1); i++)
-  {
-    int x = i % MAP_WIDTH;
-    int y = i / MAP_WIDTH;
-    Rectangle dst(x*TILE_WIDTH, y*TILE_HEIGHT, TILE_WIDTH, TILE_HEIGHT);
-    //Rectangle src;
-    
-    switch (mapbuf[i])
-    {
-      case ' ': break;
-      case 'X': fillTexture(bg, &dst, 255, 85, 85); break;
-      case 'P': fillTexture(bg, &dst, 85, 255, 255); break;
-    }
-    
-    //blitTexture(tiles, bg, &src, &dst);
-    
-    if (mapbuf[i] == 'X')
-    {
-      if ((x != 0) && (mapbuf[i-1] != 'X'))
-      {
-        add_collision(x*TILE_WIDTH, y*TILE_HEIGHT, (y+1)*TILE_HEIGHT, right, 0);
-      }
-      
-      if ((x != 15) && (mapbuf[i+1] != 'X'))
-      {
-        add_collision((x+1)*TILE_WIDTH, y*TILE_HEIGHT, (y+1)*TILE_HEIGHT, left, 0);
-      }
-      
-      if ((y != 0) && (mapbuf[i-MAP_WIDTH] != 'X'))
-      {
-        add_collision(y*TILE_HEIGHT, x*TILE_WIDTH, (x+1)*TILE_WIDTH, down, 0);
-      }
-      
-      if ((y != 15) && (mapbuf[i+MAP_WIDTH] != 'X'))
-      {
-        add_collision((y+1)*TILE_HEIGHT, x*TILE_WIDTH, (x+1)*TILE_WIDTH, up, 0);
-      }
-    } else if (mapbuf[i] == 'P')
-    {
-      add_collision(y*TILE_HEIGHT, x*TILE_WIDTH, (x+1)*TILE_WIDTH, down, 0);
-    }
-  }
-  
-  Texture* font = loadTextureFromBMP("../res/font.bmp");
-  const char* map_name = "Everything Is Embarassing";
-  int start_x = (40/2) - (strlen(map_name)/2);
-  for (int i=0; i<strlen(map_name); i++)
-  {
-    Rectangle srcRect(map_name[i] % 16 * 8, map_name[i] / 16 * 8, 8, 8);
-    Rectangle dstRect((start_x + i)*8, 24*8, 8, 8);
-    blitTexture(font, bg, &srcRect, &dstRect);
-  }
+  m_title = (char*) calloc(41, sizeof(char));
+  fgets(m_title, 41, f);
   
-  destroyTexture(font);
-  //destroyTexture(tiles);
+  fclose(f);
 }
 
 Map::~Map()
 {
-  destroyTexture(bg);
+  free(m_mapdata);
+  free(m_title);
 }
 
-void Map::add_collision(int axis, int lower, int upper, direction_t dir, int type)
+const char* Map::mapdata()
 {
-  //printf("added collision\n");
-  list<collision_t>::iterator it;
-  
-  switch (dir)
-  {
-    case up:
-      it = up_collisions.begin();
-      for (; it!=up_collisions.end(); it++)
-      {
-        if (it->axis < axis) break;
-      }
-    
-      up_collisions.insert(it, {axis, lower, upper, type});
-      
-      break;
-    case down:
-      it = down_collisions.begin();
-      for (; it!=down_collisions.end(); it++)
-      {
-        if (it->axis > axis) break;
-      }
-    
-      down_collisions.insert(it, {axis, lower, upper, type});
-      
-      break;
-    case left:
-      it = left_collisions.begin();
-      for (; it!=left_collisions.end(); it++)
-      {
-        if (it->axis < axis) break;
-      }
-  
-      left_collisions.insert(it, {axis, lower, upper, type});
-      
-      break;
-    case right:
-      it = right_collisions.begin();
-      for (; it!=right_collisions.end(); it++)
-      {
-        if (it->axis > axis) break;
-      }
-  
-      right_collisions.insert(it, {axis, lower, upper, type});
-      
-      break;
-  }
+  return m_mapdata;
 }
 
-void Map::check_collisions(mob_t* mob, int x_next, int y_next)
+const char* Map::title()
 {
-  if (x_next < mob->x)
-  {
-    for (list<collision_t>::iterator it=left_collisions.begin(); it!=left_collisions.end(); it++)
-    {
-      if (it->axis > mob->x) continue;
-      if (it->axis < x_next) break;
-  
-      if ((mob->y+mob->h > it->lower) && (mob->y < it->upper))
-      {
-        // We have a collision!
-        if (it->type == 0)
-        {
-          x_next = it->axis;
-          mob->x_vel = 0;
-        } else if (it->type == 1)
-        {
-          x_next = GAME_WIDTH-mob->w/2;
-        }
-    
-        break;
-      }
-    }
-  } else if (x_next > mob->x)
-  {
-    for (list<collision_t>::iterator it=right_collisions.begin(); it!=right_collisions.end(); it++)
-    {
-      if (it->axis < mob->x+mob->w) continue;
-      if (it->axis > x_next+mob->w) break;
-  
-      if ((mob->y+mob->h > it->lower) && (mob->y < it->upper))
-      {
-        // We have a collision!
-        if (it->type == 0)
-        {
-          x_next = it->axis - mob->w;
-          mob->x_vel = 0;
-        } else if (it->type == 1)
-        {
-          x_next = -mob->w/2;
-        }
-    
-        break;
-      }
-    }
-  }
-  
-  mob->x = x_next;
-  
-  if (y_next < mob->y)
-  {
-    for (list<collision_t>::iterator it=up_collisions.begin(); it!=up_collisions.end(); it++)
-    {
-      if (it->axis > mob->y) continue;
-      if (it->axis < y_next) break;
-  
-      if ((mob->x+mob->w > it->lower) && (mob->x < it->upper))
-      {
-        // We have a collision!
-        if (it->type == 0)
-        {
-          y_next = it->axis;
-          mob->y_vel = 0;
-        } else if (it->type == 1)
-        {
-          y_next = GAME_HEIGHT-mob->h/2-1;
-        }
-    
-        break;
-      }
-    }
-  } else if (y_next > mob->y)
-  {
-    for (list<collision_t>::iterator it=down_collisions.begin(); it!=down_collisions.end(); it++)
-    {
-      if (it->axis < mob->y+mob->h) continue;
-      if (it->axis > y_next+mob->h) break;
+  return m_title;
+}
 
-      if ((mob->x+mob->w > it->lower) && (mob->x < it->upper))
-      {
-        // We have a collision!
-        if (it->type == 0)
-        {
-          y_next = it->axis - mob->h;
-          mob->y_vel = 0;
-        } else if (it->type == 1)
-        {
-          y_next = 1 - mob->h/2;
-        }
-        
-        break;
-      }
-    }
-  }
-  
-  mob->y = y_next;
+Map* Map::getLeftMap()
+{
+  return m_leftMap;
+}
+
+Map* Map::getRightMap()
+{
+  return m_rightMap;
+}
+
+void Map::setLeftMap(Map* m)
+{
+  m_leftMap = m;
 }
 
-void Map::render(Texture* buffer)
+void Map::setRightMap(Map* m)
 {
-  blitTexture(bg, buffer, NULL, NULL);
+  m_rightMap = m;
 }
@@ -1,42 +1,21 @@
-#include <list>
-#include <vector>
-#include "mob.h"
-#include "renderer.h"
+#ifndef MAP_H
+#define MAP_H
 
-using namespace::std;
-
-const int TILE_WIDTH = 8;
-const int TILE_HEIGHT = 8;
-const int GAME_WIDTH = 320;
-const int GAME_HEIGHT = 200;
-const int MAP_WIDTH = GAME_WIDTH/TILE_WIDTH;
-const int MAP_HEIGHT = GAME_HEIGHT/TILE_HEIGHT;
-
-enum direction_t {
-  up, left, down, right
+class Map {
+  public:
+    Map(char* filename);
+    ~Map();
+    const char* mapdata();
+    const char* title();
+    Map* getLeftMap();
+    Map* getRightMap();
+    void setLeftMap(Map* m);
+    void setRightMap(Map* m);
+  private:
+    char* m_mapdata;
+    char* m_title;
+    Map* m_leftMap = 0;
+    Map* m_rightMap = 0;
 };
 
-typedef struct {
-  int axis;
-  int lower;
-  int upper;
-  int type;
-} collision_t;
-
-class Map {
-public:
-  Map();
-  ~Map();
-  void render(Texture* buffer);
-  void check_collisions(mob_t* mob, int x_next, int y_next);
-  
-private:
-  void add_collision(int axis, int lower, int upper, direction_t dir, int type);
-  
-  list<collision_t> left_collisions;
-  list<collision_t> right_collisions;
-  list<collision_t> up_collisions;
-  list<collision_t> down_collisions;
-  
-  Texture* bg;
-};
\ No newline at end of file
+#endif
@@ -0,0 +1,319 @@
+#include "mapview.h"
+
+// Initialize jump physics
+double jump_height = TILE_HEIGHT*3;
+double jump_length = 0.25 * FRAMES_PER_SECOND;
+double jump_velocity = -2 * jump_height / jump_length;
+double jump_gravity = -1 * jump_velocity / jump_length;
+
+MapView::MapView(Map* first, int x, int y)
+{
+  // Initialize player data
+  player = new mob_t();
+  player->x = x;
+  player->y = y;
+  player->x_vel = 0;
+  player->y_vel = 0;
+  player->x_accel = 0;
+  player->y_accel = jump_gravity;
+  player->w = 10;
+  player->h = 14;
+  
+  loadMap(first);
+}
+
+MapView::~MapView()
+{
+  destroyTexture(bg);
+  
+  delete player;
+}
+
+void MapView::loadMap(Map* m)
+{
+  curMap = m;
+  
+  left_collisions.clear();
+  right_collisions.clear();
+  up_collisions.clear();
+  down_collisions.clear();
+  
+  add_collision(-6, 0, GAME_WIDTH, left, (m->getLeftMap() == NULL) ? 1 : 2);
+  add_collision(GAME_WIDTH+6, 0, GAME_WIDTH, right, (m->getRightMap() == NULL) ? 1 : 2);
+  
+  if (bg == NULL)
+  {
+    bg = createTexture(GAME_WIDTH, GAME_HEIGHT);
+  }
+  
+  fillTexture(bg, NULL, 0, 0, 0);
+  
+  const char* mapbuf = m->mapdata();
+  
+  for (int i=0; i<MAP_WIDTH*(MAP_HEIGHT-1); i++)
+  {
+    int x = i % MAP_WIDTH;
+    int y = i / MAP_WIDTH;
+    Rectangle dst(x*TILE_WIDTH, y*TILE_HEIGHT, TILE_WIDTH, TILE_HEIGHT);
+    //Rectangle src;
+    
+    switch (mapbuf[i])
+    {
+      case ' ': break;
+      case 'X': fillTexture(bg, &dst, 255, 85, 85); break;
+      case 'P': fillTexture(bg, &dst, 85, 255, 255); break;
+    }
+    
+    //blitTexture(tiles, bg, &src, &dst);
+    
+    if (mapbuf[i] == 'X')
+    {
+      if ((x != 0) && (mapbuf[i-1] != 'X'))
+      {
+        add_collision(x*TILE_WIDTH, y*TILE_HEIGHT, (y+1)*TILE_HEIGHT, right, 0);
+      }
+      
+      if ((x != 39) && (mapbuf[i+1] != 'X'))
+      {
+        add_collision((x+1)*TILE_WIDTH, y*TILE_HEIGHT, (y+1)*TILE_HEIGHT, left, 0);
+      }
+      
+      if ((y != 0) && (mapbuf[i-MAP_WIDTH] != 'X'))
+      {
+        add_collision(y*TILE_HEIGHT, x*TILE_WIDTH, (x+1)*TILE_WIDTH, down, 0);
+      }
+      
+      if ((y != 23) && (mapbuf[i+MAP_WIDTH] != 'X'))
+      {
+        add_collision((y+1)*TILE_HEIGHT, x*TILE_WIDTH, (x+1)*TILE_WIDTH, up, 0);
+      }
+    } else if (mapbuf[i] == 'P')
+    {
+      add_collision(y*TILE_HEIGHT, x*TILE_WIDTH, (x+1)*TILE_WIDTH, down, 0);
+    }
+  }
+  
+  Texture* font = loadTextureFromBMP("../res/font.bmp");
+  const char* map_name = m->title();
+  int start_x = (40/2) - (strlen(map_name)/2);
+  for (size_t i=0; i<strlen(map_name); i++)
+  {
+    Rectangle srcRect(map_name[i] % 16 * 8, map_name[i] / 16 * 8, 8, 8);
+    Rectangle dstRect((start_x + i)*8, 24*8, 8, 8);
+    blitTexture(font, bg, &srcRect, &dstRect);
+  }
+  
+  destroyTexture(font);
+}
+
+void MapView::input(int key, int action)
+{
+  if (action == GLFW_PRESS)
+  {
+    switch (key)
+    {
+      case GLFW_KEY_LEFT: holding_left = true; break;
+      case GLFW_KEY_RIGHT: holding_right = true; break;
+      case GLFW_KEY_UP: player->y_vel = jump_velocity; break;
+    }
+  } else if (action == GLFW_RELEASE)
+  {
+    switch (key)
+    {
+      case GLFW_KEY_LEFT: holding_left = false; break;
+      case GLFW_KEY_RIGHT: holding_right = false; break;
+    }
+  }
+}
+
+void MapView::tick()
+{
+  if (holding_left && player->x_vel >= 0)
+  {
+    player->x_vel = -2;
+  } else if (holding_right && player->x_vel <= 0)
+  {
+    player->x_vel = 2;
+  } else if (!holding_left && !holding_right) {
+    player->x_vel = 0;
+  }
+  
+  player->x_vel += player->x_accel;
+  if (player->x_vel < -16) player->x_vel = -16;
+  if (player->x_vel > 16) player->x_vel = 16;
+  int playerx_next = player->x + player->x_vel;
+  
+  player->y_vel += player->y_accel;
+  if (player->y_vel > 16) player->y_vel = 16; // Terminal velocity
+  if (player->y_vel < -16) player->y_vel = -16;
+  int playery_next = player->y + player->y_vel;
+  
+  check_collisions(player, playerx_next, playery_next);
+}
+
+void MapView::render(Texture* tex)
+{
+  // Draw the background
+  blitTexture(bg, tex, NULL, NULL);
+  
+  // Draw the player
+  Rectangle dst_rect(player->x, player->y, player->w, player->h);
+  fillTexture(tex, &dst_rect, 255, 255, 255);
+}
+
+void MapView::add_collision(int axis, int lower, int upper, direction_t dir, int type)
+{
+  //printf("added collision\n");
+  list<collision_t>::iterator it;
+  
+  switch (dir)
+  {
+    case up:
+      it = up_collisions.begin();
+      for (; it!=up_collisions.end(); it++)
+      {
+        if (it->axis < axis) break;
+      }
+    
+      up_collisions.insert(it, {axis, lower, upper, type});
+      
+      break;
+    case down:
+      it = down_collisions.begin();
+      for (; it!=down_collisions.end(); it++)
+      {
+        if (it->axis > axis) break;
+      }
+    
+      down_collisions.insert(it, {axis, lower, upper, type});
+      
+      break;
+    case left:
+      it = left_collisions.begin();
+      for (; it!=left_collisions.end(); it++)
+      {
+        if (it->axis < axis) break;
+      }
+  
+      left_collisions.insert(it, {axis, lower, upper, type});
+      
+      break;
+    case right:
+      it = right_collisions.begin();
+      for (; it!=right_collisions.end(); it++)
+      {
+        if (it->axis > axis) break;
+      }
+  
+      right_collisions.insert(it, {axis, lower, upper, type});
+      
+      break;
+  }
+}
+
+void MapView::check_collisions(mob_t* mob, int x_next, int y_next)
+{
+  if (x_next < mob->x)
+  {
+    for (list<collision_t>::iterator it=left_collisions.begin(); it!=left_collisions.end(); it++)
+    {
+      if (it->axis > mob->x) continue;
+      if (it->axis < x_next) break;
+  
+      if ((mob->y+mob->h > it->lower) && (mob->y < it->upper))
+      {
+        // We have a collision!
+        if (it->type == 0)
+        {
+          x_next = it->axis;
+          mob->x_vel = 0;
+        } else if (it->type == 1)
+        {
+          x_next = GAME_WIDTH-mob->w/2;
+        } else if (it->type == 2)
+        {
+          x_next = GAME_WIDTH-mob->w/2;
+          loadMap(curMap->getLeftMap());
+        }
+    
+        break;
+      }
+    }
+  } else if (x_next > mob->x)
+  {
+    for (list<collision_t>::iterator it=right_collisions.begin(); it!=right_collisions.end(); it++)
+    {
+      if (it->axis < mob->x+mob->w) continue;
+      if (it->axis > x_next+mob->w) break;
+  
+      if ((mob->y+mob->h > it->lower) && (mob->y < it->upper))
+      {
+        // We have a collision!
+        if (it->type == 0)
+        {
+          x_next = it->axis - mob->w;
+          mob->x_vel = 0;
+        } else if (it->type == 1)
+        {
+          x_next = -mob->w/2;
+        } else if (it->type == 2)
+        {
+          x_next = -mob->w/2;
+          loadMap(curMap->getRightMap());
+        }
+    
+        break;
+      }
+    }
+  }
+  
+  mob->x = x_next;
+  
+  if (y_next < mob->y)
+  {
+    for (list<collision_t>::iterator it=up_collisions.begin(); it!=up_collisions.end(); it++)
+    {
+      if (it->axis > mob->y) continue;
+      if (it->axis < y_next) break;
+  
+      if ((mob->x+mob->w > it->lower) && (mob->x < it->upper))
+      {
+        // We have a collision!
+        if (it->type == 0)
+        {
+          y_next = it->axis;
+          mob->y_vel = 0;
+        } else if (it->type == 1)
+        {
+          y_next = GAME_HEIGHT-mob->h/2-1;
+        }
+    
+        break;
+      }
+    }
+  } else if (y_next > mob->y)
+  {
+    for (list<collision_t>::iterator it=down_collisions.begin(); it!=down_collisions.end(); it++)
+    {
+      if (it->axis < mob->y+mob->h) continue;
+      if (it->axis > y_next+mob->h) break;
+
+      if ((mob->x+mob->w > it->lower) && (mob->x < it->upper))
+      {
+        // We have a collision!
+        if (it->type == 0)
+        {
+          y_next = it->axis - mob->h;
+          mob->y_vel = 0;
+        } else if (it->type == 1)
+        {
+          y_next = 1 - mob->h/2;
+        }
+        
+        break;
+      }
+    }
+  }
+  
+  mob->y = y_next;
+}
@@ -0,0 +1,58 @@
+#ifndef MAPVIEW_H
+#define MAPVIEW_H
+
+#include <list>
+#include "state.h"
+#include "mob.h"
+#include "map.h"
+
+using namespace::std;
+
+const int TILE_WIDTH = 8;
+const int TILE_HEIGHT = 8;
+const int GAME_WIDTH = 320;
+const int GAME_HEIGHT = 200;
+const int MAP_WIDTH = GAME_WIDTH/TILE_WIDTH;
+const int MAP_HEIGHT = GAME_HEIGHT/TILE_HEIGHT;
+
+const int FRAMES_PER_SECOND = 60;
+
+enum direction_t {
+  up, left, down, right
+};
+
+typedef struct {
+  int axis;
+  int lower;
+  int upper;
+  int type;
+} collision_t;
+
+class MapView : public State {
+  public:
+    MapView(Map* start, int x, int y);
+    ~MapView();
+    void loadMap(Map* m);
+    void input(int key, int action);
+    void tick();
+    void render(Texture* tex);
+    
+  private:
+    void add_collision(int axis, int lower, int upper, direction_t dir, int type);
+    void check_collisions(mob_t* mob, int x_next, int y_next);
+  
+    list<collision_t> left_collisions;
+    list<collision_t> right_collisions;
+    list<collision_t> up_collisions;
+    list<collision_t> down_collisions;
+  
+    Texture* bg = NULL;
+    
+    bool holding_left = false;
+    bool holding_right = false;
+    mob_t* player;
+    
+    Map* curMap;
+};
+
+#endif
@@ -3,7 +3,7 @@
 #include <fstream>
 #include <vector>
 #include <cstdio>
-#include "map.h"
+#include "mapview.h"
 
 static bool rendererInitialized = false;
 
@@ -27,6 +27,12 @@ static GLuint scanlinesTex;
 static GLuint preBloomTex;
 static GLuint bloomPassTex;
 
+// The VAO
+static GLuint VertexArrayID;
+
+// A plane that fills the renderbuffer
+static GLuint quad_vertexbuffer;
+
 GLuint LoadShaders(const char* vertex_file_path, const char* fragment_file_path)
 { 
     // Create the shaders
@@ -221,7 +227,6 @@ GLFWwindow* initRenderer()
   }
   
   // Set up vertex array object
-  GLuint VertexArrayID;
   glGenVertexArrays(1, &VertexArrayID);
   glBindVertexArray(VertexArrayID);
   
@@ -269,6 +274,20 @@ GLFWwindow* initRenderer()
   
   curBuf = 0;
   
+  // Load the vertices of a flat surface
+  GLfloat g_quad_vertex_buffer_data[] = { 
+                -1.0f, -1.0f, 0.0f,
+                 1.0f, -1.0f, 0.0f,
+                -1.0f,  1.0f, 0.0f,
+                -1.0f,  1.0f, 0.0f,
+                 1.0f, -1.0f, 0.0f,
+                 1.0f,  1.0f, 0.0f,
+        };
+
+  glGenBuffers(1, &quad_vertexbuffer);
+  glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer);
+  glBufferData(GL_ARRAY_BUFFER, sizeof(g_quad_vertex_buffer_data), g_quad_vertex_buffer_data, GL_STATIC_DRAW);
+  
   artifactsTex = loadBMP_custom("../res/artifacts.bmp");
   scanlinesTex = loadBMP_custom("../res/scanlines.bmp");
   
@@ -293,6 +312,9 @@ void destroyRenderer()
     exit(-1);
   }
   
+  // Delete the plane buffer
+  glDeleteBuffers(1, &quad_vertexbuffer);
+  
   // Delete the shaders
   glDeleteProgram(ntscShader);
   glDeleteProgram(finalShader);
@@ -312,6 +334,9 @@ void destroyRenderer()
   // Delete the framebuffer
   glDeleteFramebuffers(1, &FramebufferName);
   
+  // Delete the VAO
+  glDeleteVertexArrays(1, &VertexArrayID);
+  
   // Kill the window
   glfwTerminate();
   
@@ -569,23 +594,9 @@ void renderScreen(Texture* tex)
   glUniform1i(glGetUniformLocation(ntscShader, "NTSCArtifactSampler"), 2);
   glUniform1f(glGetUniformLocation(ntscShader, "NTSCLerp"), curBuf * 1.0);
   
-  // Load the vertices of a flat surface
-  GLfloat g_quad_vertex_buffer_data[] = { 
-                -1.0f, -1.0f, 0.0f,
-                 1.0f, -1.0f, 0.0f,
-                -1.0f,  1.0f, 0.0f,
-                -1.0f,  1.0f, 0.0f,
-                 1.0f, -1.0f, 0.0f,
-                 1.0f,  1.0f, 0.0f,
-        };
-
-  GLuint quad_vertexbuffer;
-  glGenBuffers(1, &quad_vertexbuffer);
-  glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer);
-  glBufferData(GL_ARRAY_BUFFER, sizeof(g_quad_vertex_buffer_data), g_quad_vertex_buffer_data, GL_STATIC_DRAW);
-  
   // Render our composition
   glEnableVertexAttribArray(0);
+  glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer);
   glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
   glDrawArrays(GL_TRIANGLES, 0, 6);
   glDisableVertexAttribArray(0);
@@ -694,7 +705,6 @@ void renderScreen(Texture* tex)
   glfwSwapBuffers(window);
   
   glDeleteBuffers(1, &g_norms);
-  glDeleteBuffers(1, &quad_vertexbuffer);
   
   curBuf = (curBuf + 1) % 2;
 }
@@ -0,0 +1,13 @@
+#ifndef STATE_H
+#define STATE_H
+
+#include "renderer.h"
+
+class State {
+public:
+  virtual void input(int key, int action) = 0;
+  virtual void tick() = 0;
+  virtual void render(Texture* tex) = 0;
+};
+
+#endif