8 files changed, 140 insertions, 127 deletions

@@ -0,0 +1,13 @@
+#include "editor.h"
+
+void Editor::tick(
+  double dt,
+  const Uint8* keystate)
+{
+
+}
+
+void Editor::render(SDL_Renderer* ren)
+{
+
+}
@@ -0,0 +1,17 @@
+#ifndef EDITOR_H_8BB54FE3
+#define EDITOR_H_8BB54FE3
+
+#include "state.h"
+
+class Editor : public State {
+public:
+
+  void tick(
+    double dt,
+    const Uint8* keystate) override;
+
+  void render(SDL_Renderer* ren) override;
+
+};
+
+#endif /* end of include guard: EDITOR_H_8BB54FE3 */
@@ -1,17 +1,51 @@
 #include "renderer.h"
 
 #include <random>
+#include "renderer.h"
 #include "simulation.h"
 #include "level.h"
+#include "editor.h"
 
-int main(int, char**)
+int main(int argc, char** argv)
 {
   std::random_device randomEngine;
   std::mt19937 rng(randomEngine());
 
-  Renderer renderer;
+  window_ptr win(
+    SDL_CreateWindow(
+      "dispatcher",
+      100,
+      100,
+      WINDOW_SIZE.w(),
+      WINDOW_SIZE.h(),
+      SDL_WINDOW_SHOWN));
+
+  if (!win)
+  {
+    throw sdl_error();
+  }
+
+  renderer_ptr ren(
+    SDL_CreateRenderer(
+      win.get(),
+      -1,
+      SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC));
+
+  if (!ren)
+  {
+    throw sdl_error();
+  }
+
   Level level;
-  Simulation sim(level);
+
+  std::unique_ptr<State> state;
+
+  if (argc == 2 && !strcmp(argv[1], "--editor"))
+  {
+    state.reset(new Editor());
+  } else {
+    state.reset(new Simulation(level));
+  }
 
   bool quit = false;
 
@@ -43,10 +77,13 @@ int main(int, char**)
       }
     }
 
-    const Uint8* state = SDL_GetKeyboardState(NULL);
+    const Uint8* keystate = SDL_GetKeyboardState(NULL);
 
-    sim.tick(frameTime / 1000.0, state);
+    state->tick(frameTime / 1000.0, keystate);
 
-    renderer.render(sim);
+    SDL_SetRenderTarget(ren.get(), nullptr);
+    SDL_RenderClear(ren.get());
+    state->render(ren.get());
+    SDL_RenderPresent(ren.get());
   }
 }
@@ -1,103 +0,0 @@
-#include "renderer.h"
-#include "simulation.h"
-#include "consts.h"
-#include "level.h"
-#include "views.h"
-
-Renderer::Renderer()
-{
-  win_ = window_ptr(
-    SDL_CreateWindow(
-      "dispatcher",
-      100,
-      100,
-      WINDOW_SIZE.w(),
-      WINDOW_SIZE.h(),
-      SDL_WINDOW_SHOWN));
-
-  if (!win_)
-  {
-    throw sdl_error();
-  }
-
-  ren_ = renderer_ptr(
-    SDL_CreateRenderer(
-      win_.get(),
-      -1,
-      SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC));
-
-  if (!ren_)
-  {
-    throw sdl_error();
-  }
-
-  SDL_SetRenderDrawBlendMode(ren_.get(), SDL_BLENDMODE_MOD);
-  SDL_SetRenderDrawColor(ren_.get(), 255, 150, 255, 255);
-  SDL_RenderFillRect(ren_.get(), nullptr);
-}
-
-void Renderer::render(const Simulation& sim)
-{
-  texture_ptr canvas(
-    SDL_CreateTexture(
-      ren_.get(),
-      SDL_PIXELFORMAT_RGBA8888,
-      SDL_TEXTUREACCESS_TARGET,
-      WINDOW_SIZE.w(),
-      WINDOW_SIZE.h()));
-
-  if (!canvas)
-  {
-    throw sdl_error();
-  }
-
-  SDL_SetRenderTarget(ren_.get(), nullptr);
-  SDL_SetRenderDrawBlendMode(ren_.get(), SDL_BLENDMODE_NONE);
-  SDL_SetRenderDrawColor(ren_.get(), 255, 150, rand() % 255, 255);
-  SDL_RenderClear(ren_.get());
-
-  const Level& level = sim.getLevel();
-
-  for (size_t y = 0; y < level.getSize().h(); y++)
-  {
-    for (size_t x = 0; x < level.getSize().w(); x++)
-    {
-      int val = 255 - level.at(x, y) * 10;
-
-      SDL_SetRenderDrawColor(ren_.get(), val, val, val, 255);
-
-      SDL_Rect rect {
-        static_cast<int>(x * TILE_SIZE.w()),
-        static_cast<int>(y * TILE_SIZE.h()),
-        TILE_SIZE.w(),
-        TILE_SIZE.h()
-      };
-
-      SDL_RenderFillRect(ren_.get(), &rect);
-    }
-  }
-
-  constexpr Layer renderOrder[] = { Layer::track, Layer::object };
-
-  ranges::for_each(
-    ranges::view::for_each(
-      renderOrder,
-      [&] (Layer layer) {
-        return sim.entityRange() | views::isOnLayer(layer);
-      }),
-    [&] (const Entity& entity) {
-      SDL_SetRenderDrawColor(ren_.get(), entity.colorVal, entity.colorVal, 65, 255);
-
-      SDL_Rect rect {
-        static_cast<int>(entity.pos.x()),
-        static_cast<int>(entity.pos.y()),
-        static_cast<int>(entity.size.w()),
-        static_cast<int>(entity.size.h())
-      };
-
-      SDL_RenderFillRect(ren_.get(), &rect);
-    });
-
-  //SDL_RenderCopy(ren_.get(), canvas.get(), nullptr, nullptr);
-  SDL_RenderPresent(ren_.get());
-}
@@ -108,19 +108,4 @@ public:
 
 using texture_ptr = std::unique_ptr<SDL_Texture, texture_deleter>;
 
