4 files changed, 858 insertions, 256 deletions

@@ -3,10 +3,14 @@
 #include <stdexcept>
 #include <memory>
 #include <vector>
+#include <list>
 #include <random>
 #include <fov.h>
-#include <deque>
 #include <iostream>
+#include <tuple>
+#include <set>
+#include "util.h"
+#include "map.h"
 
 class sdl_error : public std::logic_error {
 public:
@@ -82,12 +86,20 @@ enum class Source {
   Player
 };
 
+enum class LoseState {
+  None,
+  PoppingLamps,
+  PoppingPlayer,
+  Outro
+};
+
 const int GAME_WIDTH = 640*2;
 const int GAME_HEIGHT = 480*2;
 const int TILE_WIDTH = 8*2;
-const int TILE_HEIGHT = 8*2;
-const int VIEW_WIDTH = GAME_WIDTH / TILE_WIDTH;
-const int VIEW_HEIGHT = GAME_HEIGHT / TILE_HEIGHT;
+const int TILE_HEIGHT = TILE_WIDTH;
+const int INIT_ZOOM = 10;
+const int ZOOM_X_FACTOR = 8;
+const int ZOOM_Y_FACTOR = 6;
 const int RADIUS = 8;
 
 struct Input {
@@ -97,34 +109,70 @@ struct Input {
   bool down = false;
 };
 
-class Map {
+using coord = std::tuple<int, int>;
+
+struct Kickup {
+  int x;
+  int y;
+  size_t cur;
+  size_t radius;
+  size_t chain;
+  std::set<coord> done;
+  std::set<coord> front;
+};
+
+struct MapData {
+  Tile tile = Tile::Floor;
+  bool lit = false;
+  bool wasLit = false;
+  double visibility = 0.0;
+  size_t dustLife = 0;
+  Source lightType = Source::None;
+  int lightRadius = 0;
+  std::set<coord> litTiles;
+};
+
+class Game {
 public:
 
-  Map() :
-    tiles(VIEW_WIDTH*VIEW_HEIGHT, Tile::Floor),
-    lighting(VIEW_WIDTH*VIEW_HEIGHT, false),
-    lightStrength(VIEW_WIDTH*VIEW_HEIGHT, 0.0),
-    lightSource(VIEW_WIDTH*VIEW_HEIGHT, Source::None)
+  Game(std::mt19937& rng) :
+    rng(rng),
+    map(
+      -INIT_ZOOM * ZOOM_X_FACTOR / 2,
+      -INIT_ZOOM * ZOOM_Y_FACTOR / 2,
+      INIT_ZOOM * ZOOM_X_FACTOR,
+      INIT_ZOOM * ZOOM_Y_FACTOR)
   {
   }
 
-  std::vector<Tile> tiles;
-  std::vector<bool> lighting;
-  std::vector<bool> oldLighting;
-  std::vector<double> lightStrength;
-  std::vector<Source> lightSource;
-  int lightedSpots = 0;
-};
+  std::mt19937& rng;
+
+  Map<MapData> map;
+  std::list<Kickup> kickups;
+  int litSpots = 0;
+  bool dirtyLighting = true;
+  size_t numLamps = 0;
+  size_t numDust = 0;
+
+  int player_x = 0;
+  int player_y = 0;
+  bool renderPlayer = true;
+
+  int curZoom = INIT_ZOOM;
+  int maxZoom = INIT_ZOOM;
 
-int player_x = VIEW_WIDTH / 2;
-int player_y = VIEW_HEIGHT / 2;
+  bool zooming = false;
+  //size_t oldZoom;
+  int zoomProgress = 0;
+
+};
 
 void render(
   SDL_Renderer* ren,
-  const Map& map,
+  const Game& game,
   bool drawDark = true)
 {
-  texture_ptr playerFade;
+  texture_ptr origFade;
   {
     surface_ptr pfs(IMG_Load("../res/lighting.png"));
     if (!pfs)
@@ -132,9 +180,29 @@ void render(
       throw img_error();
     }
 
-    playerFade = texture_ptr(SDL_CreateTextureFromSurface(ren, pfs.get()));
+    origFade = texture_ptr(SDL_CreateTextureFromSurface(ren, pfs.get()));
+  }
+
+  SDL_SetTextureBlendMode(origFade.get(), SDL_BLENDMODE_BLEND);
+
+  texture_ptr playerFade(
+    SDL_CreateTexture(
+      ren,
+      SDL_PIXELFORMAT_RGBA4444,
+      SDL_TEXTUREACCESS_TARGET,
+      144,
+      144));
+
+  if (!playerFade)
+  {
+    throw sdl_error();
   }
 
+  SDL_SetRenderTarget(ren, playerFade.get());
+  SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
+  SDL_RenderClear(ren);
+  SDL_RenderCopy(ren, origFade.get(), nullptr, nullptr);
+
   texture_ptr lampFade(
     SDL_CreateTexture(
       ren,
@@ -143,59 +211,83 @@ void render(
       144,
       144));
 
+  if (!lampFade)
   {
-    SDL_SetRenderTarget(ren, lampFade.get());
+    throw sdl_error();
+  }
 
-    SDL_SetRenderDrawBlendMode(ren, SDL_BLENDMODE_NONE);
-    SDL_SetRenderDrawColor(ren, 255, 255, 255, 0);
-    SDL_RenderFillRect(ren, nullptr);
+  SDL_SetRenderTarget(ren, lampFade.get());
 
-    SDL_RenderCopy(ren, playerFade.get(), nullptr, nullptr);
+  SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
+  SDL_RenderClear(ren);
+  SDL_RenderCopy(ren, origFade.get(), nullptr, nullptr);
+
+  SDL_SetRenderDrawBlendMode(ren, SDL_BLENDMODE_MOD);
+  SDL_SetRenderDrawColor(ren, 255, 204, 58, 255);
+  SDL_RenderFillRect(ren, nullptr);
 
-    SDL_SetRenderDrawBlendMode(ren, SDL_BLENDMODE_MOD);
-    SDL_SetRenderDrawColor(ren, 255, 180, 0, 255);
-    SDL_RenderFillRect(ren, nullptr);
+  texture_ptr dustFade(
+    SDL_CreateTexture(
+      ren,
+      SDL_PIXELFORMAT_RGBA4444,
+      SDL_TEXTUREACCESS_TARGET,
+      144,
+      144));
 
-    SDL_SetRenderTarget(ren, nullptr);
+  if (!dustFade)
+  {
+    throw sdl_error();
   }
 
-  int darkR = 40;
-  int darkG = 40;
-  int darkB = 40;
+  SDL_SetRenderTarget(ren, dustFade.get());
+
+  SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
+  SDL_RenderClear(ren);
+  SDL_RenderCopy(ren, origFade.get(), nullptr, nullptr);
+
+  SDL_SetRenderDrawBlendMode(ren, SDL_BLENDMODE_MOD);
+  SDL_SetRenderDrawColor(ren, 255, 150, 255, 255);
+  SDL_RenderFillRect(ren, nullptr);
 
-  if (!drawDark)
+  texture_ptr canvas(
+    SDL_CreateTexture(
+      ren,
+      SDL_PIXELFORMAT_RGBA8888,
+      SDL_TEXTUREACCESS_TARGET,
+      TILE_WIDTH * game.map.getWidth(),
+      TILE_HEIGHT * game.map.getHeight()));
+
+  if (!canvas)
   {
-    darkR = rand() % 255;
-    darkG = rand() % 255;
-    darkB = rand() % 255;
+    throw sdl_error();
   }
 
-  SDL_SetRenderDrawColor(ren, darkR, darkG, darkB, 255);
+  SDL_SetRenderTarget(ren, canvas.get());
+  SDL_SetRenderDrawBlendMode(ren, SDL_BLENDMODE_NONE);
+  SDL_SetRenderDrawColor(ren, rand() % 255, rand() % 255, rand() % 255, 255);
   SDL_RenderClear(ren);
 
-  for (int y = 0; y < VIEW_HEIGHT; y++)
+  for (int y = game.map.getTop(); y < game.map.getBottom(); y++)
   {
-    for (int x = 0; x < VIEW_WIDTH; x++)
+    for (int x = game.map.getLeft(); x < game.map.getRight(); x++)
     {
       bool draw = true;
 
-      if (player_x == x && player_y == y)
+      if ((game.player_x == x && game.player_y == y) && game.renderPlayer)
       {
         SDL_SetRenderDrawColor(ren, 255, 255, 0, 255);
-      } else if (!map.lighting.at(x+VIEW_WIDTH*y))
+        /*} else if (!game.map.at(x,y).lit)
       {
-        /*if (drawDark)
+        if (drawDark)
         {
           SDL_SetRenderDrawColor(ren, 40, 40, 40, 255);
         } else {
           draw = false;
         }*/
-        draw = false;
       } else {
-        int alpha = map.lightStrength.at(x+y*VIEW_WIDTH) * 255;
-        alpha = 255;
+        int alpha = 255;
 
-        switch (map.tiles.at(x+y*VIEW_WIDTH))
+        switch (game.map.at(x,y).tile)
         {
           case Tile::Floor:
           {
@@ -225,216 +317,322 @@ void render(
 
       if (draw)
       {
-        SDL_Rect rect{x*TILE_WIDTH, y*TILE_HEIGHT, TILE_WIDTH, TILE_HEIGHT};
-
-        SDL_SetRenderDrawBlendMode(ren, SDL_BLENDMODE_BLEND);
-        SDL_RenderFillRect(ren, &rect);
+        SDL_Rect rect {
+          game.map.getTrueX(x) * TILE_WIDTH,
+          game.map.getTrueY(y) * TILE_HEIGHT,
+          TILE_WIDTH,
+          TILE_HEIGHT};
 
+        //SDL_RenderFillRect(ren, &rect);
 
+        //int alpha = (1.0 - game.map.at(x,y).visibility) * 255;
+        //SDL_SetRenderDrawColor(ren, 40, 40, 40, 255);
+        SDL_RenderFillRect(ren, &rect);
       }
     }
   }
 
-  for (int y = 0; y < VIEW_HEIGHT; y++)
+  texture_ptr mask(
+    SDL_CreateTexture(
+      ren,
+      SDL_PIXELFORMAT_RGBA8888,
+      SDL_TEXTUREACCESS_TARGET,
+      TILE_WIDTH * game.map.getWidth(),
+      TILE_HEIGHT * game.map.getHeight()));
+
+  if (!mask)
+  {
+    throw sdl_error();
+  }
+
+  SDL_SetRenderTarget(ren, mask.get());
+  SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
+  SDL_RenderClear(ren);
+
+  for (int y = game.map.getTop(); y < game.map.getBottom(); y++)
   {
-    for (int x = 0; x < VIEW_WIDTH; x++)
+    for (int x = game.map.getLeft(); x < game.map.getRight(); x++)
     {
-      if (map.lightSource.at(x+VIEW_WIDTH*y) != Source::None)
+      if (game.map.at(x,y).lightType != Source::None)
       {
-        SDL_Rect fadeRect{x*TILE_WIDTH + (TILE_WIDTH/2) - (144/2), y*TILE_HEIGHT + (TILE_HEIGHT/2) - (144/2), 144, 144};
-        if (map.lightSource.at(x+VIEW_WIDTH*y) == Source::Lamp)
+        texture_ptr sourceMask(
+          SDL_CreateTexture(
+            ren,
+            SDL_PIXELFORMAT_RGBA8888,
+            SDL_TEXTUREACCESS_TARGET,
+            TILE_WIDTH * game.map.getWidth(),
+            TILE_HEIGHT * game.map.getHeight()));
+
+        if (!sourceMask)
         {
-          //SDL_SetTextureBlendMode(lampFade.get(), SDL_BLENDMODE_MOD);
-          SDL_RenderCopy(ren, lampFade.get(), nullptr, &fadeRect);
-          //SDL_SetRenderDrawColor(ren, 255, 180, 0, 50);
-          //SDL_SetRenderDrawBlendMode(ren, SDL_BLENDMODE_BLEND);
-          //SDL_RenderFillRect(ren, &rect);
-        } else if (map.lightSource.at(x+VIEW_WIDTH*y) == Source::Player)
+          throw sdl_error();
+        }
+
+        SDL_SetRenderTarget(ren, sourceMask.get());
+        SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
+        SDL_RenderClear(ren);
+
+        SDL_SetRenderDrawColor(ren, 255, 255, 255, 255);
+
+        for (const coord& xy : game.map.at(x,y).litTiles)
         {
-          //SDL_SetTextureBlendMode(playerFade.get(), SDL_BLENDMODE_MOD);
+          SDL_Rect rect {
+            game.map.getTrueX(std::get<0>(xy)) * TILE_WIDTH,
+            game.map.getTrueY(std::get<1>(xy)) * TILE_HEIGHT,
+            TILE_WIDTH,
+            TILE_HEIGHT};
+
+          SDL_RenderFillRect(ren, &rect);
+        }
+
+        SDL_Rect fadeRect {
+          (game.map.getTrueX(x) - game.map.at(x,y).lightRadius) * TILE_WIDTH,
+          (game.map.getTrueY(y) - game.map.at(x,y).lightRadius) * TILE_HEIGHT,
+          (game.map.at(x,y).lightRadius * 2 + 1) * TILE_WIDTH,
+          (game.map.at(x,y).lightRadius * 2 + 1) * TILE_HEIGHT};
+
+        if (game.map.at(x,y).lightType == Source::Lamp)
+        {
+          SDL_SetTextureBlendMode(lampFade.get(), SDL_BLENDMODE_MOD);
+          SDL_RenderCopy(ren, lampFade.get(), nullptr, &fadeRect);
+        } else if (game.map.at(x,y).lightType == Source::Player) {
+          SDL_SetTextureBlendMode(playerFade.get(), SDL_BLENDMODE_MOD);
           SDL_RenderCopy(ren, playerFade.get(), nullptr, &fadeRect);
+        } else if (game.map.at(x,y).lightType == Source::Dust) {
+          SDL_SetTextureBlendMode(dustFade.get(), SDL_BLENDMODE_MOD);
+          SDL_RenderCopy(ren, dustFade.get(), nullptr, &fadeRect);
         }
 
-        /*SDL_SetRenderDrawColor(ren, 40, 40, 40, alpha);
-        SDL_SetRenderDrawBlendMode(ren, SDL_BLENDMODE_BLEND);
-        SDL_RenderFillRect(ren, &rect);*/
+        SDL_SetRenderTarget(ren, mask.get());
+        SDL_SetTextureBlendMode(sourceMask.get(), SDL_BLENDMODE_ADD);
+        SDL_RenderCopy(ren, sourceMask.get(), nullptr, nullptr);
       }
     }
   }
 
-  SDL_SetRenderDrawBlendMode(ren, SDL_BLENDMODE_NONE);
-  SDL_SetRenderDrawColor(ren, darkR, darkG, darkB, 255);
+  SDL_SetRenderTarget(ren, canvas.get());
+  SDL_SetTextureBlendMode(mask.get(), SDL_BLENDMODE_MOD);
+  SDL_RenderCopy(ren, mask.get(), nullptr, nullptr);
 
-  for (int y = 0; y < VIEW_HEIGHT; y++)
-  {
-    for (int x = 0; x < VIEW_WIDTH; x++)
-    {
-      if (!map.lighting.at(x+VIEW_WIDTH*y))
-      {
-        SDL_Rect rect{x*TILE_WIDTH, y*TILE_HEIGHT, TILE_WIDTH, TILE_HEIGHT};
+  SDL_SetRenderTarget(ren, nullptr);
 
-        SDL_RenderFillRect(ren, &rect);
-      }
-    }
+  if (!game.zooming)
+  {
+    SDL_RenderCopy(ren, canvas.get(), nullptr, nullptr);
+  } else {
+    // TODO: zooming back in to the player
+    SDL_Rect zoomRect {
+      ((game.maxZoom - game.curZoom) * TILE_WIDTH + game.zoomProgress)
+        * ZOOM_X_FACTOR / 2,
+      ((game.maxZoom - game.curZoom) * TILE_HEIGHT + game.zoomProgress)
+        * ZOOM_Y_FACTOR / 2,
+      (game.curZoom * TILE_WIDTH - game.zoomProgress) * ZOOM_X_FACTOR,
+      (game.curZoom * TILE_HEIGHT - game.zoomProgress) * ZOOM_Y_FACTOR
+    };
+
+    SDL_RenderCopy(ren, canvas.get(), &zoomRect, nullptr);
   }
 
   SDL_RenderPresent(ren);
 }
 
-void incrementIfSet(Map& map, int& count, int x, int y, int w, int h, Tile val = Tile::Wall)
+void incrementIfSet(Game& game, int& count, int x, int y, Tile val = Tile::Wall)
 {
-  if ((x >= 0) && (x < w) && (y >= 0) && (y < h) && (map.tiles[x+w*y] == val))
+  if (game.map.inBounds(x, y) && game.map.at(x,y).tile == val)
   {
     count++;
   }
 }
 
-void tick(Map& map, int x1 = 0, int y1 = 0, int x2 = VIEW_WIDTH, int y2 = VIEW_HEIGHT, bool onlyDark = false)
+void tick(
+  Game& game,
+  int x1,
+  int y1,
+  int x2,
+  int y2,
+  bool invert = false,
+  bool onlyDark = false)
 {
-  std::vector<Tile> temp(map.tiles);
+  Map<MapData> temp(game.map);
 
-  for (int y = std::max(y1, 0); y < std::min(y2, VIEW_HEIGHT); y++)
+  for (int y = game.map.getTop(); y < game.map.getBottom(); y++)
   {
-    for (int x = std::max(x1, 0); x < std::min(x2, VIEW_WIDTH); x++)
+    for (int x = game.map.getLeft(); x < game.map.getRight(); x++)
     {
-      if (onlyDark && map.lighting[x+y*VIEW_WIDTH])
+      if (invert == (x >= x1 && x < x2 && y >= y1 && y < y2))
+      {
+        continue;
+      }
+
+      if (onlyDark && game.map.at(x,y).lit)
       {
         continue;
       }
 
-      if (map.tiles[x+y*VIEW_WIDTH] == Tile::Lamp)
+      if (game.map.at(x,y).tile == Tile::Lamp)
       {
         continue;
       }
 
       int count = 0;
 
-      incrementIfSet(map, count, x-1, y-1, VIEW_WIDTH, VIEW_HEIGHT);
-      incrementIfSet(map, count, x-1, y  , VIEW_WIDTH, VIEW_HEIGHT);
-      incrementIfSet(map, count, x-1, y+1, VIEW_WIDTH, VIEW_HEIGHT);
-      incrementIfSet(map, count, x  , y-1, VIEW_WIDTH, VIEW_HEIGHT);
-      incrementIfSet(map, count, x  , y  , VIEW_WIDTH, VIEW_HEIGHT);
-      incrementIfSet(map, count, x  , y+1, VIEW_WIDTH, VIEW_HEIGHT);
-      incrementIfSet(map, count, x+1, y-1, VIEW_WIDTH, VIEW_HEIGHT);
-      incrementIfSet(map, count, x+1, y  , VIEW_WIDTH, VIEW_HEIGHT);
-      incrementIfSet(map, count, x+1, y+1, VIEW_WIDTH, VIEW_HEIGHT);
+      incrementIfSet(game, count, x-1, y-1);
+      incrementIfSet(game, count, x-1, y  );
+      incrementIfSet(game, count, x-1, y+1);
+      incrementIfSet(game, count, x  , y-1);
+      incrementIfSet(game, count, x  , y  );
+      incrementIfSet(game, count, x  , y+1);
+      incrementIfSet(game, count, x+1, y-1);
+      incrementIfSet(game, count, x+1, y  );
+      incrementIfSet(game, count, x+1, y+1);
 
       if (count >= 5)
       {
-        temp[x+VIEW_WIDTH*y] = Tile::Wall;
+        temp.at(x,y).tile = Tile::Wall;
       } else {
-        temp[x+VIEW_WIDTH*y] = Tile::Floor;
+        temp.at(x,y).tile = Tile::Floor;
       }
     }
   }
 
-  map.tiles = temp;
+  game.map = std::move(temp);
 }
 
-void movePlayer(int x, int y, Map& map)
+void tick(Game& game, bool onlyDark = false)
 {
-  if ((x >= 0) && (x < VIEW_WIDTH) && (y >= 0) && (y < VIEW_HEIGHT) &&
-      map.tiles[x+VIEW_WIDTH*y] == Tile::Floor)
+  tick(
+    game,
+    game.map.getLeft(),
+    game.map.getTop(),
+    game.map.getRight(),
+    game.map.getBottom(),
+    false,
+    onlyDark);
+}
+
+void movePlayer(Game& game, int x, int y)
+{
+  if (game.map.inBounds(x, y) && game.map.at(x,y).tile == Tile::Floor)
   {
-    if (map.tiles[player_x+player_y*VIEW_WIDTH] == Tile::Floor)
+    if (game.map.at(game.player_x, game.player_y).tile == Tile::Floor)
     {
-      map.tiles[player_x+player_y*VIEW_WIDTH] = Tile::Dust;
+      game.map.at(game.player_x, game.player_y).tile = Tile::Dust;
+      game.map.at(game.player_x, game.player_y).dustLife = 1;
+      game.numDust++;
     }
 
-    player_x = x;
-    player_y = y;
+    game.player_x = x;
+    game.player_y = y;
+
+    game.dirtyLighting = true;
   }
 }
 
-void setIfValid(Map& map, int x, int y, Tile val)
+void recalculateLighting(Game& game, fov_settings_type* fov)
 {
-  if ((x >= 0) && (x < VIEW_WIDTH) && (y >= 0) && (y < VIEW_HEIGHT))
+  game.litSpots = 0;
+
+  for (MapData& md : game.map.data())
   {
-    map.tiles[x+VIEW_WIDTH*y] = val;
+    md.wasLit = md.lit;
+    md.lit = false;
+    md.visibility = 0.0;
+    md.litTiles.clear();
   }
-}
-
-void recalculateLighting(Map& map, fov_settings_type* fov)
-{
-  map.oldLighting = map.lighting;
-  map.lighting = std::vector<bool>(VIEW_WIDTH*VIEW_HEIGHT, false);
-  map.lightStrength = std::vector<double>(VIEW_WIDTH*VIEW_HEIGHT, 0.0);
-  map.lightedSpots = 0;
-  map.lightSource = std::vector<Source>(VIEW_WIDTH*VIEW_HEIGHT, Source::None);
 
   fov_settings_set_opacity_test_function(
     fov,
-    [] (void* map, int x, int y) {
-      return
-        x >= 0 &&
-        x < VIEW_WIDTH &&
-        y >= 0 &&
-        y < VIEW_HEIGHT &&
-        static_cast<Map*>(map)->tiles.at(x+VIEW_WIDTH*y) == Tile::Wall;
+    [] (void* data, int x, int y) {
+      Game& game = *static_cast<Game*>(data);
+
+      return game.map.inBounds(x,y) && game.map.at(x,y).tile == Tile::Wall;
     });
 
   fov_settings_set_apply_lighting_function(
     fov,
-    [] (void* map, int x, int y, int dx, int dy, void* source) {
-      if ((x >= 0) && (x < VIEW_WIDTH) && (y >= 0) && (y < VIEW_HEIGHT))
+    [] (void* data, int x, int y, int dx, int dy, void* source) {
+      Game& game = *static_cast<Game*>(data);
+
+      if (game.map.inBounds(x, y))
       {
-        Map& m = *static_cast<Map*>(map);
-        if (!m.lighting[x+VIEW_WIDTH*y])
+        MapData& sourceData = *static_cast<MapData*>(source);
+        double lightRadius = static_cast<double>(sourceData.lightRadius);
+
+        if (!game.map.at(x,y).lit)
         {
-          m.lightedSpots++;
+          game.litSpots++;
         }
 
-        m.lighting[x+VIEW_WIDTH*y] = true;
+        game.map.at(x,y).lit = true;
 
-        m.lightStrength[x+VIEW_WIDTH*y] = std::max(
-          m.lightStrength[x+VIEW_WIDTH*y],
+        /*game.map.at(x,y).visibility = std::max(
+          game.map.at(x,y).visibility,
           std::pow(
             std::max(
               0.0,
-              1.0 - std::sqrt(dx * dx + dy * dy) / static_cast<double>(RADIUS)),
-            1.0/3.0));
+              1.0 - std::sqrt(dx * dx + dy * dy) / lightRadius),
+            1.0/3.0));*/
+
+        sourceData.litTiles.emplace(x,y);
 
-        Source ls = *static_cast<Source*>(source);
-        if (static_cast<size_t>(ls) > static_cast<size_t>(m.lightSource[x+VIEW_WIDTH*y]))
+        //Source ls = *static_cast<Source*>(source);
+        //if (static_cast<size_t>(ls) > static_cast<size_t>(m.lightSource[x+VIEW_WIDTH*y]))
         {
           //m.lightSource[x+VIEW_WIDTH*y] = ls;
         }
       }
     });
 
-  for (int y = 0; y < VIEW_HEIGHT; y++)
+  for (int y = game.map.getTop(); y < game.map.getBottom(); y++)
   {
-    for (int x = 0; x < VIEW_WIDTH; x++)
+    for (int x = game.map.getLeft(); x < game.map.getRight(); x++)
     {
       Source ls = Source::None;
+      int lightRadius;
 
-      if (player_x == x && player_y == y)
+      if (game.renderPlayer && game.player_x == x && game.player_y == y)
       {
         ls = Source::Player;
-      } else if (map.tiles[x+VIEW_WIDTH*y] == Tile::Dust)
+        lightRadius = RADIUS;
+      } else if (game.map.at(x,y).tile == Tile::Dust)
       {
         ls = Source::Dust;
-      } else if (map.tiles[x+VIEW_WIDTH*y] == Tile::Lamp)
+        lightRadius = 2;
+      } else if (game.map.at(x,y).tile == Tile::Lamp)
       {
         ls = Source::Lamp;
+        lightRadius = RADIUS;
       }
 
+      game.map.at(x,y).lightType = ls;
+      //game.map.at(x,y).litTiles.clear();
+
       if (ls != Source::None)
       {
-        fov_circle(fov, static_cast<void*>(&map), static_cast<void*>(&ls), x, y, RADIUS);
-
-        map.lighting[x+VIEW_WIDTH*y] = true;
-        map.lightStrength[x+VIEW_WIDTH*y] = 1.0;
-        map.lightSource[x+VIEW_WIDTH*y] = ls;
+        game.map.at(x,y).lightRadius = lightRadius;
+        game.map.at(x,y).litTiles.emplace(x,y);
+
+        fov_circle(
+          fov,
+          static_cast<void*>(&game),
+          static_cast<void*>(&game.map.at(x,y)),
+          x,
+          y,
+          lightRadius);
+
+        game.map.at(x,y).lit = true;
+        game.map.at(x,y).visibility = 1.0;
       }
     }
   }
+
+  game.dirtyLighting = false;
 }
 
-void processKeys(Map& map, const Input& keystate)
+void processKeys(Game& game, const Input& keystate)
 {
-  int px = player_x;
-  int py = player_y;
+  int px = game.player_x;
+  int py = game.player_y;
 
   if (keystate.up)
   {
@@ -456,12 +654,164 @@ void processKeys(Map& map, const Input& keystate)
     px++;
   }
 
-  if (!(player_x == px && player_y == py))
+  if (!(game.player_x == px && game.player_y == py))
   {
-    movePlayer(px, py, map);
+    movePlayer(game, px, py);
   }
 }
 
+void kickUpDust(Game& game, int x, int y, size_t chain)
+{
+  Kickup dk;
+  dk.x = x;
+  dk.y = y;
+  dk.chain = chain;
+  dk.cur = 0;
+  dk.radius = RADIUS + (chain + 1) * (chain + 1);
+  dk.front.emplace(x, y);
+  dk.done.emplace(x, y);
+
+  game.kickups.push_back(dk);
+}
+
+void popLamp(Game& game, int x, int y, size_t chain)
+{
+  if (game.map.at(x,y).tile == Tile::Lamp)
+  {
+    game.numLamps--;
+  }
+
+  game.map.at(x,y).tile = Tile::Dust;
+  game.map.at(x,y).dustLife = 2;
+  game.numDust++;
+  game.dirtyLighting = true;
+
+  kickUpDust(game, x, y, chain);
+}
+
+void processKickup(Game& game)
+{
+  for (Kickup& kickup : game.kickups)
+  {
+    kickup.cur++;
+
+    std::set<coord> newFront;
+    for (const coord& xy : kickup.front)
+    {
+      auto processDir = [&] (int x, int y) {
+        coord c {x,y};
+
+        if (game.map.inBounds(x,y) &&
+            (game.map.at(x,y).tile == Tile::Floor ||
+              game.map.at(x,y).tile == Tile::Lamp) &&
+            !kickup.done.count(c))
+        {
+          newFront.insert(c);
+          kickup.done.insert(c);
+
+          if (game.map.at(x,y).tile == Tile::Floor)
+          {
+            game.map.at(x,y).tile = Tile::Dust;
+            game.map.at(x,y).dustLife = 2;
+            game.numDust++;
+            game.dirtyLighting = true;
+          } else if (game.map.at(x,y).tile == Tile::Lamp)
+          {
+            popLamp(game, x, y, kickup.chain + 1);
+          }
+        }
+      };
+
+      processDir(std::get<0>(xy) - 1, std::get<1>(xy)    );
+      processDir(std::get<0>(xy) + 1, std::get<1>(xy)    );
+      processDir(std::get<0>(xy)    , std::get<1>(xy) - 1);
+      processDir(std::get<0>(xy)    , std::get<1>(xy) + 1);
+
+      if (std::bernoulli_distribution(0.5)(game.rng))
+      {
+        processDir(std::get<0>(xy) - 1, std::get<1>(xy) - 1);
+      }
+
+      if (std::bernoulli_distribution(0.5)(game.rng))
+      {
+        processDir(std::get<0>(xy) - 1, std::get<1>(xy) + 1);
+      }
+
+      if (std::bernoulli_distribution(0.5)(game.rng))
+      {
+        processDir(std::get<0>(xy) + 1, std::get<1>(xy) - 1);
+      }
+
+      if (std::bernoulli_distribution(0.5)(game.rng))
+      {
+        processDir(std::get<0>(xy) + 1, std::get<1>(xy) + 1);
+      }
+    }
+
+    kickup.front.swap(newFront);
+  }
+
+  erase_if(
+    game.kickups,
+    [] (const Kickup& kickup) {
+      return kickup.cur == kickup.radius;
+    });
+}
+
+void growMap(Game& game, size_t zoom)
+{
+  int ol = game.map.getLeft();
+  int ot = game.map.getTop();
+  int ow = game.map.getWidth();
+  int oh = game.map.getHeight();
+
+  game.map.resize(
+    -zoom * ZOOM_X_FACTOR / 2,
+    -zoom * ZOOM_Y_FACTOR / 2,
+    zoom * ZOOM_X_FACTOR,
+    zoom * ZOOM_Y_FACTOR);
+
+  game.maxZoom = zoom;
+
+  for (int y = game.map.getTop(); y < game.map.getBottom(); y++)
+  {
+    for (int x = game.map.getLeft(); x < game.map.getRight(); x++)
+    {
+      if (!(x >= ol && x < (ol + ow) && y >= ot && y < (ot + oh)))
+      {
+        if (std::bernoulli_distribution(0.5)(game.rng))
+        {
+          game.map.at(x,y).tile = Tile::Wall;
+        }
+      }
+    }
+  }
+
+  for (int i = 0; i < 3; i++)
+  {
+    tick(game, ol, ot, ol + ow, ot + oh, true);
+  }
+}
+
+void setZoom(Game& game, size_t zoom)
+{
+  if (zoom == game.curZoom)
+  {
+    return;
+  }
+
+  if (zoom > game.maxZoom)
+  {
+    growMap(game, zoom);
+  }
+
+  // TODO: don't think this works well with rapid zoom changes
+  game.zoomProgress += (zoom - game.curZoom) * TILE_WIDTH;
+  //game.oldZoom = game.curZoom;
+  game.curZoom = zoom;
+  game.zooming = true;
+}
+
 int main(int, char**)
 {
   std::random_device randomEngine;
@@ -498,121 +848,112 @@ int main(int, char**)
       throw sdl_error();
     }
 
-    Map map;
+    SDL_SetRenderDrawBlendMode(ren.get(), SDL_BLENDMODE_BLEND);
+
+    Game game(rng);
 
     std::unique_ptr<fov_settings_type> fov(new fov_settings_type());
     fov_settings_init(fov.get());
 
-    for (int y = 0; y < VIEW_HEIGHT; y++)
+    for (MapData& md : game.map.data())
     {
-      for (int x = 0; x < VIEW_WIDTH; x++)
+      if (std::bernoulli_distribution(0.5)(rng))
       {
-        if (std::bernoulli_distribution(0.5)(rng))
-        {
-          map.tiles[x+y*VIEW_WIDTH] = Tile::Wall;
-        }
+        md.tile = Tile::Wall;
+      }
+    }
+
+    tick(game);
+    tick(game);
+
+    for (int y = -1; y <= 1; y++)
+    {
+      for (int x = -1; x <= 1; x++)
+      {
+        game.map.at(x,y).tile = Tile::Floor;
       }
     }
 
-    tick(map);
-    tick(map);
-    tick(map);
+    tick(game);
 
     bool quit = false;
+    LoseState losing = LoseState::None;
     Input keystate;
     SDL_Event e;
+
+    size_t dustDt = 40;
+    size_t dustAcc = 0;
+
+    size_t inputDt = 50;
+    size_t inputAcc = 0;
+
+    size_t losePopLampDt = 800;
+    size_t losePopLampAcc = losePopLampDt;
+
+    size_t losePopPlayerDt = 3000;
+    size_t losePopPlayerAcc = 0;
+
+    size_t zoomDt = 62;
+    size_t zoomAcc = 0;
+
+    size_t lastTime = SDL_GetTicks();
+
     while (!quit)
     {
-      //bool input = false;
-      //int presses = 0;
-      bool pressedSpace = false;
+      size_t currentTime = SDL_GetTicks();
+      size_t frameTime = currentTime - lastTime;
+      lastTime = currentTime;
+
       while (SDL_PollEvent(&e))
       {
         if (e.type == SDL_QUIT)
         {
-          quit = true;
+          if (losing != LoseState::None)
+          {
+            quit = true;
+          } else {
+            losing = LoseState::PoppingLamps;
+          }
         } else if (e.type == SDL_KEYDOWN)
         {
-          //presses++;
-
           switch (e.key.keysym.sym)
           {
             case SDLK_ESCAPE:
             {
-              quit = true;
+              if (losing != LoseState::None)
+              {
+                quit = true;
+              } else {
+                losing = LoseState::PoppingLamps;
+              }
+
               break;
             }
 
             case SDLK_SPACE:
             {
-              pressedSpace = true;
-              //input = true;
-
-              std::deque<std::tuple<int, int>> lamps;
-              lamps.emplace_back(player_x, player_y);
-
-              setIfValid(map, player_x  , player_y  , Tile::Lamp);
-
-              for (int i = 0; i < 5; i++)
-              {
-                processKeys(map, keystate);
-
-                tick(
-                  map,
-                  player_x - (RADIUS - 1),
-                  player_y - (RADIUS - 1),
-                  player_x + RADIUS,
-                  player_y + RADIUS);
-
-                render(ren.get(), map, false);
-                SDL_Delay(30);
-              }
-
-              int lamped = 0;
-              while (!lamps.empty())
+              if (losing == LoseState::None)
               {
-                lamped++;
-
-                int px, py;
-                std::tie(px, py) = lamps.front();
-                lamps.pop_front();
-
-                std::unique_ptr<fov_settings_type> dusty(new fov_settings_type);
-                fov_settings_set_opacity_test_function(
-                  dusty.get(),
-                  [] (void* map, int x, int y) {
-                    return
-                      x >= 0 &&
-                      x < VIEW_WIDTH &&
-                      y >= 0 &&
-                      y < VIEW_HEIGHT &&
-                      static_cast<Map*>(map)->tiles.at(x+VIEW_WIDTH*y) == Tile::Wall;
-                  });
-
-                fov_settings_set_apply_lighting_function(
-                  dusty.get(),
-                  [] (void* map, int x, int y, int, int, void* source) {
-                    Map& m = *static_cast<Map*>(map);
-                    auto& lamps = *static_cast<std::deque<std::pair<int, int>>*>(source);
-
-                    if ((x >= 0) && (x < VIEW_WIDTH) &&
-                        (y >= 0) && (y < VIEW_HEIGHT))
-                    {
-                      if (m.tiles[x+VIEW_WIDTH*y] == Tile::Floor)
-                      {
-                        m.tiles[x+VIEW_WIDTH*y] = Tile::Dust;
-                      } else if (m.tiles[x+VIEW_WIDTH*y] == Tile::Lamp)
-                      {
-                        m.tiles[x+VIEW_WIDTH*y] = Tile::Dust;
-                        lamps.emplace_back(x, y);
-                      }
-                    }
-                  });
-
-                fov_circle(dusty.get(), static_cast<void*>(&map), static_cast<void*>(&lamps), px, py, RADIUS+lamped*lamped);
-
-                render(ren.get(), map, false);
-                SDL_Delay(50);
+                if (game.map.at(game.player_x, game.player_y).tile ==
+                      Tile::Floor)
+                {
+                  game.map.at(game.player_x, game.player_y).tile = Tile::Lamp;
+                  game.numLamps++;
+                  game.dirtyLighting = true;
+                  kickUpDust(game, game.player_x, game.player_y, 0);
+
+                  for (int i = 0; i < 5; i++)
+                  {
+                    processKeys(game, keystate);
+
+                    tick(
+                      game,
+                      game.player_x - (RADIUS - 1),
+                      game.player_y - (RADIUS - 1),
+                      game.player_x + RADIUS,
+                      game.player_y + RADIUS);
+                  }
+                }
               }
 
               break;
@@ -627,50 +968,164 @@ int main(int, char**)
       keystate.up = state[SDL_SCANCODE_UP];
       keystate.down = state[SDL_SCANCODE_DOWN];
 
-      bool input = keystate.left || keystate.right || keystate.up || keystate.down || pressedSpace;
+      dustAcc += frameTime;
+      inputAcc += frameTime;
 
-      if (input)
+      while (dustAcc >= dustDt)
       {
-        for (int y = 0; y < VIEW_HEIGHT; y++)
+        game.numDust = 0;
+
+        for (MapData& md : game.map.data())
         {
-          for (int x = 0; x < VIEW_WIDTH; x++)
+          if (md.tile == Tile::Dust)
           {
-            if (map.tiles[x+y*VIEW_WIDTH] == Tile::Dust)
+            md.dustLife--;
+
+            if (md.dustLife <= 0)
             {
-              map.tiles[x+y*VIEW_WIDTH] = Tile::Floor;
+              md.tile = Tile::Floor;
+              game.dirtyLighting = true;
+            } else {
+              game.numDust++;
             }
           }
         }
+
+        processKickup(game);
+
+        dustAcc -= dustDt;
       }
 
-      processKeys(map, keystate);
-      recalculateLighting(map, fov.get());
+      switch (losing)
+      {
+        case LoseState::None:
+        {
+          while (inputAcc >= inputDt)
+          {
+            processKeys(game, keystate);
+
+            inputAcc -= inputDt;
+          }
+
+          break;
+        }
+
+        case LoseState::PoppingLamps:
+        {
+          if (game.numLamps == 0)
+          {
+            if (game.numDust == 0)
+            {
+              losing = LoseState::PoppingPlayer;
+            }
+          } else {
+            losePopLampAcc += frameTime;
+
+            while (losePopLampAcc >= losePopLampDt)
+            {
+              std::vector<std::tuple<int, int>> lamps;
+
+              for (int y = game.map.getTop(); y < game.map.getBottom(); y++)
+              {
+                for (int x = game.map.getLeft(); x < game.map.getRight(); x++)
+                {
+                  if (game.map.at(x,y).tile == Tile::Lamp)
+                  {
+                    lamps.emplace_back(x, y);
+                  }
+                }
+              }
+
+              std::uniform_int_distribution<int> lampDist(0, lamps.size() - 1);
+              std::tuple<int, int> popPos = lamps[lampDist(rng)];
+
+              popLamp(game, std::get<0>(popPos), std::get<1>(popPos), 1);
+
+              losePopLampAcc -= losePopLampDt;
+            }
+          }
+
+          break;
+        }
 
-      if (input)
+        case LoseState::PoppingPlayer:
+        {
+          losePopPlayerAcc += frameTime;
+
+          if (losePopPlayerAcc >= losePopPlayerDt)
+          {
+            popLamp(game, game.player_x, game.player_y, 10);
+            game.renderPlayer = false;
+
+            losing = LoseState::Outro;
+          }
+
+          break;
+        }
+
+        case LoseState::Outro:
+        {
+          if (game.numDust == 0)
+          {
+            quit = true;
+          }
+
+          break;
+        }
+      }
+
+      if (game.dirtyLighting)
       {
-        for (int y = 0; y < VIEW_HEIGHT; y++)
+        recalculateLighting(game, fov.get());
+
+        for (int y = game.map.getTop(); y < game.map.getBottom(); y++)
         {
-          for (int x = 0; x < VIEW_WIDTH; x++)
+          for (int x = game.map.getLeft(); x < game.map.getRight(); x++)
           {
-            if (!map.lighting[x+y*VIEW_WIDTH] && map.oldLighting[x+y*VIEW_WIDTH])
+            if (!game.map.at(x,y).lit && game.map.at(x,y).wasLit)
             {
               if (std::bernoulli_distribution(0.5)(rng))
               {
-                map.tiles[x+y*VIEW_WIDTH] = Tile::Wall;
+                game.map.at(x,y).tile = Tile::Wall;
               } else {
-                map.tiles[x+y*VIEW_WIDTH] = Tile::Floor;
+                game.map.at(x,y).tile = Tile::Floor;
               }
             }
           }
         }
 
-        tick(map, 0, 0, VIEW_WIDTH, VIEW_HEIGHT, true);
-        tick(map, 0, 0, VIEW_WIDTH, VIEW_HEIGHT, true);
-        tick(map, 0, 0, VIEW_WIDTH, VIEW_HEIGHT, true);
+        tick(game, true);
+        tick(game, true);
+        tick(game, true);
+
+        // TODO: better zoom algorithm
+        setZoom(game, game.litSpots / 1500 * 2 + INIT_ZOOM);
       }
 
-      render(ren.get(), map, true);
-      SDL_Delay(50);
+      zoomAcc += frameTime;
+
+      while (zoomAcc >= zoomDt)
+      {
+        if (game.zooming)
+        {
+          if (game.zoomProgress > 0)
+          {
+            game.zoomProgress--;
+          } else if (game.zoomProgress < 0)
+          {
+            game.zoomProgress++;
+          }
+
+          if (game.zoomProgress == 0)
+          {
+            game.zooming = false;
+          }
+        }
+
+        zoomAcc -= zoomDt;
+      }
+
+      render(ren.get(), game, true);
     }
   } catch (const sdl_error& ex)
   {
@@ -681,4 +1136,4 @@ int main(int, char**)
   SDL_Quit();
 
   return 0;
-}
\ No newline at end of file
+}
@@ -0,0 +1,127 @@
+#ifndef MAP_H_3AB00D12
+#define MAP_H_3AB00D12
+
+#include <vector>
+#include <algorithm>
+
+template <typename T>
+class Map {
+public:
+
+  Map(
+    int left,
+    int top,
+    int width,
+    int height) :
+      left_(left),
+      top_(top),
+      width_(width),
+      height_(height),
+      data_(width_*height_)
+  {
+  }
+
+  inline int getLeft() const
+  {
+    return left_;
+  }
+
+  inline int getRight() const
+  {
+    return left_ + width_;
+  }
+
+  inline int getTop() const
+  {
+    return top_;
+  }
+
+  inline int getBottom() const
+  {
+    return top_ + height_;
+  }
+
+  inline int getWidth() const
+  {
+    return width_;
+  }
+
+  inline int getHeight() const
+  {
+    return height_;
+  }
+
+  inline int getTrueX(int x) const
+  {
+    return (x - left_);
+  }
+
+  inline int getTrueY(int y) const
+  {
+    return (y - top_);
+  }
+
+  inline bool inBounds(int x, int y) const
+  {
+    return (x >= left_) &&
+           (x < left_ + width_) &&
+           (y >= top_) &&
+           (y < top_ + height_);
+  }
+
+  inline const T& at(int x, int y) const
+  {
+    return data_.at((x - left_) + width_ * (y - top_));
+  }
+
+  inline T& at(int x, int y)
+  {
+    return const_cast<T&>(static_cast<const Map&>(*this).at(x, y));
+  }
+
+  inline const std::vector<T>& data() const
+  {
+    return data_;
+  }
+
+  inline std::vector<T>& data()
+  {
+    return data_;
+  }
+
+  void resize(int newLeft, int newTop, int newWidth, int newHeight)
+  {
+    std::vector<T> newData(newWidth * newHeight);
+
+    int winTop = std::max(top_, newTop);
+    int winBottom = std::min(top_ + height_, newTop + newHeight);
+    int winLeft = std::max(left_, newLeft);
+    int winRight = std::min(left_ + width_, newLeft + newWidth);
+
+    for (int y = winTop; y < winBottom; y++)
+    {
+      std::move(
+        std::next(std::begin(data_), (winLeft - left_) + width_ * (y - top_)),
+        std::next(std::begin(data_), (winRight - left_) + width_ * (y - top_)),
+        std::next(std::begin(newData),
+          (winLeft - newLeft) + newWidth * (y - newTop)));
+    }
+
+    left_ = newLeft;
+    top_ = newTop;
+    width_ = newWidth;
+    height_ = newHeight;
+    data_.swap(newData);
+  }
+
+private:
+
+  int left_;
+  int top_;
+  int width_;
+  int height_;
+
+  std::vector<T> data_;
+};
+
+#endif /* end of include guard: MAP_H_3AB00D12 */
@@ -0,0 +1,20 @@
+#ifndef UTIL_H_E9110D4C
+#define UTIL_H_E9110D4C
+
+template <typename Container, typename Predicate>
+void erase_if(Container& items, const Predicate& predicate)
+{
+  for (auto it = std::begin(items); it != std::end(items);)
+  {
+    if (predicate(*it))
+    {
+      it = items.erase(it);
+    }
+    else
+    {
+      ++it;
+    }
+  }
+};
+
+#endif /* end of include guard: UTIL_H_E9110D4C */