Base

#define SDL_MAIN_HANDLED
#define SDL_TTF_H
#define _CRT_SECURE_NO_WARNINGS
#include <SDL.h>
#include <iostream>
#include <cmath>
#include <fstream>
#include <cstring>
#include <SDL_ttf.h>
#include <string>
#define NOMINMAX
#include <Windows.h>
#include <commdlg.h>
using namespace std;
//TTF_Font* font = TTF_OpenFont("C:/Windows/Fonts/Arial.ttf", 24);
SDL_Rect imageRect, saveButton, loadButton, sterge, reface, createRect, langButton, topButton;
struct punct {
    float x, y;
    int color = 0;
};
struct piesa {
    int tip, ori, ori2, esteliber[10], b, nrLinii, nrpct, ar = -1, a, lin = -1, ce = -1, r = -1, problema = 1;
    float x, y, h, l, linie[30][4], arc[10][4], cerc[10][4], dr[10][4], value[3];
    punct conexiuni[10];
    char nume[200];

}p[100], ogp[100], ptmenu[100], newPiece;
//pieces and originals we will use as base
struct conexiune {
    int p1, p2, tip, pin1, pin2;
}c[100];

int undod[1000], electric, um = 1, u = 0, muta = -1, ham, k = 1, l = 70, h = 70, x, y, t = 1, k2 = 1, nrcol, moves, tipuripiese, moves2, clickMenu, ogk = 3, maxx, maxy, pm = 0, pmx = -1, pmy = -1, pml, pmh, movepm = 0, premovex, premovey;
int rot, rot2, mm = 1, yes, running = 1, rpm, theme = 1, inbottommenu, selectbutton, ch, cinning, whichValue, cinPiece, cm, newk, drawType = 1, snap, newCheck = 0, undov[30], undonr, undocount;
int arc1, arc2, showLanguageMenu = 0, currentLanguage, premovex2, premovey2, ohm;
float scaleFactor = 50.0f;
char textcin[255];
int buttonWidth = 70, buttonWidth2;
int buttonHeight = 70;
int spacing = 10;
int offsetX = 10;
int offsetY = 30, scrollmenuh = 10, batt;

//TTF_Font* font = TTF_OpenFont("C:\Electron\Movistar Text Regular.ttf", 20);

SDL_Color col[40] = {
    {15, 29, 46,255},
    {72, 192, 240,255},
    {38, 129, 199,255},
    {183, 207, 237, 255}, //col basic

    {15, 29, 46,255},
    {72, 192, 240,255},
    {38, 129, 199,255},
    {183, 207, 237, 255},// theme 1

    {21, 21, 23,255},
    {64, 61, 64,255},
    {58, 54, 58,255},
    {227, 222, 227, 255},//theme 2

    {59, 27, 49,255},
    {240, 72, 159,255},
    {191, 13, 93,255},
    {245, 201, 231, 255},//theme 3

    {43, 27, 26,255},
    {217, 97, 41,255},
    {133, 38, 25,255},
    {235, 191, 178, 255}, //theme 4

    {24, 54, 28,255},
    {201, 16, 32,255},
    {25, 125, 14,255},
    {247, 225, 225, 255}, //theme 5
};
int vizitat[1000] = { 0 }, simu[300], lare[300], pies, con, pis[300], finish, bun, nobattery = 1;//pt simulare curent
void desenareLinie(SDL_Renderer* renderer, float x1, float y1, float x2, float y2, float scaleFactor) {
    SDL_RenderDrawLine(renderer, x1, y1, x2, y2);
}

void desenareCerc(SDL_Renderer* renderer, float cx, float cy, float rx, float ry, float scaleFactor) {
    for (int angle = 0; angle < 360; angle++) {
        float radian = angle * (3.14159 / 180);
        float x = cx + rx * cos(radian);
        float y = cy + ry * sin(radian);
        SDL_RenderDrawPoint(renderer, (int)(x), (int)(y));
    }
}
void golire() {
    if (u == 998)
        for (int i = 1;i <= 398;i++)
            undod[i] = undod[i + 600];
}


void menu(SDL_Renderer* renderer) {
    clickMenu = 0; //cout << x << " " << y << endl;
    SDL_GetRendererOutputSize(renderer, &maxx, &maxy);

    if (x <= offsetX + buttonWidth + 10) {
        if (y <= tipuripiese * 80 - 10 - scrollmenuh + 10)
            t = (y - 10 - scrollmenuh) / 80 + 1;
        l = ogp[t].l, h = ogp[t].h; //select base piece

        SDL_SetRenderDrawColor(renderer, col[t].r, col[t].g, col[t].b, col[t].a);
        clickMenu = 1;
        moves = 0;
    }
    else if (x <= offsetX + buttonWidth + 30) {
        if (offsetX > 0)offsetX = -80;
        else offsetX = 10;
        clickMenu = 1;
    }

    if (x >= 130 && x <= 230 && y >= maxy - 120)
        moves = 1 - moves, clickMenu = 1;
}

void text(SDL_Renderer* renderer, char t[100], int x, int y, int size) {
    TTF_Font* font = TTF_OpenFont("C:\\Electron\\arial unicode ms.otf", size);
    SDL_Color color = { 255, 255, 255 };

    const char* text = t;
    SDL_Surface* surface = TTF_RenderText_Solid(font, text, color);

    SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surface);
    SDL_FreeSurface(surface);


    SDL_Rect destRect = { x, y, strlen(t) * (size / 2), size * 2 };
    SDL_RenderCopy(renderer, texture, NULL, &destRect);
    SDL_DestroyTexture(texture);
    TTF_CloseFont(font);
}

int inButton(int xb, int yb, int l, int h) {
    return x >= xb && x <= xb + l && y >= yb && y <= yb + h;
}

void drawMenu(SDL_Renderer* renderer) {
    int maxx, maxy;
    offsetY = scrollmenuh;
    char c2[10];
    if (currentLanguage) strcpy(c2, "Salveaza");
    else strcpy(c2, "Save");
    char c1[10] = "Load", c3[10] = "Delete", c5[10] = "Undo";
    if (currentLanguage) strcpy(c1, "Încarca"), strcpy(c3, "Sterge"), strcpy(c5, "Anuleaza");
    SDL_GetRendererOutputSize(renderer, &maxx, &maxy);

    SDL_Rect bg = { 0, 0, offsetX + buttonWidth + 10 ,maxy };
    SDL_SetRenderDrawColor(renderer, col[0].r, col[0].g, col[0].b, col[0].a);
    SDL_RenderFillRect(renderer, &bg);
    SDL_Rect minimizer = { offsetX + buttonWidth + 10 , 0,  20, maxy };
    if (inButton(offsetX + buttonWidth + 10, 0, 20, maxy))
        SDL_SetRenderDrawColor(renderer, col[1].r, col[1].g, col[1].b, col[1].a);
    else
        SDL_SetRenderDrawColor(renderer, col[2].r, col[2].g, col[2].b, col[2].a);
    SDL_RenderFillRect(renderer, &minimizer);

    SDL_SetRenderDrawColor(renderer, col[0].r, col[0].g, col[0].b, col[0].a);
    SDL_RenderDrawLine(renderer, offsetX + buttonWidth + 30, 0, offsetX + buttonWidth + 30, maxy);
    int dir = (offsetX > 0) ? 1 : -1;
    for (int i = 0;i < 5;i++) {
        SDL_RenderDrawLine(renderer, offsetX + buttonWidth + 18 - 5 * dir + i, maxy / 2, offsetX + buttonWidth + 18 + 5 * dir + i, maxy / 2 - 30);
        SDL_RenderDrawLine(renderer, offsetX + buttonWidth + 18 - 5 * dir + i, maxy / 2, offsetX + buttonWidth + 18 + 5 * dir + i, maxy / 2 + 30);

    }

    int buttonTotalWidth = buttonWidth * 2 + spacing;
    int centerX = (maxx - buttonTotalWidth) / 2;

    int buttonY = maxy - (buttonHeight + 30);  // 30px distanță față de marginea de jos
    buttonWidth2 = buttonWidth + currentLanguage * 30;

    saveButton = { centerX, buttonY, buttonWidth2, buttonHeight };

    loadButton = { centerX + buttonWidth2 + spacing, buttonY, buttonWidth2, buttonHeight };
    sterge = { loadButton.x + buttonWidth2 + spacing, buttonY,buttonWidth2,buttonHeight };
    reface = { sterge.x + buttonWidth2 + spacing, buttonY, buttonWidth2,buttonHeight };
    if (inButton(centerX, buttonY, buttonWidth2, buttonHeight))
        SDL_SetRenderDrawColor(renderer, col[1].r, col[1].g, col[1].b, col[1].a);
    else
        SDL_SetRenderDrawColor(renderer, col[2].r, col[2].g, col[2].b, col[2].a);
    SDL_RenderFillRect(renderer, &saveButton);
    SDL_SetRenderDrawColor(renderer, col[0].r, col[0].g, col[0].b, col[0].a);
    SDL_RenderDrawRect(renderer, &saveButton);
    text(renderer, c2, saveButton.x + (saveButton.w - strlen(c2) * (buttonHeight / (4 + currentLanguage * 2))) / 2,
        saveButton.y + currentLanguage * 10 + (saveButton.h - buttonHeight) / 2, buttonHeight / (2 + currentLanguage));


    if (inButton(centerX + buttonWidth2 + spacing, buttonY, buttonWidth2, buttonHeight))
        SDL_SetRenderDrawColor(renderer, col[1].r, col[1].g, col[1].b, col[1].a);
    else
        SDL_SetRenderDrawColor(renderer, col[2].r, col[2].g, col[2].b, col[2].a);
    SDL_RenderFillRect(renderer, &loadButton);
    SDL_SetRenderDrawColor(renderer, col[0].r, col[0].g, col[0].b, col[0].a);
    SDL_RenderDrawRect(renderer, &loadButton);
    text(renderer, c1, loadButton.x + (loadButton.w - strlen(c1) * (buttonHeight / (4 + currentLanguage * 2))) / 2,
        loadButton.y + currentLanguage * 10 + (loadButton.h - buttonHeight) / 2, buttonHeight / (2 + currentLanguage));

    if (inButton(loadButton.x + buttonWidth + spacing, buttonY, buttonWidth2, buttonHeight))
        SDL_SetRenderDrawColor(renderer, col[1].r, col[1].g, col[1].b, col[1].a);
    else
        SDL_SetRenderDrawColor(renderer, col[2].r, col[2].g, col[2].b, col[2].a);
    SDL_RenderFillRect(renderer, &sterge);
    SDL_SetRenderDrawColor(renderer, col[0].r, col[0].g, col[0].b, col[0].a);
    SDL_RenderDrawRect(renderer, &sterge);
    text(renderer, c3, sterge.x + (sterge.w - strlen(c3) * (buttonHeight / 6)) / 2,
        sterge.y + (sterge.h - buttonHeight + 10), buttonHeight / 3);

    if (inButton(reface.x + spacing, buttonY, buttonWidth2, buttonHeight))
        SDL_SetRenderDrawColor(renderer, col[1].r, col[1].g, col[1].b, col[1].a);
    else
        SDL_SetRenderDrawColor(renderer, col[2].r, col[2].g, col[2].b, col[2].a);
    SDL_RenderFillRect(renderer, &reface);
    SDL_SetRenderDrawColor(renderer, col[0].r, col[0].g, col[0].b, col[0].a);
    SDL_RenderDrawRect(renderer, &reface);
    text(renderer, c5, reface.x + (reface.w - strlen(c5) * (buttonHeight / (4 + currentLanguage * 2))) / 2,
        reface.y + currentLanguage * 10 + (reface.h - buttonHeight) / 2, buttonHeight / (2 + currentLanguage));

    char c6[10] = "Create";
    if (currentLanguage) strcpy(c6, "Creeaza");
    createRect = { centerX - buttonWidth2 - spacing, buttonY, buttonWidth2, buttonHeight };
    if (inButton(createRect.x, buttonY, buttonWidth2, buttonHeight))
        SDL_SetRenderDrawColor(renderer, col[1].r, col[1].g, col[1].b, col[1].a);
    else
        SDL_SetRenderDrawColor(renderer, col[2].r, col[2].g, col[2].b, col[2].a);
    SDL_RenderFillRect(renderer, &createRect);
    SDL_SetRenderDrawColor(renderer, col[0].r, col[0].g, col[0].b, col[0].a);
    SDL_RenderDrawRect(renderer, &createRect);
    text(renderer, c6, createRect.x + (createRect.w - strlen(c6) * (buttonHeight / 4)) / 2 + 18,
        createRect.y + (createRect.h - buttonHeight) / 2 + 7, buttonHeight / 2 - 12);

    langButton = { maxx - buttonWidth2 + 60 - 170, saveButton.y, buttonWidth2 + 70, buttonHeight };

    if (inButton(langButton.x, langButton.y, langButton.w, langButton.h)) {
        SDL_SetRenderDrawColor(renderer, col[1].r, col[1].g, col[1].b, col[1].a); // Highlight

    }
    else {
        SDL_SetRenderDrawColor(renderer, col[2].r, col[2].g, col[2].b, col[2].a); // Culoare normală
    }

    SDL_RenderFillRect(renderer, &langButton);
    SDL_SetRenderDrawColor(renderer, col[0].r, col[0].g, col[0].b, col[0].a);
    SDL_RenderDrawRect(renderer, &langButton);


    char langText[10];
    if (currentLanguage)
        strcpy(langText, "Engleza");
    else strcpy(langText, "Romanian");
    text(renderer, langText, langButton.x + (langButton.w - strlen(langText) * (buttonHeight / 4)) / 2,
        langButton.y + (langButton.h - buttonHeight) / 2, buttonHeight / 2);

    SDL_Surface* startSurface = SDL_LoadBMP("C:\\Electron\\porneste.bmp");
    SDL_Surface* stopSurface = SDL_LoadBMP("C:\\Electron\\stop.bmp");
    SDL_Texture* startTexture = SDL_CreateTextureFromSurface(renderer, startSurface);
    SDL_Texture* stopTexture = SDL_CreateTextureFromSurface(renderer, stopSurface);

    int buttonTopWidth = 70;
    int buttonTopHeight = 70;
    int buttonTopX = (maxx - buttonTopWidth) / 2;
    int buttonTopY = 10;

    SDL_Rect topButton = { buttonTopX, buttonTopY, buttonTopWidth, buttonTopHeight };

    //  mouse ul este peste buton
    if (inButton(topButton.x, topButton.y, topButton.w, topButton.h)) {
        SDL_SetRenderDrawColor(renderer, col[1].r, col[1].g, col[1].b, col[1].a);
    }
    else {
        SDL_SetRenderDrawColor(renderer, col[2].r, col[2].g, col[2].b, col[2].a);
    }
    SDL_RenderFillRect(renderer, &topButton);
    SDL_SetRenderDrawColor(renderer, col[0].r, col[0].g, col[0].b, col[0].a);
    SDL_RenderDrawRect(renderer, &topButton);


    SDL_Texture* currentTexture = (ohm == 0) ? startTexture : stopTexture;


    imageRect = { buttonTopX , buttonTopY , buttonTopWidth , buttonTopHeight };
    SDL_RenderCopy(renderer, currentTexture, NULL, &imageRect);

    // eliberare resurse
    SDL_FreeSurface(startSurface);
    SDL_FreeSurface(stopSurface);
    SDL_DestroyTexture(startTexture);
    SDL_DestroyTexture(stopTexture);
    SDL_DestroyTexture(currentTexture);

    if (nobattery == 0) {

        SDL_Rect warningRect = { buttonTopX - 120, buttonTopY + buttonTopHeight + 20, 300, 40 };

        SDL_SetRenderDrawColor(renderer, col[1].r, col[1].g, col[1].b, col[1].a);
        SDL_RenderFillRect(renderer, &warningRect);


        char warningText[200] = "Nu exista sursa de tensiune electrica";
        if (currentLanguage == 0) strcpy(warningText, "No electrical power source available");

        text(renderer, warningText, warningRect.x + (warningRect.w - strlen(warningText) * (35 / 4)) / 2,
            warningRect.y + (warningRect.h - 30) / 2, 35 / 2);
    }



    SDL_Rect moveMenurect = { 130, maxy - 120, 100, 100 };
    if (moves)
        SDL_SetRenderDrawColor(renderer, col[1].r, col[1].g, col[1].b, col[1].a);
    else
        SDL_SetRenderDrawColor(renderer, col[2].r, col[2].g, col[2].b, col[2].a);
    SDL_RenderFillRect(renderer, &moveMenurect);
    SDL_SetRenderDrawColor(renderer, col[0].r, col[0].g, col[0].b, col[0].a);
    SDL_RenderDrawRect(renderer, &moveMenurect);
    char c4[7];
    if (currentLanguage) strcpy(c4, "Muta");
    else strcpy(c4, "Move");
    text(renderer, c4, 130, maxy - 130, 50);

    for (int i = 1; i <= tipuripiese; i++) {

        SDL_Rect buttonRect = { offsetX, offsetY, buttonWidth, buttonHeight };


        SDL_SetRenderDrawColor(renderer, col[1].r, col[1].g, col[1].b, col[1].a);
        SDL_RenderFillRect(renderer, &buttonRect);
        if (x >= offsetX && x <= offsetX + buttonWidth && y >= offsetY && y <= offsetY + buttonHeight) {
            SDL_SetRenderDrawColor(renderer, col[3].r, col[3].g, col[3].b, col[3].a);
            SDL_RenderFillRect(renderer, &buttonRect);
        }

        SDL_SetRenderDrawColor(renderer, col[0].r, col[0].g, col[0].b, col[0].a);


        float usableWidth = buttonWidth * 0.8f;
        float usableHeight = buttonHeight * 0.8f;
        float scaleX = usableWidth / 7.0f;
        float scaleY = usableHeight / 7.0f;
        float scale = fmin(scaleX, scaleY);
        float centerX = buttonRect.x + buttonWidth / 2.0f;
        float centerY = buttonRect.y + buttonHeight / 2.0f;

        // linii
        for (int j = 0; j <= ptmenu[i].lin; j++) {
            float x1 = centerX + ptmenu[i].linie[j][0] * scale;
            float y1 = centerY + ptmenu[i].linie[j][1] * scale;
            float x2 = centerX + ptmenu[i].linie[j][2] * scale;
            float y2 = centerY + ptmenu[i].linie[j][3] * scale;
            desenareLinie(renderer, x1, y1, x2, y2, 1.0f);
            //if (i == 1) cout <<endl <<j << " ";
        }

        // cercuri
        for (int j = 0; j <= ptmenu[i].ce; j++) {
            float cx = centerX + ptmenu[i].cerc[j][0] * scale;
            float cy = centerY + ptmenu[i].cerc[j][1] * scale;
            float radius = ptmenu[i].cerc[j][2] * scale;
            desenareCerc(renderer, cx, cy, radius, radius, 1.0f);
        }



        offsetY += buttonHeight + spacing;

    }
}
float textToNumber(const char* text) {
    float numar = 0.0f;
    bool isNegative = false;
    bool decimalPointFound = false;
    float decimalFactor = 0.1f;

    for (int i = 0; text[i] != '\0'; ++i) {
        char c = text[i];

        if (c == '-' && i == 0) {
            isNegative = true;
            continue;
        }

        if (c == '.') {
            decimalPointFound = true;
            continue;
        }

        if (c >= '0' && c <= '9') {
            if (decimalPointFound) {
                numar += (c - '0') * decimalFactor;
                decimalFactor /= 10.0f;
            }
            else {
                numar = numar * 10 + (c - '0');
            }
        }
        else {
            break;
        }
    }

    if (isNegative) {
        numar = -numar;
    }

    return numar;
}

