moved everything to src/

src/constants.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#define SCREEN_WIDTH 960
+#define SCREEN_HEIGHT 640
+#define BOUNCER_HEIGHT 5
+#define BOUNCER_WIDTH_DEFAULT 60
+#define BALL_SIZE_DEFAULT 10

src/error_codes.h

@@ -0,0 +1,17 @@
+#pragma once
+enum {
+    SUCCESS = 0,
+    FAILURE = -1,
+
+    FAILURE_STD = 1 << 0,                     // 1  : marks a generic C library error
+    FAILURE_MEMORY = FAILURE_STD | (1 << 1),  // 3  : marks a memory related error
+
+    // SDL ERRORS
+    FAILURE_SDL = 1 << 1,                           // 2  : marks a generic SDL error
+    FAILURE_SDL_INIT = FAILURE_SDL | (1 << 2),      // 6  : marks an error during SDL initialisation
+    FAILURE_SDL_WINDOW = FAILURE_SDL | (1 << 3),    // 10 : marks an error with the window
+    FAILURE_SDL_RENDERER = FAILURE_SDL | (1 << 4),  // 18 : marks an error with the renderer
+
+    // GAME ERRORS
+    FAILURE_GAME = 1 << 2,  // 4  : marks a generic game error
+};

src/level.c

@@ -0,0 +1,84 @@
+#include "level.h"
+
+#include <stdbool.h>
+#include <SDL2/SDL.h>
+#include "vector2.h"
+#include "constants.h"
+
+//prepares the level to be in a playable state
+void level_init(Level* level) {
+    level->stop = false;
+
+    // initialize ball
+    level->ball.pos.x = (SCREEN_WIDTH / 2) - (BALL_SIZE_DEFAULT / 2);
+    level->ball.pos.y = (SCREEN_HEIGHT / 2) - (BALL_SIZE_DEFAULT / 2);
+    level->ball.size = BALL_SIZE_DEFAULT;
+    level->ball.direction = (Vector2){ 0.2F, 0.2F };
+
+    // initialize bouncer
+    level->bouncer.pos.x = (SCREEN_WIDTH / 2) - (BOUNCER_WIDTH_DEFAULT / 2);
+    level->bouncer.pos.y = SCREEN_HEIGHT - (BOUNCER_HEIGHT * 2);
+    level->bouncer.width = BOUNCER_WIDTH_DEFAULT;
+}
+
+
+void ball_collisions(struct Ball* ball) {
+
+}
+
+//updates the level
+void level_update(Level* level, bool* keys) {
+    struct Bouncer* bouncer = &level->bouncer;
+    struct Ball* ball = &level->ball;
+
+    // if move bouncer LEFT
+    if (keys[SDLK_a]) {
+        bouncer->pos.x -= 0.5F;
+        ball->moving = true;
+
+        if (bouncer->pos.x == 0) {
+            bouncer->pos.x = SCREEN_WIDTH - bouncer->width;
+        }
+    }
+
+    // if move bouncer RIGHT
+    if (keys[SDLK_d]) {
+        bouncer->pos.x += 0.5F; // increase the bouncer pos
+        ball->moving = true;
+
+        if ((bouncer->pos.x + bouncer->width) > SCREEN_WIDTH) {
+            bouncer->pos.x = 1; //set the bouncer pos to 1
+        }
+    }
+
+    if (ball->moving == false)
+        return;
+
+    // update ball position
+    ball->pos.x += ball->direction.x;
+    ball->pos.y += ball->direction.y;
+
+
+    // check X axis out of bounds collisions
+    if ((ball->pos.x + ball->size) > SCREEN_WIDTH || ball->pos.x < 0) {
+        ball->direction.x *= -1;
+    }
+
+    // check Y axis out of bounds collisions
+    if (ball->pos.y < 0) {
+        ball->direction.y *= -1;
+    }
+
+
+    // check bouncer collisions
+    if ((ball->pos.x + ball->size) > bouncer->pos.x && ball->pos.x < (bouncer->pos.x + bouncer->width) &&
+        (ball->pos.y + ball->size) > bouncer->pos.y && ball->pos.y < (bouncer->pos.y + BOUNCER_HEIGHT)) {
+        ball->direction.y *= -1;
+    }
+
+    // check lose condition
+    if ((ball->pos.y + ball->size) > SCREEN_HEIGHT) {
+        level->stop = true;
+        ball->moving = false;
+    }
+}

