#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>
#include <stdbool.h>
#include <unistd.h>
#include <termios.h>
#include <limits.h>
#include <time.h>
#include <sys/time.h>
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>

#include "structure.h"
#include "base.h"
#include "display.h"

imgs* digits;
imgs* letters;

void updateRenderer(SDL_Renderer* renderer) {
    //printf("E");
    SDL_RenderPresent(renderer);
}

void resetRenderer(SDL_Renderer* renderer) {
    SDL_SetRenderDrawColor(renderer, 64, 64, 64, 255);
    SDL_RenderClear(renderer);
}

void drawRectToRenderer(SDL_Renderer* renderer, SDL_Rect* rect, int R, int G, int B, int A) {
    SDL_SetRenderDrawColor(renderer, R, G, B, A);
    SDL_RenderFillRect(renderer, rect);
}

void placeRectToRenderer(SDL_Renderer* renderer, int X, int Y, int W, int H, int R, int G, int B, int A) {
    SDL_Rect rect;
    rect.x = X;
    rect.y = Y;
    rect.w = W;
    rect.h = H;
    SDL_SetRenderDrawColor(renderer, R, G, B, A);
    SDL_RenderFillRect(renderer, &rect);
}

void drawLineWithThicc(SDL_Renderer* renderer, int width, int x1, int x2, int y1, int y2, int R, int G, int B, int A) {
    // draws line with width (native SDL cannot do that)
    double theta = 0.0;
    double seglen = distance_pt(x1, x2, y1, y2);
    while(theta < 1.0) {
        placeRectToRenderer(renderer, convex_seg(x1, x2, theta)-width/2, convex_seg(y1, y2, theta)-width/2, width, width, R, G, B, A);
        theta += 1 / seglen;
    }
}

void drawDigitToRenderer(SDL_Renderer* renderer, int digit, int X, int Y, int W, int H) {
    if(digit == -727) {
        SDL_Rect rect;
        rect.x = X;
        rect.y = Y;
        rect.w = W;
        rect.h = H;
            
        SDL_Texture* texture = digits->arr[10];
        
        SDL_RenderCopy(renderer, texture, NULL, &rect);
    } else if (!(0 <= digit && digit <= 9)) {
        fprintf(stderr, "Illegal digit : '%d'.\n", digit);
        exit(1);
    } else {
        SDL_Rect rect;
        rect.x = X;
        rect.y = Y;
        rect.w = W;
        rect.h = H;
            
        SDL_Texture* texture = digits->arr[digit];
        
        SDL_RenderCopy(renderer, texture, NULL, &rect);
    }
}

void drawCharToRenderer(SDL_Renderer* renderer, char c, int X, int Y, int W, int H) {
    if ((int)c >= 97 && (int)c <= 122) {
        SDL_Rect rect;
        rect.x = X;
        rect.y = Y;
        rect.w = W;
        rect.h = H;
            
        SDL_Texture* texture = letters->arr[(int)c - 97];
        
        SDL_RenderCopy(renderer, texture, NULL, &rect);
    }
}

void drawNumberToRenderer(SDL_Renderer* renderer, int n, int X, int Y, int W, int H, int Woffset) {
    if(n == 0) {
        drawDigitToRenderer(renderer, 0, X + W, Y, W, H);
    } else if(n > 0) {
        int toDraw = 0, remaining = n, nIter = notLN(n, 10);
        while(nIter != 0) {
            toDraw = remaining%10;
            remaining = remaining / 10;
            drawDigitToRenderer(renderer, toDraw, X + (W-Woffset)*nIter, Y, W, H);
            nIter--;
        }
    } else {
        int toDraw = 0, remaining = -n, nIter = notLN(-n, 10);
        drawDigitToRenderer(renderer, -727, X, Y, W, H);
        while(nIter != 0) {
            toDraw = remaining%10;
            remaining = remaining / 10;
            drawDigitToRenderer(renderer, toDraw, X + (W-Woffset)*nIter, Y, W, H);
            nIter--;
        }
    }
}