void cinText(SDL_Event& event, char* inputText, int maxLength) {
    if (event.type == SDL_KEYDOWN) {
        if (event.key.keysym.sym == SDLK_RETURN) {
            cout << textToNumber(inputText);
            cinning = 0;
        }
        else if (event.key.keysym.sym == SDLK_BACKSPACE && strlen(inputText) > 0) {
            //deletes last char
            inputText[strlen(inputText) - 1] = '\0';
        }
        else if (event.key.keysym.sym >= SDLK_SPACE && event.key.keysym.sym <= SDLK_z) {
            //inlocuit cu event.key.keysym.sym >= SDLK_SPACE && event.key.keysym.sym <= SDLK_z daca vrem si litere
            //event.key.keysym.sym >= SDLK_0 && event.key.keysym.sym <= SDLK_9 || event.key.keysym.sym == SDLK_PERIOD
            if (strlen(inputText) < maxLength - 1) {
                size_t len = strlen(inputText);
                inputText[len] = event.key.keysym.sym;
                if (event.key.keysym.mod & KMOD_SHIFT)
                    inputText[len] -= 32;
                inputText[len + 1] = '\0';
            }
        }
    }
}
void gradient(SDL_Renderer* renderer, SDL_Color c, int x, int y, int l, int h, int stdr, int tp) {
    float segm = 255.0 / l;
    float taper = float(h) / float(l) / 2.0 * tp;
    float percent;
    for (int i = 0;i <= l;i++) {
        //cout << i << " ";
        //cout << c.a - segm * i << " ";
        percent = float(i) / float(l);
        SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, c.a - segm * i);
        SDL_RenderDrawLine(renderer, x + stdr * i, y + i * taper * percent * percent, x + stdr * i, y + h - i * taper * percent * percent);
    }
}
void deleteConnection(int i, int x, int y, int pin1, int pin2) {
    p[x].esteliber[pin1]--;
    if (pin2 != -1)
        p[y].esteliber[pin2]--;

    for (int j2 = i;j2 < k2;j2++)
        c[j2] = c[j2 + 1];

    k2--;
}
void drawPieceMenu(SDL_Renderer* renderer, int& pm, SDL_Event& event) {
    if (pm) {

        SDL_SetRenderDrawColor(renderer, col[0].r, col[0].g, col[0].b, col[0].a);
        SDL_Rect menup = { pmx, pmy, pml, pmh };
        SDL_RenderFillRect(renderer, &menup);

        SDL_SetRenderDrawColor(renderer, 214, 17, 40, 255);
        menup = { int(pmx + pml * 0.85), pmy, int(pml * 0.15) + 1, int(pml * 0.15) };
        //cout<<pmx<< " "<<pmy<< " "<<pmx+pml*0.9<< " "<<pmy+pmh*0.9<<endl;
        SDL_RenderFillRect(renderer, &menup);

        SDL_SetRenderDrawColor(renderer, col[2].r, col[2].g, col[2].b, col[2].a);
        menup = { pmx, pmy, int(pml * 0.85), int(pml * 0.15) };
        SDL_RenderFillRect(renderer, &menup);


        //va trb sa adaug text..alta librarie..

        char t[100];
        if (currentLanguage) sprintf(t, "Piesa: %d", pm);
        else  sprintf(t, "Piece: %d", pm);
        text(renderer, t, pmx, pmy, 20);
        if (currentLanguage)
            strcpy(t, "Tip: ");
        else strcpy(t, "Type: ");
        strcat(t, ptmenu[p[pm].tip].nume);
        if (strlen(t) > 25)ch = 17;
        else ch = 20;
        text(renderer, t, pmx, pmy + 50, ch);
        ch = pmy + 45;
        if (strlen(t) > 25)ch -= 6;
        strcpy(t, "x");
        text(renderer, t, pmx + 0.85 * pml + 10, pmy - 20, 35);

        //for (int i = 0; i < ptmenu[j].nrpct; ++i)
          //  if (piesa.esteliber[i] == 0) {
        for (int i = 0;i < ptmenu[p[pm].tip].nrpct; i++) {
            if (currentLanguage)
                sprintf(t, "Conexiunea %d: %s", i + 1, (p[pm].esteliber[i] == 0) ? "Liber" : "Ocupat");
            else  sprintf(t, "Connection %d: %s", i + 1, (p[pm].esteliber[i] == 0) ? "Available" : "Occupied");
            ch += 50; //current heigth
            if (inButton(pmx, ch, pml, 50) && (p[pm].esteliber[i] != 0))
                gradient(renderer, col[2], pmx, ch - 3, pml, 45, 1, 0), p[pm].conexiuni[i].color = 1;
            else p[pm].conexiuni[i].color = 0;
            text(renderer, t, pmx, ch, 20);
            //cout << p[pm].esteliber[i] << " ";
            if (inButton(pmx, ch, pml, 50) && event.type == SDL_MOUSEBUTTONDOWN)
                for (int j = 1;j < k2;j++)
                    if (c[j].p1 == pm && c[j].pin1 == i || c[j].p2 == pm && c[j].pin2 == i)
                        deleteConnection(j, c[j].p1, c[j].p2, c[j].pin1, c[j].pin2);


        }
        ch += 50;

        if (cinning)
            gradient(renderer, col[2], pmx, ch + whichValue * 50 - 5, pml, 50, 1, 0);
        if (currentLanguage)
            sprintf(t, "Tensiune: %g", p[pm].value[0]);
        else sprintf(t, "Voltage: %g", p[pm].value[0]);
        text(renderer, t, pmx, ch, 20);
        if (currentLanguage)
            sprintf(t, "Intensitate: %g", p[pm].value[1]);
        else sprintf(t, "Current: %g", p[pm].value[1]);
        text(renderer, t, pmx, ch + 50, 20);
        if (currentLanguage)
            sprintf(t, "Rezistenta: %g", p[pm].value[2]);
        else sprintf(t, "Resistance: %g", p[pm].value[2]);
        text(renderer, t, pmx, ch + 100, 20);


        //cout << endl;
    }
}

int inPieceMenu() {
    if (x >= pmx && x <= pmx + pml && y >= pmy && y <= pmy + pmh) {
        if (x >= int(pmx + pml * 0.85) && y <= int(pmy + pml * 0.15))
            pm = 0;
        else if (x<int(pmx + pml * 0.85) && y <= int(pmy + pmh * 0.15))
            movepm = 1;
        else movepm = 0;
        cout << movepm;
        return 1;
    }
    return 0;
}

void drawConnectionPoints(SDL_Renderer* renderer, piesa& piesa) {

    SDL_SetRenderDrawColor(renderer, col[1].r, col[1].g, col[1].b, col[1].a);

    for (int i = 0; i < piesa.nrpct; ++i)
        if (piesa.esteliber[i] == 0) {

            float pointX = piesa.x + piesa.conexiuni[i].x * 15 + 2;
            float pointY = piesa.y + piesa.conexiuni[i].y * 15 + 3;


            SDL_Rect rect = { pointX - piesa.l / 8.75, pointY - piesa.h / 8.75, piesa.l / 8.75, piesa.h / 8.75 };
            SDL_RenderFillRect(renderer, &rect);


        }
}