src/level.h

@@ -0,0 +1,24 @@
+#pragma once
+#include <stdbool.h>
+#include <SDL2/SDL.h>
+#include "vector2.h"
+
+typedef struct {
+    bool stop;
+
+    struct Ball {
+        bool moving;
+        unsigned size;
+        Vector2 pos;
+        Vector2 direction;
+    } ball;
+
+    struct Bouncer {
+        unsigned width;
+        Vector2 pos;
+    } bouncer;
+} Level;
+
+
+void level_init(Level* level);
+void level_update(Level* level, bool* keys);

src/main.c

@@ -0,0 +1,93 @@
+#include <SDL2/SDL.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <time.h>
+#include "error_codes.h"
+#include "renderer.h"
+#include "level.h"
+
+#define UPDATES_PER_SEC 50
+#define CLOCKS_PER_UPDATE (CLOCKS_PER_SEC / UPDATES_PER_SEC)
+#define CLOCKS_PER_UPDATE_F (((float)CLOCKS_PER_SEC) / UPDATES_PER_SEC)
+
+// initializes the game
+static int init(SDL_Window** window, SDL_Renderer** renderer, Level* level) {
+    level_init(level);
+    return renderer_init(window, renderer);
+}
+
+// called on each game update
+static bool update(Level* level, bool* keys, RenderData* render_data) {
+    const clock_t clock_start = clock();
+
+    //update the event keys
+    {
+        SDL_Event e;
+        while (SDL_PollEvent(&e)) {
+            switch (e.type) {
+            case SDL_QUIT:
+                return false;
+                break;
+
+            case SDL_KEYDOWN:
+                keys[e.key.keysym.sym] = true;
+                break;
+            case SDL_KEYUP:
+                keys[e.key.keysym.sym] = false;
+                break;
+            }
+        }
+    }
+
+    // preform updates
+    {
+        level_update(level, keys); //update the level
+        renderer_update(render_data); //update the render
+    }
+
+    const clock_t clock_end = clock();
+
+    // provide a delay if needed, otherwise log a warning
+    const clock_t clock_diff = clock_end - clock_start;  // difference / how long the operations took
+    const int remaining_ms = (int)((CLOCKS_PER_UPDATE_F - clock_diff) / CLOCKS_PER_SEC) * 1000;
+
+    if (remaining_ms < 0) {
+        (void)printf("delay between updates was %dms too long.", -remaining_ms);
+    }
+    else {
+        SDL_Delay(remaining_ms);  // wait the time in ms
+    }
+
+    return true;
+}
+
+// cleans up resources
+static void close(SDL_Window* window, SDL_Renderer* renderer) {
+    renderer_destroy(window, renderer);
+}
+
+// entry-point of the application
+int main(void) {
+    Level level = { 0 };            //stores the game's state
+    SDL_Window* window = NULL;      //the window that is given to the OS
+    SDL_Renderer* renderer = NULL;  //the renderer used to draw to the window
+    bool keys[322] = { 0 };         //stores the key states TODO: find a better method than to use 322 bytes
+
+    // initialize
+    {
+        const int code = init(&window, &renderer, &level);
+        if (code != SUCCESS)
+            exit(code);
+    }
+
+    // TEMP: tell me that the program has been initialized
+    (void)printf("initialized!\n");
+
+    // game-loop
+    RenderData render_data = { window, renderer, &level }; //contains the data which is used to render the game
+    while (update(&level, keys, &render_data) && (level.stop == false));
+
+    // frees media and shuts down SDL
+    close(window, renderer);
+    return 0;
+}

