breakout/breakout.c

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdbool.h>
#include <math.h>
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_ttf.h>

#include "breakout.h"
#include "vector.h"

#ifndef __nullptr__
#define Nullptr(type) (type *)0
#endif // __nullptr__

int BLOCK_TextureCount = 24;
int BREAKOUT_BoxWidth, BREAKOUT_BoxHeight;
SDL_Texture * BALL_Texture;
SDL_Texture * PADDLE_Texture;
SDL_Texture * BLOCK_Texture;
SDL_Rect * BALL_SourceRects;
SDL_Rect * PADDLE_SourceRects;
SDL_Rect * BLOCK_SourceRects;
Ball ball;
Paddle paddle;
Block * blocks;
int BlockCount = 60; // Move to scenery
Uint8 * PADDLE_MoveLeftKeys, * PADDLE_MoveRightKeys;
double BALL_Speed = 15.0f;
int PADDLE_Speed = 10;
bool BREAKOUT_IsInit = false;
bool BALL_IsInit = false;
bool PADDLE_IsInit = false;
bool BLOCK_IsInit = false;

void BREAKOUT_INITIALIZE(SDL_Renderer * renderer, int width, int height){
    if (!BREAKOUT_IsInit) {
        printf("Initializing Game...\n");
        srand(time(NULL));
        BREAKOUT_BoxWidth = width;
        BREAKOUT_BoxHeight = height;
        BALL_Initialize(renderer);
        PADDLE_Initialize(renderer);
        BLOCK_Initialize(renderer);
        ball = BALL_CreateDefault();
        paddle = PADDLE_CreateDefault();
        blocks = malloc(BlockCount * sizeof(Block));
        int index;
        for (int y = 0; y < 6; y++) {
            index = 10 * y;
            for (int x = 0; x < 10; x++) {
                blocks[x + index] = BLOCK_CreateDefault();
                blocks[x + index].TargetRect = (SDL_Rect) {.x = ((192 * x) + 4), .y = ((96 * y) + 2), .w = 184, .h = 92 };
            }
        }
        printf("Game initialized!\n");
        BREAKOUT_IsInit = true;
    } else printf("Game is already initialized!\n");
} /* BREAKOUT_INITIALIZE */

void BREAKOUT_ChangeSize(int width, int height){
    BREAKOUT_BoxWidth = width;
    BREAKOUT_BoxHeight = height;
}

void BREAKOUT_Update(Uint8 * keystate){
    PADDLE_Update(&paddle, keystate); // Update paddle before ball because paddle is not static!
    BALL_Update(&ball, &paddle);
    for (size_t i = 0; i < BlockCount; i++) {
        BLOCK_Update(blocks + i);
    }
}

void BREAKOUT_Draw(SDL_Renderer * renderer){
    for (int i = 0; i < BlockCount; i++) {
        BLOCK_Draw(renderer, &(blocks[i]));
    }
    BALL_Draw(renderer, &ball);
    PADDLE_Draw(renderer, &paddle);
}

void BREAKOUT_DEINITIALIZE(){
    if (BREAKOUT_IsInit) {
        printf("De-initializing Game...\n");
        for (size_t i = 0; i < BlockCount; i++) {
            BLOCK_DestroyObject(blocks + i);
        }
        free(blocks);
        free(PADDLE_MoveLeftKeys);
        free(PADDLE_MoveRightKeys);
        free(BALL_SourceRects);
        free(PADDLE_SourceRects);
        free(BLOCK_SourceRects);
        BALL_Deinitialize();
        PADDLE_Deinitialize();
        BLOCK_Deinitialize();
        printf("Game de-initialized!\n");
        BREAKOUT_IsInit = false;
    } else printf("Game is already de-initialized!\n");
}

void BALL_Initialize(SDL_Renderer * renderer){
    if (!BALL_IsInit) {
        printf("Initializing Ball...\n");
        BALL_Texture = IMG_LoadTexture(renderer, "assets/images/ball.png");
        if (!BALL_Texture) printf("Ball texture failed to load!\n");
        BALL_SourceRects = (SDL_Rect *)malloc(1 * sizeof(SDL_Rect));
        if (!BALL_SourceRects) printf("FATAL! Memory allocation failed!\n");
        BALL_SourceRects[0] = (SDL_Rect) {.x = 0, .y = 0, .w = 512, .h = 512 };
        printf("Ball initialized!\n");
        BALL_IsInit = true;
    } else printf("Ball is already initialized!\n");
}

