game/sdlpp.cpp

#include "sdlpp.hpp"

#include <SDL2/SDL_image.h>
#include <iostream>

bool SDLPP::init() {
    if( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
        std::cerr << "SDL could not initialize! SDL_Error: " <<  SDL_GetError() << std::endl;
        return false;
    }
    if( IMG_Init( IMG_INIT_PNG ) != IMG_INIT_PNG ) {
        std::cerr << "SDL_image could not initialize! SDL_image Error: " <<  IMG_GetError() << std::endl;
        return false;
    }
    if( TTF_Init() == -1 ) {
        std::cerr << "SDL_ttf could not initialize! SDL_ttf Error: " << TTF_GetError() << std::endl;
        return false;
    }
    return true;
}

bool SDLPP::init(uint32_t SDL_OPTIONS) {
    if( SDL_Init(SDL_OPTIONS) < 0 ) {
        std::cerr << "SDL could not initialize! SDL_Error: " <<  SDL_GetError() << std::endl;
        return false;
    }
    if( IMG_Init( IMG_INIT_PNG ) != IMG_INIT_PNG ) {
        std::cerr << "SDL_image could not initialize! SDL_image Error: " <<  IMG_GetError() << std::endl;
        return false;
    }
    return true;
}

bool SDLPP::init(uint32_t SDL_OPTIONS, int IMAGE_OPTIONS) {
    if( SDL_Init(SDL_OPTIONS) < 0 ) {
        std::cerr << "SDL could not initialize! SDL_Error: " <<  SDL_GetError() << std::endl;
        return false;
    }
    if( IMG_Init( IMAGE_OPTIONS ) != IMAGE_OPTIONS ) {
        std::cerr << "SDL_image could not initialize! SDL_image Error: " <<  IMG_GetError() << std::endl;
        return false;
    }
    return true;
}

void SDLPP::CircleRender::render() {
    std::cout << "I'm a circle, look at me go!" << std::endl << "My dimensions are: [" << x_ << ", " << y_ << "], radius: " << rad_ << std::endl;
}

// only rectangles for now
bool intersects(const SDLPP::CollisionPolygon &p1, const SDLPP::CollisionPolygon &p2) {
    return !(p1.rightmost() < p2.leftmost() || p2.rightmost() < p1.leftmost() ||
             p1.topmost() > p2.bottommost() || p2.topmost() > p1.bottommost());
}

bool infinityIntersection(const SDLPP::CollisionPolygon &infinite, const SDLPP::CollisionPolygon &other) {
    int ileft = infinite.leftmost();
    int iright = infinite.rightmost();
    int itop = infinite.topmost();
    int ibottom = infinite.bottommost();
    bool ret = ileft != -1 && ileft <= other.rightmost() && ileft >= other.leftmost();
    ret |= iright != -1 && iright >= other.leftmost() && iright <= other.rightmost();
    ret |= itop != -1 && itop <= other.bottommost() && itop >= other.topmost();
    ret |= ibottom != -1 && ibottom >= other.topmost() && ibottom <= other.bottommost();
    ret |= ileft == -1 && iright == -1 && itop == -1 && ibottom == -1;
    return ret;
}

bool SDLPP::Rect::colidesWith(const SDLPP::CollisionPolygon &other) const {
    if(other.isCircle()) {
        return other.colidesWith(*this);
    }
    if(other.isInfinite() ) {
        return infinityIntersection(other, *this);
    }
    if(isInfinite())
        return infinityIntersection(*this, other);
    return intersects(*this, other);
}

bool SDLPP::Circle::colidesWith(const SDLPP::CollisionPolygon &other) const {
    if(other.isCircle()) {
        int otherRad = (other.rightmost() - other.leftmost())/2;
        int thisRad = getRadius();
        int totalDist = otherRad + thisRad;
        int xdiff = other.leftmost() + otherRad - (leftmost() + thisRad);
        int ydiff = other.topmost() + otherRad - (topmost() + thisRad);
        return (xdiff*xdiff + ydiff*ydiff) <= totalDist * totalDist;
    } else if (other.isInfinite()) {
        return infinityIntersection(other, *this);
    }
    int rad = rad_;
    int centerx = getX();
    int centery = getY();
    if(other.topmost() <= centery && other.bottommost() >= centery) {
        return other.leftmost() <= rightmost() && other.rightmost() >= leftmost();
    } else if (other.leftmost() <= centerx && other.rightmost() >= centerx) {
        return other.topmost() <= bottommost() && other.bottommost() >= topmost();
    }
    int pointx=0, pointy=0;
    if(centerx > other.rightmost()) {
        pointx = other.rightmost();
    } else {
        pointx = other.leftmost();
    }
    if(centery < other.topmost()) {
        pointy = other.topmost();
    } else {
        pointy = other.bottommost();
    }
    int distancesquared = (pointx - centerx)*(pointx - centerx) + (pointy - centery)*(pointy-centery);
    return distancesquared <= rad*rad;
}

int SDLPP::hex2num(char c) {
    if(c <= '9')
        return c - '0';
    switch(c) {
        case 'a':
        case 'A':
            return 10;
        case 'b':
        case 'B':
            return 11;
        case 'c':
        case 'C':
            return 12;
        case 'd':
        case 'D':
            return 13;
        case 'e':
        case 'E':
            return 14;
        default:
            return 15;
    }
}

std::tuple<int, int, int, int> SDLPP::getColorsHEX(const std::string &color) {
    int red = 0, green = 0, blue = 0, alpha = 255;
    const char *color_ptr = color.c_str();
    if(color_ptr[0] == '#')
        color_ptr++;
    red = hex2num(color_ptr[0])*16 + hex2num(color_ptr[1]);
    green = hex2num(color_ptr[2])*16 + hex2num(color_ptr[3]);
    blue = hex2num(color_ptr[4])*16 + hex2num(color_ptr[5]);
    if( color_ptr[6] != '\0' )
        alpha = hex2num(color_ptr[6])*16 + hex2num(color_ptr[7]);
    return {red, green, blue, alpha};
}

SDL_Color SDLPP::getSDLColorTuple(const std::tuple<int, int, int, int> &tuple) {
    SDL_Color ret_color{};
    ret_color.r = std::get<0>(tuple);
    ret_color.g = std::get<1>(tuple);
    ret_color.b = std::get<2>(tuple);
    ret_color.a = std::get<3>(tuple);
    return ret_color;
}

SDL_Color SDLPP::getSDLColorHEX(const std::string &color) {
    auto color_tuple = SDLPP::getColorsHEX(color);
    return getSDLColorTuple(color_tuple);
}

std::tuple<int, int, int, int> SDLPP::getColorsSDLColor(const SDL_Color &color) {
    return {color.r, color.g, color.b, color.a};
}