more component stuff

include/GameObject.h

@@ -1,18 +1,39 @@
 #pragma once
+#include <SDL3/SDL_events.h>
+#include <SDL3/SDL_rect.h>
 #include <memory>
 
+#include "GameState.h"
 #include "Graphics.h"
 #include "components/GraphicsComponent.h"
+#include "components/InputComponent.h"
 
-class GameObject : std::enable_shared_from_this<GameObject> {
+constexpr int HORIZONTAL_SPEED = 10;
+
+class GameObject {
 public:
-  GameObject(std::unique_ptr<GraphicsComponent> graphics)
-    : m_graphics(std::move(graphics)) {}
+  GameObject(
+      std::unique_ptr<GraphicsComponent> graphics,
+      std::unique_ptr<InputComponent> input)
+    : m_graphics(std::move(graphics)) 
+    , m_input(std::move(input)) 
+  { /* Intentionally empty */ }
 
   void update(Graphics &graphics) {
+    if (m_input->moveUp) {
+      speed.x = HORIZONTAL_SPEED;
+    }
     m_graphics->update(graphics);
   }
 
+  GameState processInput(SDL_Event const* event) {
+    return m_input->update(event);
+  }
+
 private:
   std::unique_ptr<GraphicsComponent> m_graphics;
+  std::unique_ptr<InputComponent> m_input;
+
+  SDL_Point speed;
+
 };

include/GameState.h

@@ -0,0 +1,5 @@
+#pragma once
+enum class GameState {
+  STOPPING=0,
+  RUNNING
+};

include/Graphics.h

@@ -1,8 +1,32 @@
 #pragma once
 
+#include <SDL3/SDL_rect.h>
+#include <SDL3/SDL_render.h>
+#include <SDL3/SDL_video.h>
+#include <format>
+#include <stdexcept>
+#include <string_view>
+
 class Graphics {
 public:
-  Graphics(){}
+  Graphics(std::string_view title){
+    // TODO Don't hardcode resolution
+    if (!SDL_CreateWindowAndRenderer(title.data(), 2560, 1440, SDL_WINDOW_FULLSCREEN, &window, &renderer)) {
+      throw std::runtime_error(std::format("Couldn't create window and renderer: {}", SDL_GetError()));
+    }
+  }
+
+  void drawRect(SDL_FRect const& rect, SDL_Color const& color) {
+    SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a);
+    SDL_RenderFillRect(renderer, &rect);
+  }
+
+  void show() {
+    SDL_RenderPresent(renderer);
+  }
+
 private:
+  SDL_Renderer *renderer = nullptr;
+  SDL_Window *window = nullptr;
 };
 

include/components/GraphicsComponent.h

@@ -2,12 +2,13 @@
 
 #include "Graphics.h"
 
+class GameObject;
+
 class GraphicsComponent {
 
 public:
   virtual ~GraphicsComponent() {}
   virtual void update(Graphics &graphics) = 0;
 
-private:
 };
 

include/components/InputComponent.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <SDL3/SDL_events.h>
+#include "GameState.h"
+
+struct InputComponent {
+
+public:
+  virtual ~InputComponent() {};
+  virtual GameState update(SDL_Event const* event) = 0;
+
+  bool moveUp;
+  bool moveDown;
+  bool moveLeft;
+  bool moveRight;
+};
+

include/components/PlayerGraphics.h

@@ -1,11 +1,31 @@
 #pragma once
 
+#include "GameObject.h"
 #include "Graphics.h"
 #include "GraphicsComponent.h"
-#include <print>
+#include <SDL3/SDL_pixels.h>
+#include <SDL3/SDL_rect.h>
+#include <SDL3/SDL_stdinc.h>
 
 class PlayerGraphics : public GraphicsComponent {
-  void update(Graphics &graphics) {
-    std::print("Updating player graphics");
+public:
+  void setPos(int x, int y) {
+    hitbox.x = x;
+    hitbox.y = y;
   }
+
+  void update(GameObject const& object, Graphics &graphics) {
+    SDL_Color color = { .r = 0, .g = 255, .b = 0, .a = 255};
+
+    graphics.drawRect(hitbox, color);
+  }
+
+private:
+  SDL_FRect hitbox = {
+    .x = 40,
+    .y = 40,
+    .w = 300,
+    .h = 300,
+  };
+
 };

include/components/PlayerInput.h

@@ -0,0 +1,30 @@
+#include "components/InputComponent.h"
+#include "GameState.h"
+#include <SDL3/SDL_keycode.h>
+
+class PlayerInput : public InputComponent {
+  GameState update(SDL_Event const* event) {
+    if (SDL_EVENT_QUIT == event->type || SDLK_ESCAPE == event->key.key) {
+      return GameState::STOPPING;
+    }
+    // currently dont care about anything other than down
+    if (SDL_EVENT_KEY_DOWN != event->type) {
+      return GameState::RUNNING;
+    }
+
+    if (SDLK_W == event->key.key) {
+      moveUp = event->key.type == SDL_EVENT_KEY_DOWN;
+    }
+    if (SDLK_S == event->key.key) {
+      moveDown = event->key.type == SDL_EVENT_KEY_DOWN;
+    }
+    if (SDLK_A == event->key.key) {
+      moveLeft = event->key.type == SDL_EVENT_KEY_DOWN;
+    }
+    if (SDLK_D == event->key.key) {
+      moveRight = event->key.type == SDL_EVENT_KEY_DOWN;
+    }
+
+    return GameState::RUNNING;
+  }
+};