void drawStringToRenderer(SDL_Renderer* renderer, char* s, int X, int Y, int W, int H) {
    int k = 0;
    while(s[k] != '\0') {
        drawCharToRenderer(renderer, s[k], X + W*k, Y, W, H);
        k += 1;
    }
}

void draw7SegDigitToRenderer(SDL_Renderer* renderer, int n, int X, int Y, int W, int H, int thicc, int R, int G, int B, int A) {
    if(n == 0) {
        placeRectToRenderer(renderer, X+thicc, Y+thicc, W+thicc, thicc, R, G, B, A);      // top
        placeRectToRenderer(renderer, X+thicc, Y+thicc, thicc, H+thicc, R, G, B, A);      // top left
        placeRectToRenderer(renderer, X+W+thicc, Y+thicc, thicc, H+thicc, R, G, B, A);    // top right
        placeRectToRenderer(renderer, X+thicc, Y+H+thicc, thicc, H+thicc, R, G, B, A);    // bottom left
        placeRectToRenderer(renderer, X+W+thicc, Y+H+thicc, thicc, H+thicc, R, G, B, A);  // bottom right
        placeRectToRenderer(renderer, X+thicc, Y+2*H+thicc, W+thicc, thicc, R, G, B, A);  // bottom
    } else if(n == 1) {
        placeRectToRenderer(renderer, X+W+thicc, Y+thicc, thicc, H+thicc, R, G, B, A);    // top right
        placeRectToRenderer(renderer, X+W+thicc, Y+H+thicc, thicc, H+thicc, R, G, B, A);  // bottom right
    } else if(n == 2) {
        placeRectToRenderer(renderer, X+thicc, Y+thicc, W+thicc, thicc, R, G, B, A);      // top
        placeRectToRenderer(renderer, X+W+thicc, Y+thicc, thicc, H+thicc, R, G, B, A);    // top right
        placeRectToRenderer(renderer, X+thicc, Y+H+thicc, W+thicc, thicc, R, G, B, A);    // mid
        placeRectToRenderer(renderer, X+thicc, Y+H+thicc, thicc, H+thicc, R, G, B, A);    // bottom left
        placeRectToRenderer(renderer, X+thicc, Y+2*H+thicc, W+thicc, thicc, R, G, B, A);  // bottom
    } else if(n == 3) {
        placeRectToRenderer(renderer, X+thicc, Y+thicc, W+thicc, thicc, R, G, B, A);      // top
        placeRectToRenderer(renderer, X+W+thicc, Y+thicc, thicc, H+thicc, R, G, B, A);    // top right
        placeRectToRenderer(renderer, X+thicc, Y+H+thicc, W+thicc, thicc, R, G, B, A);    // mid
        placeRectToRenderer(renderer, X+W+thicc, Y+H+thicc, thicc, H+thicc, R, G, B, A);  // bottom right
        placeRectToRenderer(renderer, X+thicc, Y+2*H+thicc, W+thicc, thicc, R, G, B, A);  // bottom
    } else if(n == 4) {
        placeRectToRenderer(renderer, X+thicc, Y+thicc, thicc, H+thicc, R, G, B, A);      // top left
        placeRectToRenderer(renderer, X+W+thicc, Y+thicc, thicc, H+thicc, R, G, B, A);    // top right
        placeRectToRenderer(renderer, X+thicc, Y+H+thicc, W+thicc, thicc, R, G, B, A);    // mid
        placeRectToRenderer(renderer, X+W+thicc, Y+H+thicc, thicc, H+thicc, R, G, B, A);  // bottom right
    } else if(n == 5) {
        placeRectToRenderer(renderer, X+thicc, Y+thicc, W+thicc, thicc, R, G, B, A);      // top
        placeRectToRenderer(renderer, X+thicc, Y+thicc, thicc, H+thicc, R, G, B, A);      // top left
        placeRectToRenderer(renderer, X+thicc, Y+H+thicc, W+thicc, thicc, R, G, B, A);    // mid
        placeRectToRenderer(renderer, X+W+thicc, Y+H+thicc, thicc, H+thicc, R, G, B, A);  // bottom right
        placeRectToRenderer(renderer, X+thicc, Y+2*H+thicc, W+thicc, thicc, R, G, B, A);  // bottom
    } else if(n == 6) {
        placeRectToRenderer(renderer, X+thicc, Y+thicc, W+thicc, thicc, R, G, B, A);      // top
        placeRectToRenderer(renderer, X+thicc, Y+thicc, thicc, H+thicc, R, G, B, A);      // top left
        placeRectToRenderer(renderer, X+thicc, Y+H+thicc, W+thicc, thicc, R, G, B, A);    // mid
        placeRectToRenderer(renderer, X+thicc, Y+H+thicc, thicc, H+thicc, R, G, B, A);    // bottom left
        placeRectToRenderer(renderer, X+W+thicc, Y+H+thicc, thicc, H+thicc, R, G, B, A);  // bottom right
        placeRectToRenderer(renderer, X+thicc, Y+2*H+thicc, W+thicc, thicc, R, G, B, A);  // bottom
    } else if(n == 7) {
        placeRectToRenderer(renderer, X+thicc, Y+thicc, W+thicc, thicc, R, G, B, A);      // top
        placeRectToRenderer(renderer, X+thicc, Y+thicc, thicc, H+thicc, R, G, B, A);      // top left
        placeRectToRenderer(renderer, X+W+thicc, Y+thicc, thicc, H+thicc, R, G, B, A);    // top right
        placeRectToRenderer(renderer, X+W+thicc, Y+H+thicc, thicc, H+thicc, R, G, B, A);  // bottom right
    } else if(n == 8) {
        placeRectToRenderer(renderer, X+thicc, Y+thicc, W+thicc, thicc, R, G, B, A);      // top
        placeRectToRenderer(renderer, X+thicc, Y+thicc, thicc, H+thicc, R, G, B, A);      // top left
        placeRectToRenderer(renderer, X+W+thicc, Y+thicc, thicc, H+thicc, R, G, B, A);    // top right
        placeRectToRenderer(renderer, X+thicc, Y+H+thicc, W+thicc, thicc, R, G, B, A);    // mid
        placeRectToRenderer(renderer, X+thicc, Y+H+thicc, thicc, H+thicc, R, G, B, A);    // bottom left
        placeRectToRenderer(renderer, X+W+thicc, Y+H+thicc, thicc, H+thicc, R, G, B, A);  // bottom right
        placeRectToRenderer(renderer, X+thicc, Y+2*H+thicc, W+thicc, thicc, R, G, B, A);  // bottom
    } else if(n == 9) {
        placeRectToRenderer(renderer, X+thicc, Y+thicc, W+thicc, thicc, R, G, B, A);      // top
        placeRectToRenderer(renderer, X+thicc, Y+thicc, thicc, H+thicc, R, G, B, A);      // top left
        placeRectToRenderer(renderer, X+W+thicc, Y+thicc, thicc, H+thicc, R, G, B, A);    // top right
        placeRectToRenderer(renderer, X+thicc, Y+H+thicc, W+thicc, thicc, R, G, B, A);    // mid
        placeRectToRenderer(renderer, X+W+thicc, Y+H+thicc, thicc, H+thicc, R, G, B, A);  // bottom right
        placeRectToRenderer(renderer, X+thicc, Y+2*H+thicc, W+thicc, thicc, R, G, B, A);  // bottom
    }
}