void drawPiece(SDL_Renderer* renderer, piesa piece) {

    //piese inserate
    SDL_Rect rect = { piece.x - piece.l / 2,piece.y - piece.h / 2,piece.l,piece.h };
    if (piece.a == 0)
    {
        SDL_SetRenderDrawColor(renderer, 255, 10, 10, 255);
        SDL_RenderFillRect(renderer, &rect);
    }

    else
    {
        if (piece.problema == 0)


            SDL_SetRenderDrawColor(renderer, 255, 10, 10, 255);

        else
            SDL_SetRenderDrawColor(renderer, col[0].r, col[0].g, col[0].b, col[0].a);
        int  scale = 15;

        // linii
        for (int j = 0; j <= piece.lin; j++) {

            float x1 = piece.x + piece.linie[j][0] * scale;
            float y1 = piece.y + piece.linie[j][1] * scale;
            float x2 = piece.x + piece.linie[j][2] * scale;
            float y2 = piece.y + piece.linie[j][3] * scale;
            desenareLinie(renderer, x1, y1, x2, y2, 1.0f);
            //if (i == 1) cout <<endl <<j << " ";
        }
        for (int j = 0; j <= piece.r; j++) {
            float x = piece.x + piece.dr[j][0] * scale;
            float y1 = piece.y + piece.dr[j][1] * scale;
            float w = piece.dr[j][2] * scale;
            float h = piece.dr[j][3] * scale;
            SDL_Rect rect = { (int)x, (int)y1, (int)w, (int)h };
            SDL_RenderDrawRect(renderer, &rect);
        }

        //  cercuri
        for (int j = 0; j <= piece.ce; j++) {
            float cx = piece.x + piece.cerc[j][0] * scale;
            float cy = piece.y + piece.cerc[j][1] * scale;
            float radius = piece.cerc[j][2] * scale;
            desenareCerc(renderer, cx, cy, radius, radius, 1.0f);
        }


        drawConnectionPoints(renderer, piece);
    }




}
void citestePiese()
{
    int i, j;
    char c = 0;
    ifstream f("C:\\Electron.txt");
    if (!f.is_open()) {
        cout << "Nu s-a putut deschide fișierul!" << endl;

    }
    f >> tipuripiese;
    f.ignore(numeric_limits<streamsize>::max(), '\n');
    for (i = 1;i <= tipuripiese;i++)
    {

        f.get(ptmenu[i].nume, 200);
        f.ignore(numeric_limits<streamsize>::max(), '\n');
        f >> ptmenu[i].nrpct;
        f.ignore(numeric_limits<streamsize>::max(), '\n');
        for (j = 0;j < ptmenu[i].nrpct;j++)
        {
            f >> ptmenu[i].conexiuni[j].x >> ptmenu[i].conexiuni[j].y;
            f.ignore(numeric_limits<streamsize>::max(), '\n');

        }
        f >> ptmenu[i].nrLinii;
        f.ignore(numeric_limits<streamsize>::max(), '\n');
        for (j = 0;j < ptmenu[i].nrLinii;j++) {
            int k;
            f >> c;

            if (c == 'L')
            {
                ++ptmenu[i].lin;  for (k = 0;k < 4;k++)
                    f >> ptmenu[i].linie[ptmenu[i].lin][k];
            }
            else if (c == 'O')
            {
                ++ptmenu[i].ce;
                for (k = 0;k < 4;k++)
                    f >> ptmenu[i].cerc[ptmenu[i].ce][k];
            }


            f.ignore(numeric_limits<streamsize>::max(), '\n');

        }
        f >> ptmenu[i].value[0];
        f.ignore(numeric_limits<streamsize>::max(), '\n');
        f >> ptmenu[i].value[1];
        f.ignore(numeric_limits<streamsize>::max(), '\n');
        f >> ptmenu[i].value[2];
        f.ignore(numeric_limits<streamsize>::max(), '\n');
        ogp[i] = ptmenu[i];
        ogp[i].l = ogp[i].h = 70;

    }

    f.close();



}
void createPiece(SDL_Renderer* renderer) {
    golire();
    int i;
    p[k] = ogp[t];
    //p[k].nrLinii = ptmenu[t].nrLinii;
    p[k].x = x, p[k].y = y;
    p[k].l = 70, p[k].h = 70, p[k].tip = t;

    p[k++].ori = 0;
    for (i = 0;i < 3;i++)
        p[k - 1].esteliber[i] = 0;
    p[k - 1].a = p[k - 1].b = 1;
    drawPiece(renderer, p[k - 1]);
    undod[++u] = 1; //esteplin();

}


void deletePiece(int i) {
    int j;
    for (j = 1;j <= k2;j++)
    {
        if (c[j].p1 == i) {
            deleteConnection(j, c[j].p2, -1, c[j].pin2, -1);

            j--;
        }
        if (c[j].p2 == i)
        {
            deleteConnection(j, c[j].p1, -1, c[j].pin1, -1);
            j--;
        }


    }
    for (j = 1; j <= k2; ++j) {
        if (c[j].p1 > i) c[j].p1--;
        if (c[j].p2 > i) c[j].p2--;
    }
    for (j = i;j < k;j++)
        p[j] = p[j + 1];
    k--;
    pm = 0;


}

int inPiece() {

    //return which piece was clicked, 0 if no piece
    for (int i = 0;i < k;i++) {

        if (x > p[i].x - p[i].l / 2 && x < p[i].x + p[i].l / 2)
        {

            if (y > p[i].y - p[i].h / 2 && y < p[i].y + p[i].h / 2)
                return i;
        }
    }
    return 0;
}
void rotateValue(float& x, float& y, float cx, float cy, float angle) {

    float radians = angle * M_PI / 180.0f;

    float newx = cos(radians) * (x - 0) - sin(radians) * (y - 0);
    float newy = sin(radians) * (x - 0) + cos(radians) * (y - 0);

    x = newx;
    y = newy;
}

int rotateCheck(int i) {
    if (rot == 0)
        return 0;
    int cx, cy;

    cx = p[i].x + (p[i].l + 15) * cos((p[i].ori2 - 60) * M_PI / 180.0);
    cy = p[i].y + (p[i].l + 15) * sin((p[i].ori2 - 60) * M_PI / 180.0);
    //cout << cx << " " << cy << endl;
    if ((x - cx) * (x - cx) + (y - cy) * (y - cy) <= p[i].l / 10 * p[i].l / 10) {
        return 1;
    }
    return 0;
}

void rotatePiece(SDL_Renderer* renderer, int i) {
    if (rot) {

        //cout << rot2  <<" " <<rotateCheck(i)<< endl;
        SDL_SetRenderDrawColor(renderer, col[0].r, col[0].g, col[0].b, col[0].a);

        desenareCerc(renderer, p[i].x, p[i].y, p[i].l + 15, p[i].l + 15, 1);

        //p[i].ori= p[i].ori2;
        //p[i].ori2= (atan2(y - p[i].y, x - p[i].x)+45) * 180.0 / M_PI;
        //cout << angle << " " << angle2 << endl;
        //angle = angle2 - angle;
        //p[i].ori = angle - p[i].ori;
        //cout << angle << " "<< angle2 << endl;
        //cout << endl;
        desenareCerc(renderer, p[i].x + (p[i].l + 15) * cos((p[i].ori2 - 60) * M_PI / 180.0), p[i].y + (p[i].l + 15) * sin((p[i].ori2 - 60) * M_PI / 180.0), p[i].l / 7, p[i].l / 7, 1);

        rotateCheck(i);
        if (rot2) {
            if (undod[u] != 4 || undod[u - 1] != i) golire(), undod[++u] = i, undod[++u] = 4;
            p[i].ori = p[i].ori2;
            p[i].ori2 = (atan2(y - p[i].y, x - p[i].x) + 45) * 180.0 / M_PI;

            for (int j = 0; j < ptmenu[p[i].tip].nrLinii; j++) {
                //cout << p[i].linie[j][0] << " " << p[i].linie[j][1] << " " << p[i].linie[j][2] << " " << p[i].linie[j][3] << endl;
                rotateValue(p[i].linie[j][0], p[i].linie[j][1], p[i].x, p[i].y, p[i].ori2 - p[i].ori);
                rotateValue(p[i].linie[j][2], p[i].linie[j][3], p[i].x, p[i].y, p[i].ori2 - p[i].ori);
            }
            for (int j = 0;j < p[i].nrpct;j++) {
                rotateValue(p[i].conexiuni[j].x, p[i].conexiuni[j].y, p[i].x, p[i].y, p[i].ori2 - p[i].ori);
            }
            for (int j = 0;j <= p[i].ce;j++) {
                rotateValue(p[i].cerc[j][0], p[i].cerc[j][1], p[i].x, p[i].y, p[i].ori2 - p[i].ori);
            }
        }
    }
}
/*void rotationSnap(int i, int factor) {
    not sure if its worth fixing cand avem deja 360 grade
    //p[i].ori = int(p[i].ori2 / 90+factor) * 90;
    cout << p[i].ori << " " << p[i].ori2 << endl;

    for (int j = 0; j < ptmenu[p[i].tip].nrLinii; j++)
        for(int k=0;k<4;k++){
            //cout << p[i].linie[j][0] << " " << p[i].linie[j][1] << " " << p[i].linie[j][2] << " " << p[i].linie[j][3] << endl;
            p[i].linie[j][k] = ogp[p[i].tip].linie[j][k];
         }
    for (int j = 0;j < p[i].nrpct;j++) {
        p[i].conexiuni[j] = ogp[i].conexiuni[j];
    }
    //p[i].ori2 = p[i].ori + factor;
}*/



void movePiece(SDL_Renderer* renderer, SDL_Event event) {
    c[k2].p2 = 0;
    SDL_GetMouseState(&x, &y);
    int i = inPiece(), ok = 1, j;
    p[inPiece()].x += event.motion.xrel; // moves position
    p[inPiece()].y += event.motion.yrel;
    int windowWidth, windowHeight;
    SDL_GetRendererOutputSize(renderer, &windowWidth, &windowHeight);
    //  piesa ramane in fereastra
    if (p[i].x < 90 + p[i].l) p[i].x = 90 + p[i].l;
    if (p[i].x > windowWidth - p[i].l) p[i].x = windowWidth - p[i].l;
    if (p[i].y < p[i].h / 2) p[i].y = p[i].h / 2;
    if (p[i].y > windowHeight - p[i].h - sterge.h) p[i].y = windowHeight - p[i].h - sterge.h;
    for (j = 1;j < k && ok;j++)
    {
        if (abs(p[j].x - p[i].x) < (p[j].l + p[i].l) / 2 && abs(p[j].y - p[i].y) < (p[j].l + p[i].l) / 2 && i != j)
        {
            p[i].a = 0;
            p[i].b = j;
            ok = 0;
        }
        if (ok)
        {
            p[i].a = 1;
            p[p[i].b].a = 1;
        }
    }
}


void movePieceMenu(SDL_Renderer* renderer, SDL_Event event) {
    c[k2].p2 = 0;
    SDL_GetMouseState(&x, &y);

    pmx += event.motion.xrel; // moves position
    pmy += event.motion.yrel;
    //cout<<pmx<< " "<<pmy<<endl;
}

int inPunct(float mouseX, float mouseY, int& piesaselectata, int& pinselectat) {
    int i;
    for (i = 0;i < k;i++)
        for (int j = 0; j < ptmenu[p[i].tip].nrpct; j++) {

            float pointX = p[i].x + p[i].conexiuni[j].x * 15;
            float pointY = p[i].y + p[i].conexiuni[j].y * 15;
            float size = p[i].l / 5; // marimea punctului

            //  mouse ul este peste punct
            if (mouseX >= pointX - size && mouseX <= pointX + size &&
                mouseY >= pointY - size && mouseY <= pointY + size) {
                piesaselectata = i;
                pinselectat = j;
                return 1;
            }

        }

    return 0;
}
int sourcePiece = -1, targetPiece = -1, sourcePin = -1, targetPin = -1;

void dirVector(int& a, int& b) {
    //saves most important direction
    //if its more to the right than up then it will be right etc
    if (abs(a) > abs(b)) {
        a = (a > 0) - (a < 0);
        b = 0;
    }
    else {
        b = (b > 0) - (b < 0);
        a = 0;
    }
}