Ball BALL_CreateDefault(){
    double rotation = (double)(rand() % 360);

    return (Ball) {
               .Location = (Vector) {.x = BREAKOUT_BoxWidth / 2 + 300, .y = BREAKOUT_BoxHeight / 2 },
               .Momentum = (Vector) {.x = 0.0f, .y = BALL_Speed },
               .TargetRect = (SDL_Rect) {.x = 0, .y = 0, .w = 50, .h = 50 },
               .Size = 25.0f,
               .Rotation = rotation,
               .RotationValue = 2,
               .TextureIndex = 0
    }; // Objekt für die Eigenschaften des Balls
}

void BALL_Draw(SDL_Renderer * renderer, Ball * obj){
    // printf("Ball drawn at (%d|%d)!\n", (obj->TargetRect).x, (obj->TargetRect).x);
    SDL_RenderCopyEx(renderer, BALL_Texture, BALL_SourceRects + (obj->TextureIndex), &(obj->TargetRect), obj->Rotation, NULL, SDL_FLIP_NONE);
}

bool BALL_CollideWithRect(Ball * obj, SDL_Rect * rect){
    SDL_Point ballCenter = BALL_GetCenter(obj);

    if (((obj->TargetRect).x) + ((obj->TargetRect).w) < (rect->x)) return false;
    if (((obj->TargetRect).x) > (rect->x) + (rect->w)) return false;
    if (((obj->TargetRect).y) + ((obj->TargetRect).w) < (rect->y)) return false;
    if (((obj->TargetRect).y) > (rect->y) + (rect->h)) return false;
    // Already returned with false if square ball hitbox didnt collide with rect
    Vector center = (Vector) {.x = ((obj->TargetRect).x) + (obj->Size), .y = ((obj->TargetRect).y) + (obj->Size) };
    Vector corner = (Vector) {0, 0 };
    // Folgender Algorithmus ist gefickt, wenn der Ballmittelpunkt im rechteck liegt!
    double perpendicular, oldMomentum, angle;
    oldMomentum = fmod((double)(vectorRotation(obj->Momentum) + 180), 360.0f);

    bool left, right, top, bottom, yMid = false, xMid = false;
    left = (ballCenter.x) < (rect->x);
    right = (ballCenter.x) > (rect->x) + (rect->w);
    top = (ballCenter.y) < (rect->y);
    bottom = (ballCenter.y) > (rect->y) + (rect->h);
    if (top)
        corner.y = rect->y;
    else if (bottom)
        corner.y = (rect->y) + (rect->w);
    else
        yMid = true;
    if (left)
        corner.x = rect->x;
    else if (right)
        corner.x = (rect->x) + (rect->w);
    else
        xMid = true;
    if (!(yMid || xMid)) { // Ball collides with corner
        perpendicular = vectorRotation(vectorSub(center, corner));
        angle = fabs(perpendicular - oldMomentum);
        if (oldMomentum < perpendicular)
            (obj->Momentum) = getScaledDirectionalUnitVector((oldMomentum + (2 * angle)), BALL_Speed);
        else
            (obj->Momentum) = getScaledDirectionalUnitVector((oldMomentum - (2 * angle)), BALL_Speed);
    } else { // Ball collides with Edge
        if (yMid)
            (obj->Momentum).y = -(obj->Momentum).y;
        else
            (obj->Momentum).x = -(obj->Momentum).x;
    }
    return true;
} /* BALL_CollideWithRect */

bool RECT_Collide(SDL_Rect * rect1, SDL_Rect * rect2){
    if ((rect1->x) + (rect1->w) < (rect2->x)) {
        return false;
    }
    if ((rect1->x) > (rect2->x) + (rect2->w)) {
        return false;
    }
    if ((rect1->y) + (rect1->w) < (rect2->y)) {
        return false;
    }
    if ((rect1->y) > (rect2->y) + (rect2->h)) {
        return false;
    }
    return true;
}

void BALL_SteerMomentum(Ball * obj, Paddle * paddle){
    int paddleHalfLen = ((paddle->TargetRect).w / 2.0f);
    double offset = (((obj->TargetRect).x) + (obj->Size)) - ((paddle->TargetRect).x + paddleHalfLen);

    offset *= 60.0f;
    offset /= (double)(paddleHalfLen);
    printf("Offset = %.2f\n", offset);
    (obj->Momentum) = getDirectionalUnitVector(offset);
}

void RECT_SetTargetPos(SDL_Rect * rect, Vector * Location){
    rect->x = (int)round(Location->x);
    rect->y = (int)round(Location->y);
}

SDL_Point BALL_GetCenter(Ball * obj){
    return (SDL_Point) {.x = ((obj->TargetRect).x) + (obj->Size), .y = ((obj->TargetRect).y) + (obj->Size) };
}