// H = size of ont segment (therefore the actual size of the number is W x 2H)
// side is -1 (alignedLeft), 0 (centered) or 1 (alignedRight)
// dot if for placing a dot (for decimals) at a specified place (enter -1 if none)
void draw7SegNumberToRenderer(SDL_Renderer* renderer, int n, int X, int Y, int W, int H, int thicc, int R, int G, int B, int A, int side, int dot) {
    int nlen = 1+ln_baseN(n, 10);
    int incrX = W+3*thicc;
    int curX = X +(side==0)*(incrX*(nlen)/2-incrX) +(side==-1)*incrX*(nlen-1);
    int curN = n;
    int doot = (dot==-1)?(nlen+1):(nlen-(dot-1));
    while(nlen > 0) {
        draw7SegDigitToRenderer(renderer, curN%10, curX, Y, W, H, thicc, R, G, B, A);
        curX -= incrX;
        if(nlen == doot) {
            placeRectToRenderer(renderer, curX-2*thicc+incrX, Y+2*H, 2*thicc, 2*thicc, R, G, B, A);
            curX -= 6*thicc;
        }
        curN /= 10;
        nlen -= 1;
    }
}
//---------------------------------------------------------------------------------------------------------------------//
// circle functions by @Gumichan01 at https://gist.github.com/Gumichan01/364c26f6197a464db91cc4647fcabb1c (not native) //
//---------------------------------------------------------------------------------------------------------------------//
void SDL_RenderDrawCircle(SDL_Renderer * renderer, int x, int y, int radius, int r, int g, int b, int a) {
    SDL_SetRenderDrawColor(renderer, r, g, b, a);
    int offsetx, offsety, d;
    int status;

    offsetx = 0;
    offsety = radius;
    d = radius -1;
    status = 0;

    while (offsety >= offsetx) {
        status += SDL_RenderDrawPoint(renderer, x + offsetx, y + offsety);
        status += SDL_RenderDrawPoint(renderer, x + offsety, y + offsetx);
        status += SDL_RenderDrawPoint(renderer, x - offsetx, y + offsety);
        status += SDL_RenderDrawPoint(renderer, x - offsety, y + offsetx);
        status += SDL_RenderDrawPoint(renderer, x + offsetx, y - offsety);
        status += SDL_RenderDrawPoint(renderer, x + offsety, y - offsetx);
        status += SDL_RenderDrawPoint(renderer, x - offsetx, y - offsety);
        status += SDL_RenderDrawPoint(renderer, x - offsety, y - offsetx);

        if (status < 0) {
            status = -1;
            break;
        }

        if (d >= 2*offsetx) {
            d -= 2*offsetx + 1;
            offsetx +=1;
        } else if (d < 2 * (radius - offsety)) {
            d += 2 * offsety - 1;
            offsety -= 1;
        } else {
            d += 2 * (offsety - offsetx - 1);
            offsety -= 1;
            offsetx += 1;
        }
    }

    //return status;
}