void drawConnect(SDL_Renderer* renderer, int i) {
    //black line between 2 pieces, to be changed later
    if (p[c[i].p1].conexiuni[c[i].pin1].color == 1 || p[c[i].p2].conexiuni[c[i].pin2].color == 1 || (yes && bun))

        SDL_SetRenderDrawColor(renderer, 0, 0, 255, 255);

    else SDL_SetRenderDrawColor(renderer, col[0].r, col[0].g, col[0].b, col[0].a);
    //SDL_RenderDrawLine(renderer, p[c[i].p1].conexiuni[c[i].pin1].x + p[c[i].p1].x - p[c[i].p1].l / 2, p[c[i].p1].conexiuni[c[i].pin1].y + p[c[i].p1].y - p[c[i].p1].h / 2,
        //p[c[i].p2].conexiuni[c[i].pin2].x +p[c[i].p2].x -p[c[i].p2].l / 2, p[c[i].p2].conexiuni[c[i].pin2].y+p[c[i].p2].y - p[c[i].p2].h / 2);
    int x1 = p[c[i].p1].conexiuni[c[i].pin1].x * 15 + p[c[i].p1].x;// -p[c[i].p1].l / 2 - p[c[i].p1].l / 17;
    int y1 = p[c[i].p1].conexiuni[c[i].pin1].y * 15 + p[c[i].p1].y;// -p[c[i].p1].h / 2 - p[c[i].p1].h / 17;
    int x2 = p[c[i].p2].conexiuni[c[i].pin2].x * 15 + p[c[i].p2].x;// -p[c[i].p2].l / 2 - p[c[i].p1].l / 17;
    int y2 = p[c[i].p2].conexiuni[c[i].pin2].y * 15 + p[c[i].p2].y;// -p[c[i].p2].h / 2 - p[c[i].p1].h / 17;
    //cout << x1 << ' ' << y1 << " " << x2 << " " << y2 << endl;
    int leftright1, updown1, leftright2, updown2, lc;

    lc = abs(x2 - x1) / 3 + 10;

    //1 if right/up -1 if left/down
    leftright1 = x1 - p[c[i].p1].x;
    updown1 = y1 - p[c[i].p1].y;
    dirVector(leftright1, updown1);

    //small line to continue the direction
    SDL_RenderDrawLine(renderer, x1, y1, x1 + leftright1 * lc, y1 + updown1 * lc);
    x1 = x1 + leftright1 * lc, y1 = y1 + updown1 * lc; //updates where we are


    //same for second one
    leftright2 = x2 - p[c[i].p2].x;
    updown2 = y2 - p[c[i].p2].y;
    dirVector(leftright2, updown2);

    SDL_RenderDrawLine(renderer, x2, y2, x2 + leftright2 * lc, y2 + updown2 * lc);
    x2 = x2 + leftright2 * lc, y2 = y2 + updown2 * lc;
    //cout<<x1<< " "<<y1<< " "<<x2<< " "<<y2<<leftright1<< " "<<updown2<<endl;
    //390 214 267 3451 -1
    //787 416 609 439 1 0 -1 1
    if (leftright2 && leftright2 == -updown1 || (leftright1 == -leftright2 && leftright1 == -1) || x1 > x2)
        swap(x1, x2), swap(y1, y2), swap(leftright1, leftright2), swap(updown1, updown2);
    if (leftright1 == leftright2 && leftright1) {
        if (leftright1 == -1)swap(x1, x2), swap(y1, y2);
        if (y1 > y2) {
            SDL_RenderDrawLine(renderer, x2, y2, x2, max(y2 + lc / 2, y1));
            y2 = max(y2 + lc / 2, y1);
        }
        else {
            SDL_RenderDrawLine(renderer, x2, y2, x2, min(y1, y2 - lc / 2));
            y2 = min(y1, y2 - lc / 2);
        }
        SDL_RenderDrawLine(renderer, x1, y1, x1, y2);
        y1 = y2;
    }
    if (leftright1 == -1 && leftright1 == -updown2 && x1 < x2) {
        SDL_RenderDrawLine(renderer, x1, y1, x1, max(y2, y1 + lc));
        y1 = max(y2, y1 + lc);
    }
    if (leftright1 == 1 && leftright1 == -updown2 && x1 > x2 && y2 >= y1) {
        //SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
        SDL_RenderDrawLine(renderer, x1, y1, x1, max(y2, y1 + lc));
        y1 = max(y2, y1 + lc);
    }
    if (updown1 == 1 && updown1 == leftright2 && x1 > x2) {
        SDL_RenderDrawLine(renderer, x2, y2, x2, max(y1, y2 + lc));
        y2 = max(y1, y2 + lc);
        //cout<<x1<< " "<<y1<< " "<<x2<< " "<<y2<<leftright1<< " "<<updown2<<endl;
    }
    //cout<<x1<< " "<<y1<< " "<<x2<< " "<<y2<<leftright1<< " "<<updown2<<endl;
    if (updown2 == -1 && updown2 == leftright1) {
        SDL_RenderDrawLine(renderer, x1, y1, x1, y1 + lc);
        y1 = y1 + lc;
        //cout<<x1<< " "<<y1<< " "<<x2<< " "<<y2<<" "<<leftright1<< " "<<updown2<<endl;
    }


    //SDL_SetRenderDrawColor(renderer, 0, 255, 0, 255);
    if (updown1 != 0) {
        int aux;
        if (updown1 == 1) {
            aux = max(y1, y2);
        }
        else aux = min(y1, y2);
        SDL_RenderDrawLine(renderer, x1, y1, x1, aux);
        y1 = aux; //so that we get a rounder form if both are vertical
        SDL_RenderDrawLine(renderer, x1, y1, x1 + (x2 - x1) / 4, y1);
        x1 = x1 + (x2 - x1) / 4;
        leftright1 = -leftright2; //so that we get a less harsh connection if one is vertical the other horizontal
    }
    //same for second
    if (updown2 != 0) {
        int aux;
        if (updown2 == 1) {
            aux = max(y1, y2);
        }
        else aux = min(y1, y2);
        SDL_RenderDrawLine(renderer, x2, y2, x2, aux);
        y2 = aux;
        SDL_RenderDrawLine(renderer, x2, y2, x2 + (x1 - x2) / 4, y2);
        x2 = x2 + (x1 - x2) / 4;
        leftright2 = -leftright1;//working primarily horizontally
    }
    //SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
    //cadranu 3 reparat
    if ((x1 > x2 && leftright2 == -1) || (x1 < x2 && leftright2 == 1) || updown1 == leftright2)
        swap(x1, x2), swap(y1, y2), swap(leftright1, leftright2), swap(updown1, updown2);
    //so we'll need less cases as x1 is the smaller one

    //SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
    //787 416 609 439 1 0 -1 1
    if (leftright1 * leftright2 < 0 && leftright1 == -1 && !updown2) {
        SDL_RenderDrawLine(renderer, x2, y2, x2, min(y2 - lc / 2, (y1 + y2 / 2)));
        y2 = min(y2 - lc / 2, (y1 + y2 / 2));
    }
    //SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);

    //cout<<x1<< " "<<y1<< " "<<x2<< " "<<y2<<" "<<leftright1<< " "<<updown1<< " "<<leftright2<< " "<<updown2<<endl;

    //750 274 566 338 1 0 -1 1
    //SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
    if (leftright1 * leftright2<0 && leftright2 == -1 && !updown1 && x1>x2) {
        //swap(x1, x2), swap(y1, y2), swap(leftright1, leftright2), swap(updown1, updown2);
        SDL_RenderDrawLine(renderer, x1, y1, x1, max((y1 + y2) / 2, y1 + lc / 2));
        y1 = max((y1 + y2) / 2, y1 + lc / 2);
        swap(x1, x2), swap(y1, y2), swap(leftright1, leftright2), swap(updown1, updown2);
    }
    //SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);

    //for the cases in which theyre going in opposite directions
    if (updown1 * updown2 < 0) {
        SDL_RenderDrawLine(renderer, x2, y2, x2 + (x1 - x2) / 3, y2);
        x2 = x2 + (x1 - x2) / 3;
    }
    //SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
    //idk if the if else is necessary tbh
    if (x1 > x2 && leftright1 == updown2 == -1)
        swap(x1, x2), swap(y1, y2), swap(leftright1, leftright2), swap(updown1, updown2);
    if (updown1 && updown2) {
        SDL_RenderDrawLine(renderer, x1, y1, x2, y1);
        SDL_RenderDrawLine(renderer, x2, y1, x2, y2);
    }
    else {
        SDL_RenderDrawLine(renderer, x1, y1, x1, y2);
        SDL_RenderDrawLine(renderer, x1, y2, x2, y2);
    }
}
void connect(SDL_Renderer* renderer) {

    //  piesa si pinul sursa
    if (targetPiece != -1 && targetPiece != sourcePiece || sourcePiece == -1) {
        sourcePiece = -1, targetPiece = -1, sourcePin = -1, targetPin = -1;

        if (!inPunct(x, y, sourcePiece, sourcePin)) {
            cout << "Nu s-a selectat un punct valid pentru conexiune" << endl;
            return;
        }
    }


    // piesa si pinul destinatie
    if (!inPunct(x, y, targetPiece, targetPin) || sourcePiece == targetPiece) {
        cout << "Nu se poate realiza conexiunea" << sourcePiece << " " << targetPiece << endl;
        return;
    }



    // creeaza conexiunea
    c[k2] = { sourcePiece, targetPiece, 0, sourcePin, targetPin };
    p[sourcePiece].esteliber[sourcePin]++;
    p[targetPiece].esteliber[targetPin]++;

    drawConnect(renderer, k2);
    golire();
    undod[++u] = 2; //esteplin();
    k2++;



}
void resizePiece(SDL_Renderer* renderer, piesa& p, float factor) {
    piesa c; c = p;
    p.l += factor * p.l;
    p.h += factor * p.h;int windowWidth, windowHeight, i, ok = 1;
    SDL_GetRendererOutputSize(renderer, &windowWidth, &windowHeight);
    if ((p.x < 80 + p.l || p.x > windowWidth - p.l || p.y < p.h / 2 || p.y > windowHeight - p.h - sterge.h) && um)
        p = c;
    else {
        for (int j = 0;j < p.nrLinii;j++) {
            p.linie[j][0] += factor * p.linie[j][0];
            p.linie[j][1] += factor * p.linie[j][1];
            p.linie[j][2] += factor * p.linie[j][2];
            p.linie[j][3] += factor * p.linie[j][3];


        }
        for (int j = 0;j <= p.ce;j++) {
            p.cerc[j][0] += factor * p.cerc[j][0];
            p.cerc[j][1] += factor * p.cerc[j][1];
            p.cerc[j][2] += factor * p.cerc[j][2];
            p.cerc[j][3] += factor * p.cerc[j][3];
        }
        for (int j = 0;j < p.nrpct;j++) {
            p.conexiuni[j].x += factor * p.conexiuni[j].x;
            p.conexiuni[j].y += factor * p.conexiuni[j].y;
        }
    }


}
void resizePM(SDL_Renderer* renderer, int i) {
    if (rpm) {
        SDL_SetRenderDrawColor(renderer, col[2].r, col[2].g, col[2].b, col[2].a);
        desenareCerc(renderer, p[i].x - p[i].l / 1, p[i].y + p[i].h * 1.4, p[i].l / 4, p[i].l / 4, 1);
        desenareCerc(renderer, p[i].x + p[i].l / 1, p[i].y + p[i].h * 1.4, p[i].l / 4, p[i].l / 4, 1);

        for (int j = 0;j < 3;j++) {
            SDL_RenderDrawLine(renderer, p[i].x - p[i].l / 1.13, p[i].y + p[i].h * 1.4 + j - 2, p[i].x - p[i].l / 0.9, p[i].y + p[i].h * 1.4 + j - 2);
            SDL_RenderDrawLine(renderer, p[i].x + p[i].l / 1.13, p[i].y + p[i].h * 1.4 + j - 2, p[i].x + p[i].l / 0.9, p[i].y + p[i].h * 1.4 + j - 2);
            SDL_RenderDrawLine(renderer, p[i].x + p[i].l / 1 + j - 2, p[i].y + p[i].h * 1.28, p[i].x + p[i].l / 1 + j - 2, p[i].y + p[i].h * 1.5);
        }

    }
}
int resizeCheck(int i) {
    if ((x - (p[i].x - p[i].l / 1)) * (x - (p[i].x - p[i].l / 1)) +
        (y - (p[i].y + p[i].h * 1.4)) * (y - (p[i].y + p[i].h * 1.4)) <=
        (p[i].l / 4) * (p[i].l / 4)) {
        return -1;
    }

    else if ((x - (p[i].x + p[i].l / 1)) * (x - (p[i].x + p[i].l / 1)) +
        (y - (p[i].y + p[i].h * 1.4)) * (y - (p[i].y + p[i].h * 1.4)) <=
        (p[i].l / 4) * (p[i].l / 4)) {
        return 1;
    }

    return 0;
}

void moveScreen(SDL_Renderer* render, SDL_Event event) {
    SDL_GetMouseState(&x, &y);
    int windowWidth, windowHeight, i, ok = 1;
    SDL_GetRendererOutputSize(render, &windowWidth, &windowHeight);
    for (i = 1;i < k && ok;i++) {
        int x, y;
        x = p[i].x + event.motion.xrel; // moves position
        y = p[i].y + event.motion.yrel;
        if (x < 90 + p[i].l || x > windowWidth - p[i].l || y < p[i].h / 2 || y > windowHeight - p[i].h - sterge.h)
            ok = 0;
    }
    for (i = 1;i < k && ok;i++)
    {
        p[i].x = p[i].x + event.motion.xrel; // moves position
        p[i].y = p[i].y + event.motion.yrel;

    }
}

void zoomScreen(SDL_Renderer* renderer, float factor) {
    SDL_GetMouseState(&x, &y);
    int windowWidth, windowHeight, i, ok = 1;
    SDL_GetRendererOutputSize(renderer, &windowWidth, &windowHeight);
    um = 0;
    for (i = 1;i < k && ok;i++) {
        piesa c = p[i];
        resizePiece(renderer, c, factor);
        c.x += (c.x - x) * factor; // moves position
        c.y += (c.y - y) * factor;
        //p[i].l += p[i].l * zoom;
        //p[i].h += p[i].h * zoom;
        if (c.x < 90 + c.l || c.x > windowWidth - c.l || c.y < c.h / 2 || c.y > windowHeight - c.h - sterge.h)
            ok = 0;


    }

    //if (ok == 0) zoomScreen(renderer, -0.1);
    if (ok) {
        for (i = 1;i < k;i++)
        {
            resizePiece(renderer, p[i], factor);
            p[i].x += (p[i].x - x) * factor; // moves position
            p[i].y += (p[i].y - y) * factor;
        }
        for (i = 1;i <= tipuripiese;i++) {
            resizePiece(renderer, ogp[i], factor);
        }
    }
    um = 1;
    cout << ogp[0].l;

}