-class Renderer {
-public:
-
-  Renderer();
-
-  void render(const Simulation& game);
-
-private:
-
-  sdl_wrapper sdl_;
-  img_wrapper img_;
-  window_ptr win_;
-  renderer_ptr ren_;
-};
-
 #endif /* end of include guard: RENDERER_H_6A58EC30 */
@@ -233,6 +233,49 @@ void Simulation::tick(
   }
 }
 
+void Simulation::render(SDL_Renderer* ren)
+{
+  for (size_t y = 0; y < level_.getSize().h(); y++)
+  {
+    for (size_t x = 0; x < level_.getSize().w(); x++)
+    {
+      int val = 255 - level_.at(x, y) * 10;
+
+      SDL_SetRenderDrawColor(ren, val, val, val, 255);
+
+      SDL_Rect rect {
+        static_cast<int>(x * TILE_SIZE.w()),
+        static_cast<int>(y * TILE_SIZE.h()),
+        TILE_SIZE.w(),
+        TILE_SIZE.h()
+      };
+
+      SDL_RenderFillRect(ren, &rect);
+    }
+  }
+
+  constexpr Layer renderOrder[] = { Layer::track, Layer::object };
+
+  ranges::for_each(
+    ranges::view::for_each(
+      renderOrder,
+      [&] (Layer layer) {
+        return entityRange() | views::isOnLayer(layer);
+      }),
+    [&] (const Entity& entity) {
+      SDL_SetRenderDrawColor(ren, entity.colorVal, entity.colorVal, 65, 255);
+
+      SDL_Rect rect {
+        static_cast<int>(entity.pos.x()),
+        static_cast<int>(entity.pos.y()),
+        static_cast<int>(entity.size.w()),
+        static_cast<int>(entity.size.h())
+      };
+
+      SDL_RenderFillRect(ren, &rect);
+    });
+}
+
 id_type Simulation::emplaceEntity()
 {
   id_type nextId;
@@ -1,8 +1,8 @@
 #ifndef SIMULATION_H_7BF6EEA4
 #define SIMULATION_H_7BF6EEA4
 
+#include "state.h"
 #include "entity.h"
-#include "renderer.h"
 #include "schedule.h"
 #include <range/v3/all.hpp>
 #include <vector>
@@ -11,7 +11,7 @@
 
 class Level;
 
-class Simulation {
+class Simulation : public State {
 public:
 
   // Constructor
@@ -19,7 +19,9 @@ public:
 
   void tick(
     double dt,
-    const Uint8* keystate);
+    const Uint8* keystate) override;
+
+  void render(SDL_Renderer* ren) override;
 
   id_type emplaceEntity();
 
@@ -0,0 +1,19 @@
+#ifndef STATE_H_86BFEF59
+#define STATE_H_86BFEF59
+
+#include "renderer.h"
+
+class State {
+public:
+
+  virtual ~State() = default;
+
+  virtual void tick(
+    double dt,
+    const Uint8* keystate) = 0;
+
+  virtual void render(SDL_Renderer* ren) = 0;
+
+};
+
+#endif /* end of include guard: STATE_H_86BFEF59 */