void SDL_RenderFillCircle(SDL_Renderer * renderer, int x, int y, int radius, int r, int g, int b, int a) {
    SDL_SetRenderDrawColor(renderer, r, g, b, a);
    int offsetx, offsety, d;
    int status;

    offsetx = 0;
    offsety = radius;
    d = radius -1;
    status = 0;

    while (offsety >= offsetx) {

        status += SDL_RenderDrawLine(renderer, x - offsety, y + offsetx,
                                     x + offsety, y + offsetx);
        status += SDL_RenderDrawLine(renderer, x - offsetx, y + offsety,
                                     x + offsetx, y + offsety);
        status += SDL_RenderDrawLine(renderer, x - offsetx, y - offsety,
                                     x + offsetx, y - offsety);
        status += SDL_RenderDrawLine(renderer, x - offsety, y - offsetx,
                                     x + offsety, y - offsetx);

        if (status < 0) {
            status = -1;
            break;
        }

        if (d >= 2*offsetx) {
            d -= 2*offsetx + 1;
            offsetx +=1;
        } else if (d < 2 * (radius - offsety)) {
            d += 2 * offsety - 1;
            offsety -= 1;
        } else {
            d += 2 * (offsety - offsetx - 1);
            offsety -= 1;
            offsetx += 1;
        }
    }
    //return status;
}