void BALL_Update(Ball * obj, Paddle * paddle){
    Vector oldMomentum = obj->Momentum;
    Vector oldLocation = obj->Location;
    SDL_Point ballCenter = BALL_GetCenter(obj);

    (obj->Rotation) += (obj->RotationValue); // No effect on physics
    (obj->Location) = vectorAdd((obj->Location), oldMomentum);

    if (BALL_CollideWithRect(obj, &(paddle->TargetRect))) {
        (obj->Location) = oldLocation;   // Maybe remove this
        BALL_SteerMomentum(obj, paddle); // Sets it to unit vector!
        // Following assumes that the paddle position was udated before the ball was updated
        // BUG/GLITCH: Make sure that the postition of the ball is not shifted into the borders of the game!
        while (RECT_Collide(&(obj->TargetRect), &(paddle->TargetRect))) { // Move away from rect in small steps
            (obj->Location) = vectorAdd((obj->Location), (obj->Momentum));
            RECT_SetTargetPos(&(obj->TargetRect), &(obj->Location));
        }
        (obj->Momentum) = vectorScaleTo((obj->Momentum), BALL_Speed);
    }
    for (size_t i = 0; i < BlockCount; i++) {
        if (blocks[i].HP <= 0) continue;
        oldMomentum = obj->Momentum;
        oldLocation = obj->Location;
        if (BALL_CollideWithRect(obj, &(blocks[i].TargetRect))) {
            BLOCK_DealDamage(blocks + i, 1);
            (obj->Location) = vectorAdd(oldLocation, (obj->Momentum));
            RECT_SetTargetPos(&(obj->TargetRect), &(obj->Location));
        }
    }

    if ((obj->Location).y > BREAKOUT_BoxHeight)                                                       // Collide with box boundaries
        (obj->Location) = (Vector) {.x = BREAKOUT_BoxWidth / 2 + 300, .y = BREAKOUT_BoxHeight / 2 };  // Dead
    else if ((obj->Location).y < 0.0f)
        (obj->Momentum).y = -(obj->Momentum).y;
    if ((obj->Location).x < 0.0f || (obj->Location).x > BREAKOUT_BoxWidth - (2 * (obj->Size)))
        (obj->Momentum).x = -(obj->Momentum).x;
    RECT_SetTargetPos(&(obj->TargetRect), &(obj->Location));
} /* BALL_Update */

void BALL_DestroyObject(Ball * obj){
}

void BALL_Deinitialize(){
    if (BALL_IsInit) {
        printf("De-initializing Ball...\n");
        SDL_DestroyTexture(BALL_Texture);
        printf("Ball de-initialized!\n");
        BALL_IsInit = false;
    } else printf("Ball is already de-initialized!\n");
}

void PADDLE_Initialize(SDL_Renderer * renderer){
    if (!PADDLE_IsInit) {
        printf("Initializing Paddle...\n");
        PADDLE_Texture = IMG_LoadTexture(renderer, "assets/images/paddle.png");
        if (!PADDLE_Texture) printf("Paddle texture failed to load!\n");
        PADDLE_SourceRects = (SDL_Rect *)malloc(1 * sizeof(SDL_Rect));
        if (!PADDLE_SourceRects) printf("FATAL! Memory allocation failed!\n");
        PADDLE_SourceRects[0] = (SDL_Rect) {.x = 0, .y = 0, .w = 512, .h = 512 };
        PADDLE_MoveLeftKeys = (Uint8 *)malloc(2 * sizeof(Uint8));
        if (!PADDLE_MoveLeftKeys) printf("FATAL! Memory allocation failed!\n");
        PADDLE_MoveRightKeys = (Uint8 *)malloc(2 * sizeof(Uint8));
        if (!PADDLE_MoveRightKeys) printf("FATAL! Memory allocation failed!\n");
        PADDLE_MoveLeftKeys[0] = 2; // Erster wert gibt größe des arrays an
        PADDLE_MoveLeftKeys[1] = SDL_SCANCODE_LEFT;
        PADDLE_MoveLeftKeys[2] = SDL_SCANCODE_A;
        PADDLE_MoveRightKeys[0] = 2;
        PADDLE_MoveRightKeys[1] = SDL_SCANCODE_RIGHT;
        PADDLE_MoveRightKeys[2] = SDL_SCANCODE_D;
        printf("Paddle initialized!\n");
        PADDLE_IsInit = true;
    } else printf("Paddle is already initialized!\n");
} /* PADDLE_Initialize */