void themeChangeArrow(SDL_Renderer* renderer, int y, int h) {
    SDL_SetRenderDrawColor(renderer, col[2].r, col[2].g, col[2].b, col[2].a);
    y += 10;
    h *= 0.75;
    for (int i = 0;i < 10;i++) {
        SDL_RenderDrawLine(renderer, maxx / 2 - maxx / 6 + i, y, maxx / 2 - maxx / 6 - maxx / 20 + i, y + h / 2);
        SDL_RenderDrawLine(renderer, maxx / 2 - maxx / 6 + i, y + h, maxx / 2 - maxx / 6 - maxx / 20 + i, y + h / 2);

        SDL_RenderDrawLine(renderer, maxx / 2 + maxx / 6 + i, y, maxx / 2 + maxx / 6 + maxx / 20 + i, y + h / 2);
        SDL_RenderDrawLine(renderer, maxx / 2 + maxx / 6 + i, y + h, maxx / 2 + maxx / 6 + maxx / 20 + i, y + h / 2);
    }
}
void themeChange(int i) {
    col[0] = col[4 * i];
    col[1] = col[4 * i + 1];
    col[2] = col[4 * i + 2];
    col[3] = col[4 * i + 3];
}

SDL_Color highlightSelection(int yMM, int h) {
    if (y >= yMM && y <= yMM + h) {
        return col[1];
    }
    else return col[2];
}
void buttonMain(SDL_Renderer* renderer, SDL_Color c, int x, int y, int l, int h) {
    SDL_Rect button = { x - l / 2, y, l, h };
    c = highlightSelection(y, h);
    SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, c.a);
    SDL_RenderFillRect(renderer, &button);

    gradient(renderer, c, x + l / 2, y, l, h - 1, 1, 0);
    gradient(renderer, c, x - l / 2, y, l, h - 1, -1, 0);

}
void load() {
    OPENFILENAME ofn;  // structura pentru deschiderea fisierului
    wchar_t szFile[260];  // tablou pentru calea fisierului selectat

    ZeroMemory(&ofn, sizeof(ofn));  // initializare cu 0
    ofn.lStructSize = sizeof(ofn);  // dimensiunea structurii
    ofn.hwndOwner = NULL;  // fara fereastra parinte
    ofn.lpstrFile = szFile;  // calea fisierului
    ofn.lpstrFile[0] = L'\0';  // calea goala initial
    ofn.nMaxFile = sizeof(szFile) / sizeof(wchar_t);  // dimensiunea maxima a caii
    ofn.lpstrFilter = L"All Files\0*.*\0Text Files\0*.TXT\0";  // filtrele de fisier
    ofn.nFilterIndex = 1;  // filtrul implicit
    ofn.lpstrFileTitle = NULL;  // fara titlu fisier
    ofn.nMaxFileTitle = 0;  // dimensiunea titlului
    ofn.lpstrInitialDir = L"C:\\";  // directorul initial
    ofn.lpstrTitle = L"Open File";  // titlul ferestrei
    ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;  // optiuni pentru fisier existent

    if (GetOpenFileName(&ofn) == TRUE) {  // deschiderea dialogului
        cout << "Fisier incarcat: " << endl;

        ifstream inFile(szFile, ios::binary);
        if (!inFile) {
            cout << "Eroare la deschiderea fișierului pentru încărcare!" << endl;
            return;
        }

        inFile.read(reinterpret_cast<char*>(&k), sizeof(k));  // citirea numarului de piese

        inFile.read(reinterpret_cast<char*>(&k2), sizeof(k2));  // citirea numarului de conexiuni

        inFile.read(reinterpret_cast<char*>(p), k * sizeof(piesa));  // citirea pieselor
        inFile.read(reinterpret_cast<char*>(c), k2 * sizeof(conexiune));  // citirea conexiunilor

        inFile.close();
        cout << k << " " << k2;
    }
}

void languageMenu(SDL_Renderer* renderer, SDL_Event event) {
    SDL_SetRenderDrawColor(renderer, col[0].r, col[0].g, col[0].b, col[0].a);
    SDL_RenderClear(renderer);

    char t[100];
    if (currentLanguage)
        strcpy(t, "Selecteaza Limba");
    else
        strcpy(t, "Select Language");
    int size = 50;
    text(renderer, t, maxx / 2 - strlen(t) / 2 * size / 2, maxy / 3 - size, size);

    buttonMain(renderer, col[2], maxx / 2, maxy / 2 - maxy / 16, maxx / 4, maxy / 10);
    if (currentLanguage)
        strcpy(t, "Romana");
    else
        strcpy(t, "Romanian");
    text(renderer, t, maxx / 2 - strlen(t) * 35 / 4, maxy / 2 - maxy / 16 + maxy / 24 - 30, 35);

    // English Button
    buttonMain(renderer, col[2], maxx / 2, maxy / 2 + maxy / 16, maxx / 4, maxy / 10);
    if (currentLanguage)
        strcpy(t, "Engleza");
    else strcpy(t, "English");
    text(renderer, t, maxx / 2 - strlen(t) * 30 / 4, maxy / 2 + maxy / 16 + maxy / 24 - 22, 30);

    if (event.type == SDL_MOUSEBUTTONDOWN) {
        if (y >= maxy / 2 - maxy / 12 && y <= maxy / 2) {
            currentLanguage = 1; // Romanian
            showLanguageMenu = 0; // Închide submeniul
        }
        else if (y >= maxy / 2 + maxy / 12 && y <= maxy / 2 + 2 * maxy / 12) {
            currentLanguage = 0; // English
            showLanguageMenu = 0; // Închide submeniul
        }
    }

    SDL_RenderPresent(renderer);
}
void mainMenu(SDL_Renderer* renderer, SDL_Event event) {

    SDL_SetRenderDrawColor(renderer, col[0].r, col[0].g, col[0].b, col[0].a);
    SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);

    SDL_RenderClear(renderer);
    char t[100];
    strcpy(t, "Electron");
    SDL_GetRendererOutputSize(renderer, &maxx, &maxy);
    int size = 80;

    text(renderer, t, maxx / 2 - strlen(t) / 2.0 * size / 2, maxy / 2 - size * 4, size);

    buttonMain(renderer, col[1], maxx / 2, maxy / 3, maxx / 3, maxy / 5);
    /*SDL_Rect button = {maxx / 3, maxy / 3, maxx / 3, maxy / 5};
    SDL_SetRenderDrawColor(renderer, col[1].r, col[1].g, col[1].b, col[1].a);
    SDL_RenderFillRect(renderer, &button);

    gradient(renderer, col[1], maxx / 3 * 2, maxy / 3, maxx / 4, maxy / 5-1, 1, 0);
    gradient(renderer, col[1], maxx / 3, maxy / 3, maxx / 4, maxy / 5 - 1, -1, 0);*/
    if (currentLanguage)
        strcpy(t, "Începe");
    else
        strcpy(t, "Start");
    size = 60;
    text(renderer, t, maxx / 2 - strlen(t) / 2 * size / 2 - 10, maxy / 2.8, size);

    buttonMain(renderer, col[2], maxx / 2, maxy / 1.72, maxx / 6, maxy / 12);
    if (currentLanguage)
        strcpy(t, "Încarca");
    else
        strcpy(t, "Load");
    size = 40;
    text(renderer, t, maxx / 2 - strlen(t) / 2.0 * size / 2, maxy / 1.75, size - 5);

    buttonMain(renderer, col[2], maxx / 2, maxy / 1.72 + maxy / 10, maxx / 6, maxy / 12);
    if (currentLanguage)
        strcpy(t, "Tema");
    else
        strcpy(t, "Theme");
    size = 40;
    text(renderer, t, maxx / 2 - strlen(t) / 2.0 * size / 2, maxy / 1.75 + maxy / 10, size);
    themeChangeArrow(renderer, maxy / 1.72 + maxy / 10, maxy / 12);

    buttonMain(renderer, col[2], maxx / 2, maxy / 1.72 + 2 * maxy / 10, maxx / 6, maxy / 12);
    if (currentLanguage)
        strcpy(t, "Limba");
    else strcpy(t, "Language");
    size = 37;
    text(renderer, t, maxx / 2 - strlen(t) / 2.0 * size / 2, maxy / 1.75 + 2 * maxy / 10, size);

    buttonMain(renderer, col[2], maxx / 2, maxy / 1.72 + 3 * maxy / 10, maxx / 6, maxy / 12);
    if (currentLanguage)
        strcpy(t, "Iesire");
    else strcpy(t, "Exit");
    size = 40;
    text(renderer, t, maxx / 2 - strlen(t) / 2.0 * size / 2, maxy / 1.75 + 3 * maxy / 10, size);

    if (event.type == SDL_MOUSEBUTTONDOWN) {
        if (y >= maxy / 3 && y <= maxy / 3 + maxy / 5)
            mm = 0;
        else if (y >= maxy / 1.72 && y <= maxy / 1.72 + maxy / 12) {
            load();
            mm = 0;
        }
        else if (y >= maxy / 1.72 + 3 * maxy / 10 && y <= maxy / 1.72 + 3 * maxy / 10 + maxy / 12) {
            mm = 0;
            running = 0;
        }
        else if (y >= maxy / 1.72 + maxy / 10 && y <= maxy / 1.72 + maxy / 10 + maxy / 12) {
            cout << theme;
            if (x < maxx / 2) {
                theme--;
                if (theme < 1) theme = 5;
            }
            else {
                theme++;
                if (theme > 5) theme = 1;
            }
            cout << theme;
            themeChange(theme);
        }
        else if (y >= maxy / 1.72 + 2 * maxy / 10 && y <= maxy / 1.72 + 3 * maxy / 10)
            showLanguageMenu = 1;

    }
    if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_RETURN) {
        mm = 0;
    }

    if (event.type == SDL_QUIT) {
        mm = 0, running = 0;
    }
    SDL_RenderPresent(renderer);
}
float normalization(float x, float middle) {
    return (x - middle) / 60;
}
float denormalization(float x, float middle) {
    return x * 60 + middle;
}

void scriePiesaNoua() {

    ifstream f_in("C:\\Electron.txt");
    if (!f_in) {
        cout << "eroare frate" << endl;
        return;
    }
    string line;
    string content;
    bool firstLine = true;  //pt modif prima linie
    while (getline(f_in, line)) {
        if (firstLine) {
            // prima linie cu valoarea noua
            content += to_string(tipuripiese) + "\n";
            firstLine = false;
        }
        else {
            // Adăugăm liniile rămase nemodificate
            content += line + "\n";
        }
    }

    f_in.close();


    ofstream f_out("C:\\Electron.txt");
    if (!f_out) {
        cout << "nu-i bine" << endl;
        return;
    }

    //continutul modificat
    f_out << content;

    // piesa noua
    if (strcmp(ptmenu[tipuripiese].nume, "") == 0) strcpy(ptmenu[tipuripiese].nume, "Untitled");
    f_out << ptmenu[tipuripiese].nume << endl;
    f_out << ptmenu[tipuripiese].nrpct << endl;
    for (int i = 0; i < ptmenu[tipuripiese].nrpct; ++i) {
        f_out << ptmenu[tipuripiese].conexiuni[i].x << " " << ptmenu[tipuripiese].conexiuni[i].y << endl;
    }
    f_out << ptmenu[tipuripiese].nrLinii + ptmenu[tipuripiese].ce + 1 + (ptmenu[tipuripiese].r + 1) * 4 << endl;

    for (int i = 0; i <= ptmenu[tipuripiese].lin; ++i) {
        f_out << "L ";
        for (int k = 0; k < 4; ++k) {
            f_out << ptmenu[tipuripiese].linie[i][k] << " ";
        }
        f_out << endl;
    }

    for (int i = 0; i <= ptmenu[tipuripiese].ce; ++i) {
        f_out << "O ";
        for (int k = 0; k < 4; ++k) {
            f_out << ptmenu[tipuripiese].cerc[i][k] << " ";
        }
        f_out << endl;
    }



    f_out << ptmenu[tipuripiese].value[0] << endl;
    f_out << ptmenu[tipuripiese].value[1] << endl;
    f_out << ptmenu[tipuripiese].value[2] << endl;


    f_out.close();  // Închidem fișierul de scriere
}




