drawing player components

constants.h

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

level.c

@@ -7,14 +7,14 @@
 //prepares the level to be in a playable state
 void level_init(Level* level) {
     // initialize ball
-    level->ball.pos.x = SCREEN_WIDTH / 2;
+    level->ball.pos.x = (SCREEN_WIDTH / 2) - (BALL_SIZE_DEFAULT / 2);
-    level->ball.pos.y = SCREEN_HEIGHT / 2;
+    level->ball.pos.y = (SCREEN_HEIGHT / 2) - (BALL_SIZE_DEFAULT / 2);
-    level->ball.radius = 1;
+    level->ball.size = BALL_SIZE_DEFAULT;
 
     // initialize bouncer
-    level->bouncer.pos.x = SCREEN_HEIGHT / 2;
+    level->bouncer.pos.x = (SCREEN_WIDTH / 2) - (BOUNCER_WIDTH_DEFAULT / 2);
-    level->bouncer.pos.y = 5;
+    level->bouncer.pos.y = SCREEN_HEIGHT - (BOUNCER_HEIGHT * 2);
-    level->bouncer.width = 20;
+    level->bouncer.width = BOUNCER_WIDTH_DEFAULT;
 }
 
 //updates the level

level.h

@@ -9,7 +9,7 @@ typedef struct {
 
 typedef struct {
     struct {
-        unsigned radius;
+        unsigned size;
         Position pos;
     } ball;
 

main.c

@@ -11,14 +11,14 @@
 #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) {
+static int init(SDL_Window** window, SDL_Renderer** renderer, Level* level) {
     level_init(level);
-    return renderer_init(&window, &renderer);
+    return renderer_init(window, renderer);
 }
 
 // called on each game update
 static bool update(Level* level, bool* keys, RenderData* render_data) {
-    clock_t clock_start = clock();
+    const clock_t clock_start = clock();
 
     //update the event keys
     {
@@ -45,11 +45,11 @@ static bool update(Level* level, bool* keys, RenderData* render_data) {
         renderer_update(render_data); //update the render
     }
 
-    clock_t clock_end = clock();
+    const clock_t clock_end = clock();
 
     // provide a delay if needed, otherwise log a warning
-    clock_t clock_diff = clock_end - clock_start;  // difference / how long the operations took
+    const clock_t clock_diff = clock_end - clock_start;  // difference / how long the operations took
-    int remaining_ms = (int)((CLOCKS_PER_UPDATE_F - clock_diff) / CLOCKS_PER_SEC) * 1000;
+    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);
@@ -68,26 +68,24 @@ static void close(SDL_Window* window, SDL_Renderer* renderer) {
 
 // entry-point of the application
 int main(void) {
-    Level* level = NULL;            //stores the game's state
+    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
 
     // initialize
     {
-        int code = init(window, renderer, level);
+        const int code = init(&window, &renderer, &level);
         if (code != SUCCESS)
             exit(code);
     }
 
-    bool quit = false;
-
     // 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
+    RenderData render_data = { window, renderer, &level }; //contains the data which is used to render the game
-    while (update(level, keys, &render_data));
+    while (update(&level, keys, &render_data));
 
     // frees media and shuts down SDL
     close(window, renderer);

renderer.c

@@ -34,15 +34,27 @@ int renderer_init(SDL_Window** window, SDL_Renderer** renderer) {
 
 // renders the screen
 void renderer_update(RenderData* render_data) {
-    // render background
+    SDL_Renderer* renderer = render_data->renderer;
-    (void)SDL_SetRenderDrawColor(render_data->renderer, 0x00, 0x00, 0x00, 0xFF);
+    Level* level = render_data->level;
-    (void)SDL_RenderClear(render_data->renderer);
 
-    //TODO: render ball as a circle at render_data->level->ball.pos
+    int success = 0; // if an error occurs, this value is <0
-    //TODO: render bouncer as a bar at render_data->level->bouncer.pos
+
+    // 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_RenderFillRect(renderer, &(SDL_Rect) {level->bouncer.pos.x, level->bouncer.pos.y, level->bouncer.width, 5});
+    success |= SDL_RenderFillRect(renderer, &(SDL_Rect) {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(render_data->renderer);
+    SDL_RenderPresent(renderer);
 }
 
 void renderer_destroy(SDL_Window* window, SDL_Renderer* renderer) {