void drawCircleToRenderer(SDL_Renderer * renderer, int32_t centreX, int32_t centreY, int32_t radius, int r, int g, int b, int a) {
    SDL_SetRenderDrawColor(renderer, r, g, b, a);
    const int32_t diameter = (radius * 2);

    int32_t x = (radius - 1);
    int32_t y = 0;
    int32_t tx = 1;
    int32_t ty = 1;
    int32_t error = (tx - diameter);

    while(x >= y){
        SDL_RenderDrawLine(renderer, centreX + x, centreY - y, centreX, centreY);
        SDL_RenderDrawLine(renderer, centreX + x, centreY + y, centreX, centreY);
        SDL_RenderDrawLine(renderer, centreX - x, centreY - y, centreX, centreY);
        SDL_RenderDrawLine(renderer, centreX - x, centreY + y, centreX, centreY);
        SDL_RenderDrawLine(renderer, centreX + y, centreY - x, centreX, centreY);
        SDL_RenderDrawLine(renderer, centreX + y, centreY + x, centreX, centreY);
        SDL_RenderDrawLine(renderer, centreX - y, centreY - x, centreX, centreY);
        SDL_RenderDrawLine(renderer, centreX - y, centreY + x, centreX, centreY);

        if(error <= 0){
            ++y;
            error += ty;
            ty += 2;
        }

        if(error > 0) {
            --x;
            tx += 2;
            error += (tx - diameter);
        }
    }
}

void drawQuarterCircleToRenderer(SDL_Renderer * renderer, int32_t centreX, int32_t centreY, int32_t radius, bool TL, bool TR, bool BL, bool BR, int r, int g, int b, int a) {
    SDL_SetRenderDrawColor(renderer, r, g, b, a);
    const int32_t diameter = (radius * 2);

    int32_t x = (radius - 1);
    int32_t y = 0;
    int32_t tx = 1;
    int32_t ty = 1;
    int32_t error = (tx - diameter);

    while(x >= y){

        if(TL) {
            SDL_RenderDrawLine(renderer, centreX - x, centreY - y, centreX, centreY);
            SDL_RenderDrawLine(renderer, centreX - y, centreY - x, centreX, centreY);
        }

        if(TR) {
            SDL_RenderDrawLine(renderer, centreX + x, centreY - y, centreX, centreY);
            SDL_RenderDrawLine(renderer, centreX + y, centreY - x, centreX, centreY);
        }

        if(BL) {
            SDL_RenderDrawLine(renderer, centreX - x, centreY + y, centreX, centreY);
            SDL_RenderDrawLine(renderer, centreX - y, centreY + x, centreX, centreY);
        }

        if(BR) {
            SDL_RenderDrawLine(renderer, centreX + x, centreY + y, centreX, centreY);
            SDL_RenderDrawLine(renderer, centreX + y, centreY + x, centreX, centreY);
        }

        if(error <= 0){
            ++y;
            error += ty;
            ty += 2;
        }

        if(error > 0) {
            --x;
            tx += 2;
            error += (tx - diameter);
        }
    }
}

// ------------------------------------------------------------------------------------------------------------------------- //

void renderStraights(SDL_Renderer* renderer, level* lvl, int cx, int cy, int range, int rsize) {
    for(int x = -range; x <= range; x++) {
        for(int y = -range; y <= range; y++) {
            if(cx+x >= 0 && cy+y >= 0 && cx+x < lvl->lines && cy+y < lvl->cols) {
                switch (lvl->map[cx+x][cy+y]){
                case NONE:
                    placeRectToRenderer(renderer, (WIDTH-rsize)/2+rsize*y, (HEIGHT-rsize)/2+rsize*x, rsize, rsize, 0, 0, 0, 255);
                    break;

                case START:
                case END:
                    placeRectToRenderer(renderer, (WIDTH-rsize)/2+rsize*y, (HEIGHT-rsize)/2+rsize*x, rsize, rsize, 0, 0, 0, 255);
                    placeRectToRenderer(renderer,
                        (WIDTH-rsize)/2+rsize*y+(int)(START_EDGE*rsize),
                        (HEIGHT-rsize)/2+rsize*x,
                        rsize-(int)(2*START_EDGE*rsize),
                        rsize,
                    64, 64, 64, 255);
                    placeRectToRenderer(renderer,
                        (WIDTH-rsize)/2+rsize*y,
                        (HEIGHT-rsize)/2+rsize*x+(int)(START_EDGE*rsize),
                        rsize,
                        rsize-(int)(2*START_EDGE*rsize),
                    64, 64, 64, 255);
                    break;

                case STR_H:
                    placeRectToRenderer(renderer, (WIDTH-rsize)/2+rsize*y, (HEIGHT-rsize)/2+rsize*x, rsize, rsize, 0, 0, 0, 255);
                    placeRectToRenderer(renderer,
                        (WIDTH-rsize)/2+rsize*y,
                        (HEIGHT-rsize)/2+rsize*x+(int)(DIST_EDGE*rsize),
                        rsize,
                        rsize-(int)(2*DIST_EDGE*rsize),
                    64, 64, 64, 255);
                    break;

                case STR_V:
                    placeRectToRenderer(renderer, (WIDTH-rsize)/2+rsize*y, (HEIGHT-rsize)/2+rsize*x, rsize, rsize, 0, 0, 0, 255);
                    placeRectToRenderer(renderer,
                        (WIDTH-rsize)/2+rsize*y+(int)(DIST_EDGE*rsize),
                        (HEIGHT-rsize)/2+rsize*x,
                        rsize-(int)(2*DIST_EDGE*rsize),
                        rsize,
                    64, 64, 64, 255);
                    break;

                case TURN_NE:
                    break;

                case TURN_SE:
                    break;

                case TURN_SW:
                    break;

                case TURN_NW:
                    break;
                
                default:
                    break;
                }
            }
        }
    }
}