void createMenu(SDL_Renderer* renderer, SDL_Event event) {
    SDL_SetRenderDrawColor(renderer, col[0].r, col[0].g, col[0].b, col[0].a);
    SDL_RenderClear(renderer);
    int i;
    //cout << x << " " << y << endl;

    SDL_SetRenderDrawColor(renderer, col[2].r, col[2].g, col[2].b, col[2].a / 2);
    for (i = 0;i <= maxx / 4;i += 60) {
        SDL_RenderDrawLine(renderer, maxx / 2 - i, maxy / 2 - 300, maxx / 2 - i, maxy / 2 + 300);
        SDL_RenderDrawLine(renderer, maxx / 2 + i, maxy / 2 - 300, maxx / 2 + i, maxy / 2 + 300);
    }
    for (i = 0;i <= maxx / 4;i += 60) {
        SDL_RenderDrawLine(renderer, maxx / 2 - 300, maxy / 2 - i, maxx / 2 + 300, maxy / 2 - i);
        SDL_RenderDrawLine(renderer, maxx / 2 - 300, maxy / 2 + i, maxx / 2 + 300, maxy / 2 + i);
    }

    SDL_SetRenderDrawColor(renderer, col[1].r, col[1].g, col[1].b, col[1].a);
    for (i = -1;i < 2;i++) {
        SDL_RenderDrawLine(renderer, maxx / 2 - 10, maxy / 2 + i, maxx / 2 + 10, maxy / 2 + i);
        SDL_RenderDrawLine(renderer, maxx / 2 + i, maxy / 2 - 10, maxx / 2 + i, maxy / 2 + 10);
    }

    char t[50];
    SDL_Rect button = { maxx / 16 , maxy / 2 - 300, maxx / 8 + 40 + 50 * currentLanguage, 50 };
    if (currentLanguage)
        sprintf(t, "Aliniere la grila: %s", snap ? "PORNITA" : "OPRITA");
    else
        sprintf(t, "Snap to grid: %s", snap ? "ON" : "OFF");
    SDL_SetRenderDrawColor(renderer, col[2 - snap].r, col[2 - snap].g, col[2 - snap].b, col[2 - snap].a);
    SDL_RenderFillRect(renderer, &button);
    text(renderer, t, button.x + 10, button.y, 20);

    SDL_Rect button2 = { maxx / 32, maxy / 2 - 300 + button.h + 70, maxx / 2 - 300 - maxx / 16, 70 };
    if (currentLanguage)
        sprintf(t, "Adauga Segment");
    else sprintf(t, "Add Segment");
    SDL_SetRenderDrawColor(renderer, col[2 - (drawType == 1)].r, col[2 - (drawType == 1)].g, col[2 - (drawType == 1)].b, col[2 - (drawType == 1)].a);
    SDL_RenderFillRect(renderer, &button2);
    text(renderer, t, button2.x + 20, button2.y, button2.h / 2);

    SDL_Rect button3 = { maxx / 32, button2.y + button2.h + 20, maxx / 2 - 300 - maxx / 16, button2.h };
    if (currentLanguage)
        sprintf(t, "Adauga Dreptunghi");
    else sprintf(t, "Add Rectangle");
    SDL_SetRenderDrawColor(renderer, col[2 - (drawType == 2)].r, col[2 - (drawType == 2)].g, col[2 - (drawType == 2)].b, col[2 - (drawType == 2)].a);
    SDL_RenderFillRect(renderer, &button3);
    text(renderer, t, button3.x + 4, button3.y, button3.h / 2);

    SDL_Rect button4 = { maxx / 32, button3.y + button2.h + 20, maxx / 2 - 300 - maxx / 16, button2.h };
    if (currentLanguage)
        sprintf(t, "Adauga Cerc");
    else sprintf(t, "Add Circle");
    SDL_SetRenderDrawColor(renderer, col[2 - (drawType == 3)].r, col[2 - (drawType == 3)].g, col[2 - (drawType == 3)].b, col[2 - (drawType == 3)].a);
    SDL_RenderFillRect(renderer, &button4);
    text(renderer, t, button4.x + 30, button4.y, button4.h / 2);

    /*SDL_Rect button5 = {maxx / 32, button4.y + button2.h + 20, maxx / 2 - 300 - maxx / 16, button2.h};
    sprintf(t, "Add Arc");
    SDL_SetRenderDrawColor(renderer, col[2 - (drawType == 4)].r, col[2 - (drawType == 4)].g, col[2 - (drawType == 4)].b, col[2 - (drawType == 4)].a);
    SDL_RenderFillRect(renderer, &button5);
    text(renderer, t, button5.x + 50, button5.y, button5.h / 2);*/

    SDL_Rect button6 = { maxx / 32, button4.y + button2.h + 20, maxx / 2 - 300 - maxx / 16, button2.h };
    if (currentLanguage)
        sprintf(t, "Adauga Punct de Conexiune");
    else sprintf(t, "Add Connection Point");
    SDL_SetRenderDrawColor(renderer, col[2 - (drawType == 5)].r, col[2 - (drawType == 5)].g, col[2 - (drawType == 5)].b, col[2 - (drawType == 5)].a);
    SDL_RenderFillRect(renderer, &button6);
    text(renderer, t, button6.x + 10, button6.y + 15, button6.h / 2 - 10);

    SDL_Rect buttonUndo = { maxx / 32+50, maxy / 2 + 300 - button2.h, 90 + currentLanguage * 60, button2.h };
    if (currentLanguage)
        sprintf(t, "Anuleaza");
    else sprintf(t, "Undo");
    SDL_SetRenderDrawColor(renderer, col[2 - inButton(buttonUndo.x, buttonUndo.y, buttonUndo.w, buttonUndo.h)].r, col[2 - inButton(buttonUndo.x, buttonUndo.y, buttonUndo.w, buttonUndo.h)].g,
        col[2 - inButton(buttonUndo.x, buttonUndo.y, buttonUndo.w, buttonUndo.h)].b, col[2 - inButton(buttonUndo.x, buttonUndo.y, buttonUndo.w, buttonUndo.h)].a);
    SDL_RenderFillRect(renderer, &buttonUndo);
    text(renderer, t, buttonUndo.x + 8, buttonUndo.y + 2, buttonUndo.h / 2);

    SDL_Rect buttonRedo = { maxx / 32 + 90 + currentLanguage * 50 + 45+50, maxy / 2 + 300 - button2.h, 90, button2.h };
    if (currentLanguage)
        sprintf(t, "Refa");
    else sprintf(t, "Redo");
    SDL_SetRenderDrawColor(renderer, col[2 - inButton(buttonRedo.x, buttonRedo.y, buttonRedo.w, buttonRedo.h)].r, col[2 - inButton(buttonRedo.x, buttonRedo.y, buttonRedo.w, buttonRedo.h)].g,
        col[2 - inButton(buttonRedo.x, buttonRedo.y, buttonRedo.w, buttonRedo.h)].b, col[2 - inButton(buttonRedo.x, buttonRedo.y, buttonRedo.w, buttonRedo.h)].a);
    SDL_RenderFillRect(renderer, &buttonRedo);
    text(renderer, t, buttonRedo.x + 8, buttonRedo.y + 2, buttonRedo.h / 2);

    SDL_Rect buttonSave = { maxx / 2, maxy / 2 + 300, 300, 70 };
    if (currentLanguage)
        sprintf(t, "Salveaza");
    else sprintf(t, "Save");
    gradient(renderer, col[2 - inButton(buttonSave.x - 300, buttonSave.y, buttonSave.w + 300, buttonSave.h)], buttonSave.x, buttonSave.y, buttonSave.w, buttonSave.h, 1, 0);
    gradient(renderer, col[2 - inButton(buttonSave.x - 300, buttonSave.y, buttonSave.w + 300, buttonSave.h)], buttonSave.x, buttonSave.y, buttonSave.w, buttonSave.h, -1, 0);
    text(renderer, t, buttonSave.x - 50, buttonSave.y - 15, buttonSave.h / 2 + 12);

    SDL_Rect buttonX = { 10, 10, 70 + currentLanguage * 15, 50 };
    if (currentLanguage)
        sprintf(t, "Inapoi");
    else sprintf(t, "Back");
    SDL_SetRenderDrawColor(renderer, col[2].r, col[2].g, col[2].b, col[2].a);
    SDL_RenderFillRect(renderer, &buttonX);
    text(renderer, t, buttonX.x + 10, buttonX.y, buttonX.h / 2);

    gradient(renderer, col[2 - (cinning && (whichValue == -1))], maxx / 2, maxy / 2 - 370, maxx / 4, 70, 1, 0);
    gradient(renderer, col[2 - (cinning && (whichValue == -1))], maxx / 2, maxy / 2 - 370, maxx / 4, 70, -1, 0);

    gradient(renderer, col[2 * (cinning && whichValue > -1)], maxx / 2 + maxx / 4 + maxx / 8-25, maxy / 2 - 60 + whichValue * 120, maxx / 8, 120, 1, 0);
    gradient(renderer, col[2 * (cinning && whichValue > -1)], maxx / 2 + maxx / 4 + maxx / 8-25, maxy / 2 - 60 + whichValue * 120, maxx / 8, 120, -1, 0);
    SDL_SetRenderDrawColor(renderer, col[2].r, col[2].g, col[2].b, col[2].a);
    for (i = 0;i <= 3;i++)
        SDL_RenderDrawLine(renderer, maxx / 2 + 300, maxy / 2 - 60 + i * 120, maxx, maxy / 2 - 60 + i * 120);

    if (currentLanguage)
        sprintf(t, "Nume: %s", newPiece.nume);
    else sprintf(t, "Name: %s", newPiece.nume);
    text(renderer, t, maxx / 2 - strlen(t) / 2 * 20+0, maxy / 2 - 300 - 80, 40);
    if (currentLanguage)
        strcpy(t, "Tensiune");
    else strcpy(t, "Voltage");
    text(renderer, t, maxx / 2 + 300 + 100+50, maxy / 2 - 60, 30);
    sprintf(t, "%g", newPiece.value[0]);
    text(renderer, t, maxx / 2 + 300 + 150 - strlen(t) * 15 / 2+50, maxy / 2, 30);
    if (currentLanguage)
        strcpy(t, "Intensitate");
    else strcpy(t, "Current");
    text(renderer, t, maxx / 2 + 300 + 100+50, maxy / 2 + 60, 30);
    sprintf(t, "%g", newPiece.value[1]);
    text(renderer, t, maxx / 2 + 300 + 150 - strlen(t) * 15 / 2+50, maxy / 2 + 120, 30);
    if (currentLanguage)
        strcpy(t, "Rezistenta");
    else strcpy(t, "Resistance");
    text(renderer, t, maxx / 2 + 300 + 80+50, maxy / 2 + 180, 30);
    sprintf(t, "%g", newPiece.value[2]);
    text(renderer, t, maxx / 2 + 300 + 150 - strlen(t) * 15 / 2+50, maxy / 2 + 240, 30);

    newPiece.x = maxx/2 +300+200;
    newPiece.y = maxy / 2 - 200;
    newPiece.lin = (newk + 1) / 2 - 1;
    newPiece.nrLinii = newPiece.lin + 1;
    newPiece.l = 100;
    newPiece.h = 100;
    newPiece.a = 1;

    SDL_SetRenderDrawColor(renderer, col[3].r, col[3].g, col[3].b, col[3].a);
    SDL_Rect newRect = { newPiece.x - 100, newPiece.y - 100, 200, 200 };
    SDL_RenderFillRect(renderer, &newRect);

    drawPiece(renderer, newPiece);

    SDL_SetRenderDrawColor(renderer, col[3].r, col[3].g, col[3].b, col[3].a);
    for (i = 0;i < newk;i += 2) {
        SDL_RenderDrawLine(renderer, denormalization(newPiece.linie[i / 2][0], maxx / 2), denormalization(newPiece.linie[i / 2][1], maxy / 2),
            denormalization(newPiece.linie[i / 2][2], maxx / 2), denormalization(newPiece.linie[i / 2][3], maxy / 2));
        //cout << newPiece.linie[i][0] << " " << newPiece.linie[i][1] << " " << newPiece.linie[i][2] << " " << newPiece.linie[i][3] << endl;
    }
    for (i = 0;i <= newPiece.r; i++) {
        SDL_Rect temp = { denormalization(newPiece.dr[i][0], maxx / 2), denormalization(newPiece.dr[i][1], maxy / 2),
            newPiece.dr[i][2] * 60, newPiece.dr[i][3] * 60 };
        SDL_RenderDrawRect(renderer, &temp);
    }
    for (i = 0;i <= newPiece.ce; i++) {
        desenareCerc(renderer, denormalization(newPiece.cerc[i][0], maxx / 2), denormalization(newPiece.cerc[i][1], maxy / 2),
            newPiece.cerc[i][2] * 60, newPiece.cerc[i][2] * 60, 1);
    }
    SDL_SetRenderDrawColor(renderer, col[1].r, col[1].g, col[1].b, col[1].a);
    for (i = 0;i < newPiece.nrpct;i++) {
        newRect = { int(denormalization(newPiece.conexiuni[i].x, maxx / 2) - 15),int(denormalization(newPiece.conexiuni[i].y, maxy / 2) - 15) , 30, 30 };
        SDL_RenderFillRect(renderer, &newRect);
    }


    if (event.type == SDL_MOUSEBUTTONDOWN) {
        cinning = 0;
        if (inButton(maxx / 2 - 300, maxy / 2 - 300, 600, 600)) {
            if (drawType == 1) {
                if (newk % 2 == 0) {
                    newPiece.linie[newk / 2][0] = normalization(x, maxx / 2);
                    newPiece.linie[newk / 2][1] = normalization(y, maxy / 2);
                    if (snap) {
                        newPiece.linie[newk / 2][0] = round(newPiece.linie[newk / 2][0]);
                        newPiece.linie[newk / 2][1] = round(newPiece.linie[newk / 2][1]);
                    }
                    newk++;
                }
                else {
                    newPiece.linie[newk / 2][2] = normalization(x, maxx / 2);
                    newPiece.linie[newk / 2][3] = normalization(y, maxy / 2);
                    if (snap) {
                        newPiece.linie[newk / 2][2] = round(newPiece.linie[newk / 2][2]);
                        newPiece.linie[newk / 2][3] = round(newPiece.linie[newk / 2][3]);
                    }
                    newk++;
                }
            }
            if (drawType == 2) {
                newCheck = 1 - newCheck;
                if (newCheck == 1) {
                    newPiece.r++;
                    newPiece.dr[newPiece.r][0] = normalization(x, maxx / 2);
                    newPiece.dr[newPiece.r][1] = normalization(y, maxy / 2);
                    if (snap) {
                        newPiece.dr[newPiece.r][0] = round(newPiece.dr[newPiece.r][0]);
                        newPiece.dr[newPiece.r][1] = round(newPiece.dr[newPiece.r][1]);
                    }
                }
                else {
                    newPiece.dr[newPiece.r][2] = normalization(x, maxx / 2) - newPiece.dr[newPiece.r][0];
                    newPiece.dr[newPiece.r][3] = normalization(y, maxy / 2) - newPiece.dr[newPiece.r][1];
                    if (snap) {
                        newPiece.dr[newPiece.r][2] = round(newPiece.dr[newPiece.r][2]);
                        newPiece.dr[newPiece.r][3] = round(newPiece.dr[newPiece.r][3]);
                    }
                }
            }
            if (drawType == 3) {
                newCheck = 1 - newCheck;
                if (newCheck == 1) {
                    newPiece.ce++;
                    newPiece.cerc[newPiece.ce][0] = normalization(x, maxx / 2);
                    newPiece.cerc[newPiece.ce][1] = normalization(y, maxy / 2);
                    if (snap) {
                        newPiece.cerc[newPiece.ce][0] = round(newPiece.cerc[newPiece.ce][0]);
                        newPiece.cerc[newPiece.ce][1] = round(newPiece.cerc[newPiece.ce][1]);
                    }
                }
                else {
                    float x1, x2, y1, y2;
                    x1 = newPiece.cerc[newPiece.ce][0];
                    y1 = newPiece.cerc[newPiece.ce][1];
                    x2 = normalization(x, maxx / 2);
                    y2 = normalization(y, maxy / 2);
                    newPiece.cerc[newPiece.ce][2] = sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
                    newPiece.cerc[newPiece.ce][3] = newPiece.cerc[newPiece.ce][2];
                    if (snap) {
                        newPiece.cerc[newPiece.ce][2] = round(newPiece.cerc[newPiece.ce][2]);
                        newPiece.cerc[newPiece.ce][3] = round(newPiece.cerc[newPiece.ce][3]);
                    }
                }
            }
            if (drawType == 5) {
                undov[undonr++] = drawType;
                newPiece.conexiuni[newPiece.nrpct].x = normalization(x, maxx / 2);
                newPiece.conexiuni[newPiece.nrpct].y = normalization(y, maxy / 2);
                if (snap) {
                    newPiece.conexiuni[newPiece.nrpct].x = round(newPiece.conexiuni[newPiece.nrpct].x);
                    newPiece.conexiuni[newPiece.nrpct].y = round(newPiece.conexiuni[newPiece.nrpct].y);
                }
                newPiece.nrpct++;
                cout << newPiece.conexiuni[1].x << " " << newPiece.conexiuni[1].y << endl;
            }
            undov[undonr++] = drawType;
        }
        if (inButton(buttonSave.x - 300, buttonSave.y, buttonSave.w + 300, buttonSave.h)) {
            while (newPiece.r > -1) {
                newPiece.linie[newPiece.nrLinii][0] = newPiece.dr[newPiece.r][0];
                newPiece.linie[newPiece.nrLinii][1] = newPiece.dr[newPiece.r][1];
                newPiece.linie[newPiece.nrLinii][2] = newPiece.dr[newPiece.r][0] + newPiece.dr[newPiece.r][2];
                newPiece.linie[newPiece.nrLinii][3] = newPiece.dr[newPiece.r][1];

                newPiece.nrLinii++;
                newPiece.lin++;
                newPiece.linie[newPiece.nrLinii][0] = newPiece.dr[newPiece.r][0];
                newPiece.linie[newPiece.nrLinii][1] = newPiece.dr[newPiece.r][1];
                newPiece.linie[newPiece.nrLinii][2] = newPiece.dr[newPiece.r][0];
                newPiece.linie[newPiece.nrLinii][3] = newPiece.dr[newPiece.r][1] + newPiece.dr[newPiece.r][3];

                newPiece.nrLinii++;
                newPiece.lin++;
                newPiece.linie[newPiece.nrLinii][0] = newPiece.dr[newPiece.r][0] + newPiece.dr[newPiece.r][2];
                newPiece.linie[newPiece.nrLinii][1] = newPiece.dr[newPiece.r][1];
                newPiece.linie[newPiece.nrLinii][2] = newPiece.dr[newPiece.r][0] + newPiece.dr[newPiece.r][2];
                newPiece.linie[newPiece.nrLinii][3] = newPiece.dr[newPiece.r][1] + newPiece.dr[newPiece.r][3];

                newPiece.nrLinii++;
                newPiece.lin++;
                newPiece.linie[newPiece.nrLinii][0] = newPiece.dr[newPiece.r][0];
                newPiece.linie[newPiece.nrLinii][1] = newPiece.dr[newPiece.r][1] + newPiece.dr[newPiece.r][3];
                newPiece.linie[newPiece.nrLinii][2] = newPiece.dr[newPiece.r][0] + newPiece.dr[newPiece.r][2];
                newPiece.linie[newPiece.nrLinii][3] = newPiece.dr[newPiece.r][1] + newPiece.dr[newPiece.r][3];

                newPiece.nrLinii++;
                newPiece.lin++;
                newPiece.r--;
            }
            ptmenu[++tipuripiese] = newPiece;
            ogp[tipuripiese] = newPiece;
            scriePiesaNoua();
            cm = 0;
            running = 1;
        }
        if (inButton(button.x, button.y, button.w, button.h)) {
            snap = 1 - snap;
        }
        else if (inButton(button2.x, button2.y, button2.w, button2.h)) {
            drawType = 1;
        }
        else if (inButton(button3.x, button3.y, button3.w, button3.h)) {
            drawType = 2; newCheck = 0;
        }
        else if (inButton(button4.x, button4.y, button4.w, button4.h)) {
            drawType = 3; newCheck = 0;
        }
        /*else if (inButton(button5.x, button5.y, button5.w, button5.h)) {
            drawType = 4; newCheck = 0;
        }*/
        else if (inButton(button6.x, button6.y, button6.w, button6.h)) {
            drawType = 5;
        }
        else if (inButton(maxx / 4, maxy / 2 - 370, maxx / 2, 70)) {
            strcpy(newPiece.nume, "");
            cinning = 1; whichValue = -1;
        }
        else if (inButton(maxx / 2 + 350, maxy / 2 - 60, 200, 360)) {
            whichValue = (y - (maxy / 2 - 60)) / 120;
            strcpy(textcin, "");
            cinning = 1;
        }
        else if (inButton(buttonUndo.x, buttonUndo.y, buttonUndo.w, buttonUndo.h) && undonr >= 0) {
            undonr -= 2; undocount++;
            if (undov[undonr] == 1)newk -= 2;
            else if (undov[undonr] == 2)newPiece.r--;
            else if (undov[undonr] == 3)newPiece.ce--;
            else if (undov[undonr] == 5)newPiece.nrpct--;
        }
        else if (inButton(buttonRedo.x, buttonRedo.y, buttonRedo.w, buttonRedo.h) && undocount) {
            undocount--;
            if (undov[undonr] == 1)newk += 2;
            else if (undov[undonr] == 2)newPiece.r++;
            else if (undov[undonr] == 3)newPiece.ce++;
            else if (undov[undonr] == 5)newPiece.nrpct++;
            undonr += 2;
        }
        else if (inButton(buttonX.x, buttonX.y, buttonX.w, buttonX.h)) {
            cm = 0;
            running = 1;
        }

        //cout << normalization(x,maxx/2) << " " << normalization(y,maxy/2) << endl;

    }

    if (newk % 2) {
        newPiece.linie[newk / 2][2] = normalization(x, maxx / 2);
        newPiece.linie[newk / 2][3] = normalization(y, maxy / 2);
    }
    if (newCheck == 1 && drawType == 2) {
        newPiece.dr[newPiece.r][2] = normalization(x, maxx / 2) - newPiece.dr[newPiece.r][0];
        newPiece.dr[newPiece.r][3] = normalization(y, maxy / 2) - newPiece.dr[newPiece.r][1];
    }
    else if (newCheck == 1 && drawType == 3) {
        float x1, x2, y1, y2;
        x1 = newPiece.cerc[newPiece.ce][0];
        y1 = newPiece.cerc[newPiece.ce][1];
        x2 = normalization(x, maxx / 2);
        y2 = normalization(y, maxy / 2);
        newPiece.cerc[newPiece.ce][2] = sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
        newPiece.cerc[newPiece.ce][3] = newPiece.cerc[newPiece.ce][2];
    }
    if (cinning) {
        if (whichValue == -1)
            cinText(event, newPiece.nume, 50);
        else {
            cinText(event, textcin, 20);
            newPiece.value[whichValue] = textToNumber(textcin);
        }
    }
    if (event.type == SDL_QUIT) {
        cm = 0, running = 0;
    }
    SDL_RenderPresent(renderer);
}