src/renderer.c

@@ -0,0 +1,64 @@
+#include "renderer.h"
+
+#include <SDL2/SDL.h>
+#include <stdio.h>
+#include "error_codes.h"
+#include "level.h"
+#include "constants.h"
+
+// initializes the window and renderer
+int renderer_init(SDL_Window** window, SDL_Renderer** renderer) {
+    // initialize SDL
+    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
+        (void)printf("SDL Failed to initialize! SDL_Error: %s\n", SDL_GetError());
+        return FAILURE_SDL_INIT;
+    }
+
+    // init the window
+    *window = SDL_CreateWindow("Title", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
+    if (*window == NULL) {
+        (void)printf("Window failed to be created! SDL_Error: %s\n", SDL_GetError());
+        return FAILURE_SDL_WINDOW;
+    }
+
+    // create a renderer
+    *renderer = SDL_CreateRenderer(*window, -1, SDL_RENDERER_PRESENTVSYNC);
+
+    if (*renderer == NULL) {
+        (void)printf("Renderer failed to be created! SDL_Error: %s\n", SDL_GetError());
+        return FAILURE_SDL_RENDERER;
+    }
+
+    return SUCCESS;
+}
+
+// renders the screen
+void renderer_update(RenderData* render_data) {
+    SDL_Renderer* renderer = render_data->renderer;
+    Level* level = render_data->level;
+
+    int success = 0; // if an error occurs, this value is <0
+
+    // render background
+    success |= SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0xFF);
+    success |= SDL_RenderClear(renderer);
+
+    //draw player components
+    success |= SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);
+    success |= SDL_RenderFillRectF(renderer, &(SDL_FRect) {level->bouncer.pos.x, level->bouncer.pos.y, level->bouncer.width, 5});
+    success |= SDL_RenderFillRectF(renderer, &(SDL_FRect) {level->ball.pos.x, level->ball.pos.y, level->ball.size, level->ball.size});
+
+    if (success < 0) {
+        printf("something went wrong whilst rendering: %s\n", SDL_GetError());
+        exit(FAILURE_SDL_RENDERER);
+    }
+
+    // present the result to the renderer
+    SDL_RenderPresent(renderer);
+}
+
+void renderer_destroy(SDL_Window* window, SDL_Renderer* renderer) {
+    SDL_DestroyWindow(window);
+    SDL_DestroyRenderer(renderer);
+    SDL_Quit();
+}

src/renderer.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <SDL2/SDL.h>
+#include "level.h"
+
+typedef struct {
+    SDL_Window* window;
+    SDL_Renderer* renderer;
+    Level* level;
+} RenderData;
+
+int renderer_init(SDL_Window** window, SDL_Renderer** renderer);
+void renderer_update(RenderData* render_data);
+void renderer_destroy(SDL_Window* window, SDL_Renderer* renderer);

src/vector2.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#define VECTOR2_UP ((Vector2){ 0, 1 })
+#define VECTOR2_DOWN ((Vector2){ 0, -1 })
+#define VECTOR2_LEFT ((Vector2){ -1, 0 })
+#define VECTOR2_RIGHT ((Vector2){ 1, 0 })
+#define VECTOR2_ZERO ((Vector2){ 0, 0 })
+#define VECTOR2_ONE ((Vector2){ 1, 1 })
+
+#define vec2_add(v1, v2) ((Vector2){v1.x + v2.x, v1.y + v2.y})
+#define vec2_subt(v1, v2) ((Vector2){v1.x - v2.x, v1.y - v2.y})
+#define vec2_mult(v, a) ((Vector2){v.x * a, v.y * a})
+#define vec2_div(v, a) ((Vector2){v.x / a, v.y / a})
+
+typedef struct {
+    float x;
+    float y;
+} Vector2;