void renderCircles(SDL_Renderer* renderer, level* lvl, int cx, int cy, int range, int rsize) {
    for(int x = -range; x <= range; x++) {
        for(int y = -range; y <= range; y++) {
            if(cx+x >= 0 && cy+y >= 0 && cx+x < lvl->lines && cy+y < lvl->cols) {
                switch (lvl->map[cx+x][cy+y]){
                case NONE:
                    break;

                case START:
                case END:
                    break;

                case STR_H:
                    break;

                case STR_V:
                    break;

                case TURN_NE:
                    placeRectToRenderer(renderer,  (WIDTH-rsize)/2+rsize*y, (HEIGHT-rsize)/2+rsize*x, rsize, rsize, 0, 0, 0, 255);
                    drawQuarterCircleToRenderer(renderer, (WIDTH-rsize)/2+rsize*y+rsize, (HEIGHT-rsize)/2+rsize*x      , (int)(rsize*(1-DIST_EDGE)), 
                        false, false, true, false,
                        64, 64, 64, 192);
                    SDL_RenderFillCircle(renderer,        (WIDTH-rsize)/2+rsize*y+rsize, (HEIGHT-rsize)/2+rsize*x      , (int)(rsize*DIST_EDGE), 0, 0, 0, 255);
                    break;

                case TURN_SE:
                    placeRectToRenderer(renderer,  (WIDTH-rsize)/2+rsize*y, (HEIGHT-rsize)/2+rsize*x, rsize, rsize, 0, 0, 0, 255);
                    drawQuarterCircleToRenderer(renderer, (WIDTH-rsize)/2+rsize*y+rsize, (HEIGHT-rsize)/2+rsize*x+rsize, (int)(rsize*(1-DIST_EDGE)),
                        true, false, false, false,
                        64, 64, 64, 192);
                    SDL_RenderFillCircle(renderer,        (WIDTH-rsize)/2+rsize*y+rsize, (HEIGHT-rsize)/2+rsize*x+rsize, (int)(rsize*DIST_EDGE), 0, 0, 0, 255);
                    break;

                case TURN_SW:
                    placeRectToRenderer(renderer,  (WIDTH-rsize)/2+rsize*y, (HEIGHT-rsize)/2+rsize*x, rsize, rsize, 0, 0, 0, 255);
                    drawQuarterCircleToRenderer(renderer, (WIDTH-rsize)/2+rsize*y      , (HEIGHT-rsize)/2+rsize*x+rsize, (int)(rsize*(1-DIST_EDGE)),
                        false, true, false, false,
                        64, 64, 64, 192);
                    SDL_RenderFillCircle(renderer,        (WIDTH-rsize)/2+rsize*y      , (HEIGHT-rsize)/2+rsize*x+rsize, (int)(rsize*DIST_EDGE), 0, 0, 0, 255);
                    break;

                case TURN_NW:
                    placeRectToRenderer(renderer,  (WIDTH-rsize)/2+rsize*y, (HEIGHT-rsize)/2+rsize*x, rsize, rsize, 0, 0, 0, 255);
                    drawQuarterCircleToRenderer(renderer, (WIDTH-rsize)/2+rsize*y      , (HEIGHT-rsize)/2+rsize*x      , (int)(rsize*(1-DIST_EDGE)),
                        false, false, false, true,
                        64, 64, 64, 192);
                    SDL_RenderFillCircle(renderer,        (WIDTH-rsize)/2+rsize*y      , (HEIGHT-rsize)/2+rsize*x      , (int)(rsize*DIST_EDGE), 0, 0, 0, 255);
                    break;
                
                default:
                    break;
                }
            }
        }
    }
}