void drawLine(SDL_Renderer* renderer) {
    //no use for testing only
    SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
    SDL_RenderDrawLine(renderer, 200, 100, 700, 500);
}




void deleteAll() {
    golire();
    undod[++u] = k;undod[++u] = k2; undod[++u] = 3; //esteplin();
    k = 1; k2 = 1;
    rot = 0, rpm = 0;
}
void un() {
    cout << undod[u] << " ";
    if (undod[u] == 1) k--;
    else if (undod[u] == 2) k2--, p[c[k2].p1].esteliber[c[k2].pin1]--, p[c[k2].p2].esteliber[c[k2].pin2]--;
    else if (undod[u] == 3) k2 = undod[--u], k = undod[--u];
    else if (undod[u] == 4)
    {
        u--;
        for (int i = 0;i <= p[undod[u]].lin;i++)
            for (int j = 0;j < 4;j++)
                p[undod[u]].linie[i][j] = ptmenu[p[undod[u]].tip].linie[i][j];
        for (int i = 0;i < p[undod[u]].nrpct;i++)
            p[undod[u]].conexiuni[i] = ptmenu[p[undod[u]].tip].conexiuni[i];
        p[undod[u]].ori = 0;
    }
    u--;
    rot = 0, rpm = 0;
}

void save() {
    OPENFILENAME ofn;  // structura pentru salvarea fisierului
    wchar_t szFile[260];  // tablou pentru calea fisierului selectat

    ZeroMemory(&ofn, sizeof(ofn));  // initializare cu 0
    ofn.lStructSize = sizeof(ofn);  // dimensiunea structurii
    ofn.hwndOwner = NULL;  // fara fereastra parinte
    ofn.lpstrFile = szFile;  // calea fisierului
    ofn.lpstrFile[0] = L'\0';  // calea goala initial
    ofn.nMaxFile = sizeof(szFile) / sizeof(wchar_t);  // dimensiunea maxima a caii
    ofn.lpstrFilter = L"All Files\0*.*\0Text Files\0*.TXT\0";  // filtrele de fisier
    ofn.nFilterIndex = 1;  // filtrul implicit
    ofn.lpstrFileTitle = NULL;  // fara titlu fisier
    ofn.nMaxFileTitle = 0;  // dimensiunea titlului
    ofn.lpstrInitialDir = L"C:\\";  // directorul initial
    ofn.lpstrTitle = L"Save As";  // titlul ferestrei
    ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_OVERWRITEPROMPT;  // optiuni pentru salvare

    if (GetSaveFileName(&ofn) == TRUE) {  // deschiderea dialogului de salvare
        wcout << L" salvat ca: " << szFile << endl;

        ofstream outFile(szFile, ios::binary);
        if (!outFile) {
            cerr << "eroare" << endl;
            return;
        }

        outFile.write(reinterpret_cast<char*>(&k), sizeof(k));  // salvarea numarului de piese
        outFile.write(reinterpret_cast<char*>(&k2), sizeof(k2));  // salvarea numarului de conexiuni

        outFile.write(reinterpret_cast<char*>(p), k * sizeof(piesa));  // salvarea pieselor
        outFile.write(reinterpret_cast<char*>(c), k2 * sizeof(conexiune));  // salvarea conexiunilor

        outFile.close();
    }
}