Paddle PADDLE_CreateDefault(){
    int defaultpaddlewidth = 300;

    return (Paddle) {
               .TargetRect = (SDL_Rect) {.x = (BREAKOUT_BoxWidth -  defaultpaddlewidth) / 2, .y = BREAKOUT_BoxHeight - 100, .w = defaultpaddlewidth, .h = 30 },
               .TextureIndex = 0
    }; // Objekt für die Eigenschaften des Balls
}

void PADDLE_Draw(SDL_Renderer * renderer, Paddle * obj){
    // printf("Paddle drawn at (%d|%d)!\n", (obj->TargetRect).x, (obj->TargetRect).x);
    // SDL_RenderCopy(renderer, PADDLE_Texture, PADDLE_SourceRects + (obj->TextureIndex), &(obj->TargetRect));
    SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
    SDL_RenderDrawRect(renderer, &(obj->TargetRect));
}

bool KeyPressed(Uint8 * keystate, Uint8 * keyArray){
    for (int i = 0; i < (*keyArray); i++) {
        if (keystate[keyArray[(i + 1)]]) return true;
    }
    return false;
}

void constrain(int * variable, int min, int max){
    if (*variable > max)
        *variable = max;
    else if (*variable < min)
        *variable = min;
}

void PADDLE_Update(Paddle * obj, Uint8 * keystate){
    bool leftKeyPressed = KeyPressed(keystate, PADDLE_MoveLeftKeys), rightKeyPressed = KeyPressed(keystate, PADDLE_MoveRightKeys);

    if (leftKeyPressed && (!rightKeyPressed)) {
        ((obj->TargetRect).x) -= PADDLE_Speed;
    } else if ((!leftKeyPressed) && rightKeyPressed) {
        ((obj->TargetRect).x) += PADDLE_Speed;
    }
    constrain(&((obj->TargetRect).x), 0, (BREAKOUT_BoxWidth - ((obj->TargetRect).w)));
}

void PADDLE_DestroyObject(Paddle * obj){
}

void PADDLE_Deinitialize(){
    if (PADDLE_IsInit) {
        printf("De-initializing Paddle...\n");
        SDL_DestroyTexture(PADDLE_Texture);
        printf("Paddle de-initialized!\n");
        PADDLE_IsInit = false;
    } else printf("Paddle is already de-initialized!\n");
}

void BLOCK_Initialize(SDL_Renderer * renderer){
    if (!BLOCK_IsInit) {
        printf("Initializing Block...\n");
        BLOCK_Texture = IMG_LoadTexture(renderer, "assets/images/blocks_debug.png");
        if (!BLOCK_Texture) printf("Block texture failed to load!\n");
        BLOCK_SourceRects = (SDL_Rect *)malloc(BLOCK_TextureCount * sizeof(SDL_Rect));
        if (!BLOCK_SourceRects) printf("FATAL! Memory allocation failed!\n");
        for (int i = 0; i < BLOCK_TextureCount; i++) {
// TODO: All textures!
            BLOCK_SourceRects[i] = (SDL_Rect) {.x = 0, .y = 500 * i * 0, .w = 1000, .h = 500 };
        }
        printf("Block initialized!\n");
        BLOCK_IsInit = true;
    } else printf("Block is already initialized!\n");
} /* PADDLE_Initialize */

Block BLOCK_CreateDefault() {
    int defaultpaddlewidth = 300;

    return (Block) {
               .TargetRect = (SDL_Rect) {.x = (BREAKOUT_BoxWidth -  defaultpaddlewidth) / 2, .y = BREAKOUT_BoxHeight - 100, .w = 150, .h = 75 },
               .TextureIndex = (rand() % BLOCK_TextureCount),
               .HP = 1
    };   // Objekt für die Eigenschaften des Balls
}

void BLOCK_Draw(SDL_Renderer * renderer, Block * obj){
    if ((obj->HP) > 0) {
        // printf("Block drawn at (%d|%d)!\n", (obj->TargetRect).x, (obj->TargetRect).y);
        SDL_RenderCopy(renderer, BLOCK_Texture, (BLOCK_SourceRects + (obj->TextureIndex)), &(obj->TargetRect));
    }
}

void BLOCK_DealDamage(Block * obj, int dmg){
    if (((obj->HP) -= dmg) <= 0) printf("Block was destroyed!\n");
}

void BLOCK_Update(Block * obj){
// Do nothing currently
}
void BLOCK_DestroyObject(Block * obj){
}

void BLOCK_Deinitialize(){
    if (BLOCK_IsInit) {
        printf("De-initializing Block...\n");
        SDL_DestroyTexture(BLOCK_Texture);
        printf("Block de-initialized!\n");
        BLOCK_IsInit = false;
    } else printf("Block is already de-initialized!\n");
}