void renderPlayers(SDL_Renderer* renderer, int cx, int cy, int range, int rsize) {
    for(int p = 0; p < nPlayers; p++) {
        if(players[p].c->chx >= cx-range && players[p].c->chx <= cx+range && players[p].c->chy >= cy-range && players[p].c->chy <= cy+range) {
            int plchx = players[p].c->chx;
            int plchy = players[p].c->chy;
            int cox = (WIDTH-rsize)/2+rsize*(plchx-cx) + (int)((players[p].c->pos.fx*1.0)/ROOM_SIZE*rsize);
            int coy = (HEIGHT-rsize)/2+rsize*(plchy-cy) + (int)((players[p].c->pos.fy*1.0)/ROOM_SIZE*rsize);
            SDL_RenderFillCircle(renderer, cox, coy, PLAYER_R, players[p].rgb.red, players[p].rgb.green, players[p].rgb.blue, 255);
        } else {
            //
        }
    }
}

void renderMap(SDL_Renderer* renderer, level* lvl, int cx, int cy, int range, int rsize) {
    renderCircles(renderer, lvl, cx, cy, range, rsize);
    renderStraights(renderer, lvl, cx, cy, range, rsize);
    renderPlayers(renderer, cx, cy, range, rsize);
}

// ------------------------------------------------------------------------------------------------------------------------- //

void import_digits(SDL_Renderer* renderer) {
    imgs* res = malloc(sizeof(imgs));
    res->arr = malloc(sizeof(SDL_Texture*)*11);
    SDL_Texture* texture;
    SDL_Surface* img;

    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/digits/digit-0.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[0] = texture;

    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/digits/digit-1.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[1] = texture;

    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/digits/digit-2.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[2] = texture;

    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/digits/digit-3.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[3] = texture;

    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/digits/digit-4.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[4] = texture;

    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/digits/digit-5.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[5] = texture;

    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/digits/digit-6.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[6] = texture;

    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/digits/digit-7.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[7] = texture;

    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/digits/digit-8.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[8] = texture;

    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/digits/digit-9.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[9] = texture;

    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/digits/sign-minus.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[10] = texture;

    res->len = 11;
    digits = res;
}
void import_letters(SDL_Renderer* renderer) {
    imgs* res = malloc(sizeof(imgs));
    res->arr = malloc(sizeof(SDL_Texture*)*26);
    SDL_Texture* texture;
    SDL_Surface* img;

    int cc = 0;

    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-a.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-b.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-c.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-d.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-e.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-f.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-g.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-h.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-i.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-j.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-k.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-l.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-m.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-n.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-o.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-p.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-q.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-r.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-s.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-t.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-u.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-v.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-w.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-x.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-y.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;
    cc += 1;
    // -------------------------------------------------------- //
    img = SDL_LoadBMP("./res/letters/letter-z.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, img);
    SDL_FreeSurface(img);
    res->arr[cc] = texture;

    res->len = 26;
    letters = res;
}

void free_digits(imgs* dgts) {
    for(int i = 0; i < dgts->len; i++) {
        SDL_DestroyTexture(dgts->arr[i]);
    }
    free(dgts->arr);
    free(dgts);
}