void showSplashScreen(SDL_Renderer* renderer, SDL_Texture* image) {
    SDL_Color theme1_bg = col[4];
    SDL_Color theme1_button = col[4];
    SDL_Color theme1_gradient = col[2];
    SDL_Color theme1_text = { 255, 255, 255, 255 };
    char title[] = "Welcome to Electron";
    char loadingText[50];
    char nameLeft[] = "Alexandru Bianca";
    char nameRight[] = "Darie Iulia";

    int progress[] = { 10, 30, 50, 75, 80,95, 97,98, 99 };
    int numSteps = 9;

    SDL_GetRendererOutputSize(renderer, &maxx, &maxy);

    for (int i = 0; i < numSteps; ++i) {

        SDL_SetRenderDrawColor(renderer, theme1_bg.r, theme1_bg.g, theme1_bg.b, 200);
        SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
        SDL_RenderClear(renderer);


        if (image) {
            SDL_Rect imgRect = { maxx / 2 - 50, 80, 150, 150 };

            SDL_RenderCopy(renderer, image, NULL, &imgRect);
        }



        buttonMain(renderer, theme1_button, maxx / 2, maxy / 2 - 35, 200, 60);
        text(renderer, title, maxx / 2 - strlen(title) / 2.0 * 32 / 2, maxy / 2 - 40, 32);


        sprintf(loadingText, "Loading %d%%", progress[i]);
        text(renderer, loadingText, maxx / 2 - strlen(loadingText) / 2.0 * 28 / 2, maxy / 2 + 40, 28);


        SDL_Rect leftRect = { maxx / 4 , maxy - 60, 120, 50 };
        buttonMain(renderer, theme1_button, leftRect.x, leftRect.y, leftRect.w, leftRect.h);


        SDL_RenderDrawRect(renderer, &leftRect);

        text(renderer, nameLeft, leftRect.x + (leftRect.w - strlen(nameLeft) * 24) / 2 + 30, leftRect.y + (leftRect.h - 24) / 10, 24);


        SDL_Rect rightRect = { 3 * maxx / 4 , maxy - 60, 120, 50 };

        buttonMain(renderer, theme1_button, rightRect.x, rightRect.y, rightRect.w, rightRect.h);

        SDL_RenderDrawRect(renderer, &rightRect);


        text(renderer, nameRight, rightRect.x + (rightRect.w - strlen(nameRight) * 24) / 2, rightRect.y + (rightRect.h - 24) / 10, 24);

        SDL_RenderPresent(renderer);
        if (i < 3 || i == 4)
            SDL_Delay(200);
        else if (i > 4) SDL_Delay(400);
        else SDL_Delay(500);
    }
}

void dfs(int nod, int bat) {
    vizitat[nod] = 1;
    simu[++pies] = nod;
    pis[nod] = 0;
    for (int m = 1; m < k2; m++) {
        if (c[m].p1 == nod && !vizitat[c[m].p2] && (bat == 0 || c[m].pin1 == 1)) {
            lare[++con] = m;
            pis[nod]++;
        }
        else if (c[m].p2 == nod && !vizitat[c[m].p1] && (bat == 0 || c[m].pin2 == 1)) {
            lare[++con] = m;
            pis[nod]++;
        }
    }
    for (int m = 1; m < k2; m++) {
        if (c[m].p1 == nod && !vizitat[c[m].p2] && (bat == 0 || c[m].pin1 == 1)) {
            dfs(c[m].p2, 0);
        }
        else if (c[m].p2 == nod && !vizitat[c[m].p1] && (bat == 0 || c[m].pin2 == 1)) {
            dfs(c[m].p1, 0);
        }
    }
}

void simularecurent() {

    for (int i = 1;i <= 999;i++) vizitat[i] = 0;
    pies = 0, con = 0;
    int i, j, ok = 1, baterie = -1;
    for (i = 1;i < k;i++)
        for (j = 0;j < p[i].nrpct;j++)
        {
            if (p[i].esteliber[j] == 0)
                ok = 0, p[i].problema = 0;
            if (strcmp(p[i].nume, "Baterie") == 0)
                baterie = i, nobattery = 1;
        }
    if (baterie == -1) ok = 0, nobattery = 0;
    if (ok)
        yes = 1, finish = 1, dfs(baterie, 1);


}

void redrawAll(SDL_Renderer* renderer, SDL_Event& event) {
    int i, j = 0;
    SDL_SetRenderDrawColor(renderer, col[3].r, col[3].g, col[3].b, col[3].a);
    SDL_RenderClear(renderer);
    //drawMenu(renderer);
    for (i = 1;i < k;i++) {
        drawPiece(renderer, p[i]);
    }

    for (i = 1;i < k2;i++) {
        drawConnect(renderer, i);
    } rotatePiece(renderer, rot);
    resizePM(renderer, rpm);
    drawMenu(renderer);
    drawPieceMenu(renderer, pm, event);
    SDL_RenderPresent(renderer);

    if (yes && finish)

    {

        bun = 1;
        for (i = 1; i < k; i++) {





            for (int m = 1; m <= pis[simu[i]]; m++) {
                drawConnect(renderer, lare[++j]);
                SDL_RenderPresent(renderer);

            }SDL_Delay(400);
        }

    }
    finish = 0;
}

int main() {
    HWND hwnd = GetConsoleWindow();
    ShowWindow(hwnd, SW_HIDE);
    if (SDL_Init(SDL_INIT_VIDEO) != 0) {
        std::cout << "SDL_Init failed: " << SDL_GetError() << std::endl;

        return 1;
    }

    if (TTF_Init() == -1) {
        std::cout << "TTF_Init failed: " << TTF_GetError() << std::endl;
        SDL_Quit();
        return 1;
    }
    //TTF_Font* font = TTF_OpenFont("C:\\Electron\\Movistar Text Regular.ttf", 20);

    SDL_Window* splashWindow = SDL_CreateWindow("Welcome", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, 0);
    SDL_Renderer* splashRenderer = SDL_CreateRenderer(splashWindow, -1, SDL_RENDERER_ACCELERATED);

    SDL_Surface* imgSurface = SDL_LoadBMP("C:\\Electron\\fulger.bmp");
    SDL_Texture* imgTexture = NULL;
    if (imgSurface) {
        imgTexture = SDL_CreateTextureFromSurface(splashRenderer, imgSurface);
        SDL_FreeSurface(imgSurface);
    }

    showSplashScreen(splashRenderer, imgTexture);


    if (imgTexture) SDL_DestroyTexture(imgTexture);
    SDL_DestroyRenderer(splashRenderer);
    SDL_DestroyWindow(splashWindow);
    //create window
    SDL_Init(SDL_INIT_VIDEO);
    SDL_Window* window = SDL_CreateWindow("Electron", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1400, 800, 0);

    //create renderer NOT the same thing as window
    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    SDL_Event event;
    SDL_SetRenderDrawColor(renderer, 30, 20, 80, 255);
    SDL_RenderClear(renderer);

    int movep = 0, current;
    //int running = 1;
    while (mm) {
        while (SDL_PollEvent(&event)) {
            if (showLanguageMenu) languageMenu(renderer, event);
            else
                mainMenu(renderer, event);

            SDL_GetMouseState(&x, &y);

        }

    }

    //set bg color (r g b values)

    citestePiese(
    );
    //drawMenu(renderer);
    //SDL_RenderPresent(renderer);

    //start main loop
mainloop:
    while (running) {
        //here add events= things that happen
        while (SDL_PollEvent(&event)) {
            SDL_GetMouseState(&x, &y);
            //when click
            if (event.type == SDL_MOUSEBUTTONDOWN) {
                //takes mouse position in x y
                SDL_GetMouseState(&x, &y);

                if (x >= saveButton.x && x <= saveButton.x + saveButton.w &&
                    y >= saveButton.y && y <= saveButton.y + saveButton.h) {
                    save(); inbottommenu = 1;
                }


                else if (x >= loadButton.x && x <= loadButton.x + loadButton.w &&
                    y >= loadButton.y && y <= loadButton.y + loadButton.h) {
                    load(); inbottommenu = 1;
                }

                else if (x >= sterge.x && x <= sterge.x + sterge.w &&
                    y >= sterge.y && y <= sterge.y + sterge.h) {
                    deleteAll(); inbottommenu = 1;
                }
                else if (x >= reface.x && x <= reface.x + reface.w &&
                    y >= reface.y && y <= reface.y + reface.h) {
                    un(); inbottommenu = 1;
                }
                else if (x >= createRect.x && x <= createRect.x + createRect.w &&
                    y >= createRect.y && y <= createRect.y + createRect.h) {
                    cm = 1; inbottommenu = 1; newk = 0;
                    newPiece = ogp[tipuripiese + 1];
                    running = 0;
                }

                else if (pm == 0 && x >= langButton.x && x <= langButton.x + langButton.w &&
                    y >= langButton.y && y <= langButton.y + langButton.h) {
                    if (currentLanguage) currentLanguage = 0;
                    else currentLanguage = 1;
                    inbottommenu = 1;
                }
                else if (x >= imageRect.x && x <= imageRect.x + imageRect.w &&
                    y >= imageRect.y && y <= imageRect.y + imageRect.h) {

                    inbottommenu = 1;
                    if (ohm) {
                        ohm = 0; yes = 0; bun = 0;
                        for (int m = 1;m < k;m++)
                            p[m].problema = 1;
                        nobattery = 1;
                    }
                    else ohm = 1, simularecurent();

                }
                else inbottommenu = 0;


                cout << inPiece(); //de verificare
                current = inPiece();

                if (event.button.button == SDL_BUTTON_RIGHT)
                    c[k2].p2 = 0;//dam cancel la conexiune

                connect(renderer); //wont do anything if we dont connect
                //can connect while moving maybe good maybe bad

                if (moves)moves2 = 1;//otherwise will move the screen infinitely
                else moves2 = 0;

                if (event.button.clicks == 2 && inPiece()) {
                    pm = inPiece();
                    pmx = maxx - 250, pmy = maxy - 400 - 50 * (p[pm].nrpct - 3), pml = 250, pmh = 400 + 50 * (p[pm].nrpct - 3);

                }
                if (!inPiece() && !inPieceMenu()) pm = 0;

                if (inPiece()) {
                    rot = rpm = inPiece();
                }
                if (rot && rotateCheck(rot)) {
                    rot2 = rotateCheck(rot);
                }


                menu(renderer); //checks if menu was pressed
                if (!clickMenu && !inPieceMenu() && !rotateCheck(rot) && resizeCheck(rpm) == 0 && !inbottommenu) {
                    if (!inPiece() && !moves && !inPunct(x, y, targetPiece, targetPin))createPiece(renderer); //draws if nothing else
                    else movep = 1;
                }
                if (event.button.button == SDL_BUTTON_RIGHT && inPiece())
                    deletePiece(inPiece());
                if (rpm && resizeCheck(rpm)) {
                    resizePiece(renderer, p[rpm], 0.1 * resizeCheck(rpm));
                }

                if (inButton(pmx, ch, pml, 150) && pm) {
                    strcpy(textcin, "");
                    cinning = 1; cinPiece = pm;
                    whichValue = (y - ch) / 50;
                }
                if (cinPiece != pm)cinning = 0;
            }
            if (cinning) {
                gradient(renderer, col[2], pmx, ch + whichValue * 50, pml, 50, 1, 0);
                cinText(event, textcin, 255);
                p[cinPiece].value[whichValue] = textToNumber(textcin);
            }

            if (x < offsetX + buttonWidth + 30 && event.type == SDL_MOUSEWHEEL) {
                scrollmenuh += event.wheel.y * 5;
                if (scrollmenuh > 10)scrollmenuh = 7;
                if (scrollmenuh < -(buttonHeight + spacing) * tipuripiese + maxy)scrollmenuh = -(buttonHeight + spacing) * tipuripiese + maxy;
            }

            if (inPiece() && event.type == SDL_MOUSEMOTION && movep && !moves2 && (muta == -1 || muta == inPiece()))
            {
                movePiece(renderer, event);
                muta = inPiece();

                if (p[inPiece()].a == 1) premovex = x, premovey = y;

            }

            if (movepm) {
                movePieceMenu(renderer, event);
            }

            if (event.type == SDL_MOUSEMOTION && moves2)
                moveScreen(renderer, event);

            if (event.type == SDL_MOUSEBUTTONUP) {
                int aux = muta;
                muta = -1;
                if (p[aux].a == 0)p[aux].x = premovex, p[aux].y = premovey, p[aux].a = 1, p[p[aux].b].a = 1;
                movep = 0, moves2 = 0, movepm = 0, rot2 = 0;//stops moving
            }


            //when key press
            //resize also maybe move in void somehow??
            if (event.type == SDL_KEYDOWN) {
                if (event.key.keysym.sym == SDLK_RIGHT && current) {
                    resizePiece(renderer, p[current], 0.1);
                }
                if (event.key.keysym.sym == SDLK_LEFT && current) {
                    resizePiece(renderer, p[current], -0.1);
                }
                if (event.key.keysym.sym == SDLK_RIGHT && moves) {
                    zoomScreen(renderer, 0.1);
                }
                if (event.key.keysym.sym == SDLK_LEFT && moves) {
                    zoomScreen(renderer, -0.1);
                }
                if (event.key.keysym.sym == SDLK_c) {
                    cm = 1; newk = 0;
                    newPiece = ogp[tipuripiese + 1];
                    running = 0;
                }
                c[k2].p2 = 0;//dam cancel la conexiune
            }

            //when close window = ends main while
            if (event.type == SDL_QUIT) {
                running = 0;
            }
            redrawAll(renderer, event);
        }
        //resets color after connection turns it white
        SDL_SetRenderDrawColor(renderer, col[t].r, col[t].g, col[t].b, col[t].a);
        //updates screen on every frame = for now NOT necessary but who knows
        //SDL_RenderPresent(renderer);
    }
    while (cm) {
        while (SDL_PollEvent(&event)) {
            createMenu(renderer, event);
            SDL_GetMouseState(&x, &y);
            if (cm == 0) {
                goto mainloop;
            }
        }
    }
    return 0;
}