complete range

#include"pch.h"
#include<SFML/Graphics.hpp>
#include<SFML/Window.hpp>
#include<SFML/OpenGL.hpp>
#include<SFML/Audio.hpp>
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<functional>
#include<ctime>
#include<time.h>
using namespace sf;
using namespace std;
struct leftmovement {
    int i, j;
};
struct rightmovement {
    int i, j;
};
struct upmovement {
    int i, j;
};
struct downmovement {
    int i, j;
};
struct BFS_Movement {
    int i, j;
}Smart_Skeleton_Movement, Red_Robot_Movement;
struct status {
    int lives = 3;
    int range = 3;

}player_status;
//////////////////////////////////////////////////////////
//Bomb struct
struct bomb {
    bool bomb_placed = 0;
    bool bomb_exploded = 0;
    vector <Sprite>range_right;
    vector <Sprite>range_left;
    vector <Sprite>range_up;
    vector <Sprite>range_down;
    Sprite sprt;
    Time bomb_time, start_explosion, explosion_time;
    Clock bomb_clock, start_clock, explosion_clock;
    int x_pos, y_pos, x_index, y_index;
    int exp_animation_x = 1, exp_animation_y = 0, bomb_animation_y, bomb_animation_x;
    bool flag_range_up = 1, flag_range_down = 1, flag_range_right = 1, flag_range_left = 1;

};
int pos_x = 1, pos_y = 0, pos = 0, a, b, i, j;
bool explosion = false, ispressed = false, flag = 0, flag1 = 0;
/////////////////////////////////////////////////////////
//General stuff
const int length = 12, width = 17;
float Smart_Monsters_Speed = 0.3;
int Random_Monsters_Speed = 1;

// Menu stuff
#define MAX_NUMBER_OF_ITEMS 4
int selectedItemIndex = 0;
Font font; Text menu[MAX_NUMBER_OF_ITEMS];
void setmenustatus(float width, float height) {
    if (!font.loadFromFile("Chocolate Bar Demo.otf"))
    {
        // handle error
        cout << "SHIIIIT" << endl;
    }

    for (int i = 0; i < MAX_NUMBER_OF_ITEMS; i++)
    {
        menu[i].setFont(font);
        if (i == 0) {
            menu[i].setFillColor(Color::Red);
            menu[i].setString("Single player");
            menu[i].setPosition(sf::Vector2f(width / 2.5, height / (MAX_NUMBER_OF_ITEMS + 1) * 2.35));
        }
        else if (i == 1) {
            menu[i].setFillColor(Color::White);
            menu[i].setString("Multiplayer");
            menu[i].setPosition(sf::Vector2f(width / 2.5, height / (MAX_NUMBER_OF_ITEMS + 1) * 3.1));

        }
        else if (i == 2)
        {
            menu[i].setFillColor(Color::White);
            menu[i].setString("About us");
            menu[i].setPosition(sf::Vector2f(width / 2.4, height / (MAX_NUMBER_OF_ITEMS + 1) * 3.75));
        }
        else {
            menu[3].setFillColor(Color::White);
            menu[3].setString("Exit");
            menu[3].setPosition(sf::Vector2f(width / 2.25, height / (MAX_NUMBER_OF_ITEMS + 1) * 4.5));
        }

    }
}

// Levels_Menu stuff
#define MAX_NUMBER_OF_levels 3
int selectedlevelIndex = 0;
Font levelsfont; Text levels[MAX_NUMBER_OF_levels];
void setlevelsstatus(float width, float height) {
    if (!levelsfont.loadFromFile("Chocolate Bar Demo.otf"))
    {
        // handle error
        cout << "SHIIIIT" << endl;
    }

    for (int i = 0; i < MAX_NUMBER_OF_levels; i++)
    {
        levels[i].setFont(levelsfont);
        if (i == 0) {
            levels[i].setFillColor(Color::Red);
            levels[i].setString("Beginner");
            levels[i].setPosition(sf::Vector2f(width / 2.4, height / (MAX_NUMBER_OF_ITEMS + 1) * 2.35));
        }
        else if (i == 1) {
            levels[i].setFillColor(Color::White);
            levels[i].setString("Advanced");
            levels[i].setPosition(sf::Vector2f(width / 2.4, height / (MAX_NUMBER_OF_ITEMS + 1) * 3.1));

        }
        else if (i == 2) {

            levels[i].setFillColor(Color::White);
            levels[i].setString("Legendary");
            levels[i].setPosition(sf::Vector2f(width / 2.4, height / (MAX_NUMBER_OF_ITEMS + 1) * 3.75));

        }
    }
}
void drawmenu(RenderWindow &window)
{
    for (int i = 0; i < MAX_NUMBER_OF_ITEMS; i++)
    {
        window.draw(menu[i]);

    }
}
void drawlev(RenderWindow &window)
{
    for (int i = 0; i < MAX_NUMBER_OF_levels; i++)
    {
        window.draw(levels[i]);

    }
}
void MoveUp()
{
    if (selectedItemIndex - 1 >= 0)
    {
        menu[selectedItemIndex].setFillColor(Color::White);
        selectedItemIndex--;
        menu[selectedItemIndex].setFillColor(Color::Red);
    }
}
void MoveUplev()
{
    if (selectedlevelIndex - 1 >= 0)
    {
        levels[selectedlevelIndex].setFillColor(Color::White);
        selectedlevelIndex--;
        levels[selectedlevelIndex].setFillColor(Color::Red);
    }
}
void MoveDown()
{
    if (selectedItemIndex + 1 < MAX_NUMBER_OF_ITEMS)
    {
        menu[selectedItemIndex].setFillColor(Color::White);
        selectedItemIndex++;
        menu[selectedItemIndex].setFillColor(Color::Red);
    }
}
void MoveDownlev()
{
    if (selectedlevelIndex + 1 < MAX_NUMBER_OF_levels)
    {
        levels[selectedlevelIndex].setFillColor(Color::White);
        selectedlevelIndex++;
        levels[selectedlevelIndex].setFillColor(Color::Red);
    }
}
int GetPressedItem() {
    return selectedItemIndex;
}
int GetPressedlevel() {
    return selectedlevelIndex;
}

int GetXindx(float a)
{
    return (a - 183) / 53 + 2;
}
int GetYindx(float a)
{
    return (a - 74) / 48 + 2;
}
int GetXpostion(int a)
{
    return ((a - 2) * 53) + 198;
}
int GetYpostion(int a)
{
    return ((a - 2) * 48) + 89;
}
void destroy_breakable_walls(int Xindx, int Yindx, Sprite Grid[][13], Texture &ground, Texture &ground2)
{

    if (Xindx % 2 == Yindx % 2) { Grid[Xindx][Yindx].setTexture(ground); }
    else { Grid[Xindx][Yindx].setTexture(ground2); }

    Grid[Xindx][Yindx].setPosition((Xindx + 2) * 53, (Yindx + 0.8) * 48);
    Grid[Xindx][Yindx].setScale(0.1009, 0.101);


}
//void destroy_breakable_walls(int Xindx, int Yindx, Sprite Grid[][10], Texture &ground, Texture &ground2)
//{
//
//  if (Xindx % 2 == Yindx % 2) { Grid[Xindx][Yindx].setTexture(ground); }
//  else { Grid[Xindx][Yindx].setTexture(ground2); }
//
//  Grid[Xindx][Yindx].setPosition((Xindx + 2) * 53, (Yindx + 0.8) * 48);
//  Grid[Xindx][Yindx].setScale(0.1009, 0.101);
//
//
//}

bool vis[20][20];
int dx[] = { 0,  0, 1, -1 };
int dy[] = { 1, -1, 0,  0 };
bool valid(int i, int j, Sprite arr[][length + 1], Texture &g1, Texture &g2)
{
    return i >= 2 and j >= 2 and i < width + 1 and j < length + 1 and !vis[i][j] and (arr[i][j].getTexture() == &g1 || arr[i][j].getTexture() == &g2);
}
void BFS(int srcX, int srcY, int distX, int distY, Sprite arr[][length + 1], Texture &g1, Texture &g2)
{
    memset(vis, 0, sizeof vis);
    queue <pair<int, int> > Q;
    vis[srcX][srcY] = 1;
    Q.push({ srcX, srcY });
    while (!Q.empty())
    {
        int nodeX = Q.front().first;
        int nodeY = Q.front().second;
        //cout << nodeY << endl;
        if ((nodeX == distX && nodeY + 1 == distY)) {
            Smart_Skeleton_Movement.i = nodeX;
            Smart_Skeleton_Movement.j = nodeY;
            Red_Robot_Movement.i = nodeX;
            Red_Robot_Movement.j = nodeY;
            break;
        }
        else if (nodeX == distX && nodeY - 1 == distY) {
            Smart_Skeleton_Movement.i = nodeX;
            Smart_Skeleton_Movement.j = nodeY;
            Red_Robot_Movement.i = nodeX;
            Red_Robot_Movement.j = nodeY;
            break;
        }
        else if (nodeX + 1 == distX && nodeY == distY) {
            Smart_Skeleton_Movement.i = nodeX;
            Smart_Skeleton_Movement.j = nodeY;
            Red_Robot_Movement.i = nodeX;
            Red_Robot_Movement.j = nodeY;
            break;
        }
        else if (nodeX - 1 == distX && nodeY == distY) {
            Smart_Skeleton_Movement.i = nodeX;
            Smart_Skeleton_Movement.j = nodeY;
            Red_Robot_Movement.i = nodeX;
            Red_Robot_Movement.j = nodeY;
            break;
        }

        Q.pop();
        for (int k = 0; k < 4; k++)
        {
            int newNodeX = nodeX + dx[k];
            int newNodeY = nodeY + dy[k];
            if (valid(newNodeX, newNodeY, arr, g1, g2))
            {
                vis[newNodeX][newNodeY] = 1;
                Q.push({ newNodeX, newNodeY });
            }
        }
    }
}

void Generate_Charcter(RectangleShape &charcter, Texture &charcter_texture, Vector2u &charcter_size, string filename, int X_Postion, int Y_Postion) {
    X_Postion = GetXpostion(X_Postion); Y_Postion = GetYpostion(Y_Postion);
    charcter.setPosition(X_Postion, Y_Postion);
    charcter.setScale(0.8, 0.8);
    charcter_texture.loadFromFile(filename);
    charcter.setTexture(&charcter_texture);
    charcter_size = charcter_texture.getSize();
    charcter_size.x /= 9;
    charcter_size.y /= 4;
    charcter.setTextureRect(IntRect(charcter_size.x * 0, charcter_size.y * 2, charcter_size.x, charcter_size.y));
}
void Movement_Upward(RectangleShape &character, Time &Monster_time, Clock &Monster_clock, float &Monster_position, Vector2u &Monster_text_size, float Monster_speed)
{
    character.move(0.0, -Monster_speed);
    Monster_time = Monster_clock.getElapsedTime();
    if (Monster_time.asSeconds() >= 0.1) {
        Monster_clock.restart();
        Monster_position++;
        if (Monster_position > 8)
            Monster_position -= 8;
    }
    character.setTextureRect(IntRect(Monster_text_size.x*Monster_position, Monster_text_size.y * 0, Monster_text_size.x, Monster_text_size.y));
}
void Movement_Downward(RectangleShape &character, Time &Monster_time, Clock &Monster_clock, float &Monster_position, Vector2u &Monster_text_size, float Monster_speed)
{
    character.move(0.0, Monster_speed);
    Monster_time = Monster_clock.getElapsedTime();
    if (Monster_time.asSeconds() >= 0.1) {
        Monster_clock.restart();
        Monster_position++;
        if (Monster_position > 8)
            Monster_position -= 8;
    }
    character.setTextureRect(IntRect(Monster_text_size.x*Monster_position, Monster_text_size.y * 2, Monster_text_size.x, Monster_text_size.y));
}
void Movement_Right(RectangleShape &character, Time &Monster_time, Clock &Monster_clock, float &Monster_position, Vector2u &Monster_text_size, float Monster_speed)
{
    character.move(Monster_speed, 0.0);
    Monster_time = Monster_clock.getElapsedTime();
    if (Monster_time.asSeconds() >= 0.1) {
        Monster_clock.restart();
        Monster_position++;
        if (Monster_position > 8)
            Monster_position -= 8;
    }
    character.setTextureRect(IntRect(Monster_text_size.x*Monster_position, Monster_text_size.y * 3, Monster_text_size.x, Monster_text_size.y));
}
void Movement_Left(RectangleShape &character, Time &Monster_time, Clock &Monster_clock, float &Monster_position, Vector2u &Monster_text_size, float Monster_speed)
{
    character.move(-Monster_speed, 0.0);
    Monster_time = Monster_clock.getElapsedTime();
    if (Monster_time.asSeconds() >= 0.1) {
        Monster_clock.restart();
        Monster_position++;
        if (Monster_position > 8)
            Monster_position -= 8;
    }
    character.setTextureRect(IntRect(Monster_text_size.x*Monster_position, Monster_text_size.y * 1, Monster_text_size.x, Monster_text_size.y));
}
void Beginner_Mode()
{
    //###############################################################################
                    // Load Songs
    Music ingame,lost;
    if (!ingame.openFromFile("ingame.wav"))             // ingame
        cout << "error to load ingame " << endl;
    if (!lost.openFromFile("For the Damaged Coda.wav"))     // End_Game
        cout << "error to load The damgae of coda";
    ingame.play();
    //###############################################################################
    // Making of Player
    RectangleShape player(Vector2f(100, 120));
    Texture player_texture;
    Vector2u player_size;
    Clock player_clock;
    Time player_time;
    float player_position = 0;
    const int player_speed = 2;
    Generate_Charcter(player, player_texture, player_size, "mainplayer.png", 10, 2);
    //###############################################################################

    //###############################################################################
    // Making of Yellow_Robot
    RectangleShape Yellow_Robot(Vector2f(100, 120));
    Texture Yellow_Robot_texture;
    Vector2u Yellow_Robot_size;
    Clock Yellow_Robot_clock;
    Time Yellow_Robot_time;
    float Yellow_Robot_speed = 1;
    float Yellow_Robot_position = 0;
    int Yellow_Robot_Counter = 0;
    int Yellow_Robot_Rand_motion = rand() % 4 + 1;
    Generate_Charcter(Yellow_Robot, Yellow_Robot_texture, Yellow_Robot_size, "yellow_robot.png", 15, 2);
    //###############################################################################

    //###############################################################################
    // Making of Skeleton
    RectangleShape Skeleton(Vector2f(100, 120));
    Texture Skeleton_texture;
    Vector2u Skeleton_size;
    Clock Skeleton_clock;
    Time Skeleton_time;
    int Skeleton_Rand_motion = rand() % 4 + 1;
    int Skeleton_counter = 0;
    float Skeleton_position = 0;
    Generate_Charcter(Skeleton, Skeleton_texture, Skeleton_size, "monster (5).png", 7, 8);
    //###############################################################################


    //###############################################################################
    // Making of White_Robot
    RectangleShape White_Robot(Vector2f(100, 120));
    Texture White_Robot_texture;
    Vector2u White_Robot_size;
    Clock White_Robot_clock;
    Time White_Robot_time;
    int White_Robot_Rand_motion = rand() % 4 + 1;
    int White_Robot_counter = 0;
    float White_Robot_position = 0;
    Generate_Charcter(White_Robot, White_Robot_texture, White_Robot_size, "white_robot.png", 14, 8);
    //###############################################################################

    //###############################################################################
    // Movement stuff
    leftmovement left; rightmovement right; upmovement up; downmovement down;
    int Player_xindx = 0, Player_yindx = 0, White_Robot_xindx = 0, White_Robot_yindx = 0, Skeleton_xindx = 0, Skeleton_yindx = 0, Robot_xindx = 0, Robot_yindx = 0;
    //###############################################################################
                        // Making of MAP //
    //###############################################################################
                        // Making of Grid //
    Texture wall, ground, wallpaper, ground2, breakable, hurt, choice;
    if (!breakable.loadFromFile("breakable.png"))
    {
        cout << "error loading breakable wall pic";
    }
    if (!wallpaper.loadFromFile("wallpaper.jpg"))
    {
        cout << "error loading wallpaper pic";
    }
    if (!wall.loadFromFile("3d wall.png"))
    {
        cout << "error loading wall pic";
    }

    if (!ground.loadFromFile("ground 1.png"))
    {
        cout << "error loading ground pic";
    }
    if (!ground2.loadFromFile("grass.png"))
    {
        cout << "error loading grass pic";
    }

    if (!hurt.loadFromFile("hurt.png"))
    {
        cout << "error loading  hurt pic";
    }
    hurt.setSmooth(1);
    //###############################################################################

                // Distribution of wall , brekable & ground on the Grid //

    Sprite Grid[width + 1][length + 1], Hurt, Wallpaper, bombing, exp;

    for (int i = 1; i <= width; i++)                // Distribution of wall and ground on the Grid //
    {
        for (int j = 1; j <= length; j++)
        {
            if (i % 2 != 0 && j % 2 != 0)
            {

                Grid[i][j].setTexture(wall);
                Grid[i][j].setPosition((i + 1.97)*53.15, (j + 0.255) * 48);
                Grid[i][j].setScale(Vector2f(0.1009, 0.165));

            }

            else if (i == 1 || i == width)
            {
                Grid[i][j].setTexture(wall);
                Grid[i][j].setPosition((i + 1.97)*53.15, (j + 0.255) * 48);
                Grid[i][j].setScale(Vector2f(0.1009, 0.165));
            }
            else if (j == 1 || j == length)
            {
                Grid[i][j].setTexture(wall);
                Grid[i][j].setPosition((i + 1.97)*53.15, (j + 0.255) * 48);
                Grid[i][j].setScale(Vector2f(0.1009, 0.165));
            }
            else
            {
                if (i % 2 == j % 2) { Grid[i][j].setTexture(ground); }
                else { Grid[i][j].setTexture(ground2); }
                Grid[i][j].setPosition((i + 2) * 53, (j + 0.8) * 48);
                Grid[i][j].setScale(0.1, 0.101);
            }
        }
    }


    for (int i = 1; i <= 30; i++)                   // Distribution of Brekable on the Grid //
    {
        int x = rand() % 15 + 2, y = rand() % 9 + 2;
        if (x % 2 != 0 && y % 2 != 0)
        {
            x++;
        }
        Grid[x][y].setTexture(breakable);
        Grid[x][y].setPosition((x + 1.97)*53.15, (y + 0.255) * 48);
        Grid[x][y].setScale(Vector2f(0.1009, 0.165));
    }



    //###############################################################################


    //###############################################################################
                            // Player Abilities and Features //
    Texture  life, bomb_frame, range, tomb, Rip, healskill, speedskill, rangeskill, timebomb, bombtext, exptext;
    Hurt.setTexture(hurt);
    Wallpaper.setTexture(wallpaper);
    if (!life.loadFromFile("flife.png"))
    {
        cout << "error loading life pic";
    }
    if (!range.loadFromFile("frange.png"))
    {
        cout << "error loading range pic";
    }
    if (!bomb_frame.loadFromFile("fbomb.png"))
    {
        cout << "error loading bomb pic";
    }
    if (!Rip.loadFromFile("death.png"))
    {
        cout << "error loading RIP pic";
    }
    if (!tomb.loadFromFile("Ripp.png"))
    {
        cout << "error loading tomb pic";
    }
    if (!healskill.loadFromFile("Heal .png"))
    {
        cout << "error to loading Heal skill" << endl;
    }

    if (!rangeskill.loadFromFile("Range skill.png"))
    {
        cout << "error to loading Range skill " << endl;
    }
    if (!timebomb.loadFromFile("time-bomb.png"))
    {
        cout << "error to loading time bomb skill " << endl;
    }


    //###############################################################################
    // Player Abilities
    //###############################################################################
    Sprite lifeS, bombS, rangeS, Tomb, RIP_Photo,timebombS[2] ,super_life[2],super_speed[2],super_range[2];
    /*super_life[0].setTexture(rangeskill);
    super_life[0].setScale(0.5, 0.3);
    super_life[0].setPosition(GetXpostion(4)+20, GetYpostion(6)); // y pos +2 needed indx*/


    lifeS.setTexture(life);
    lifeS.setPosition(0, 180);
    lifeS.setScale(0.4, 0.4);

    rangeS.setTexture(range);
    rangeS.setPosition(0, 250);
    rangeS.setScale(0.4, 0.4);

    bombS.setTexture(bomb_frame);
    bombS.setPosition(0, 330);
    bombS.setScale(0.4, 0.4);

    Tomb.setTexture(tomb);
    Tomb.setScale(0.09, 0.09);

    RIP_Photo.setTexture(Rip);
    Clock Clock_Damgae;
    //###############################################################################


    //###############################################################################
                //Player Bomb stuff //
    bombtext.loadFromFile("BOOM.png");
    exptext.loadFromFile("exp.png");
    bombing.setTexture(bombtext);
    exp.setTexture(exptext);
    Vector2u text_size_bomb = bombtext.getSize();
    Vector2u text_size_exp = exptext.getSize();
    text_size_bomb.y /= 4;
    text_size_exp.x /= 3;
    text_size_exp.y /= 3;
    Time times2, times, t, ti;
    Clock clocks2, c, cs, clocks;

    bomb bomb_template;
    bomb_template.sprt.setTexture(bombtext);
    bomb_template.sprt.setScale(0.15f, 0.15f);
    vector<bomb>bombs;
    int number_of_bombs = 0, range_of_bomb = 3, bomb_placement_timer = 0;
    //bombs.push_back(bomb_template);
    //###############################################################################
    bool death_flag=0;
    //###############################################################################
                            // Game Window //
    RenderWindow Level_1(VideoMode(1280, 768), "Fuck");
    while (Level_1.isOpen())
    {

        // Robot 1 movement
        Robot_xindx = (float)((float)(Yellow_Robot.getPosition().x - 183) / 53 + 2);
        Robot_yindx = (float)((float)(Yellow_Robot.getPosition().y - 74) / 48 + 2);
        right.i = GetXindx(Yellow_Robot.getPosition().x + 20); right.j = Robot_yindx;
        left.i = GetXindx(Yellow_Robot.getPosition().x - 20); left.j = Robot_yindx;
        up.i = Robot_xindx; up.j = GetYindx(Yellow_Robot.getPosition().y - 7);
        down.i = Robot_xindx; down.j = GetYindx(Yellow_Robot.getPosition().y + 7);
        //######################################################################################################
                                    // Robot Movement //
        if (Yellow_Robot_Counter >= 250)
        {
            Yellow_Robot_Rand_motion = rand() % 4 + 1;
            Yellow_Robot_Counter = 0;
        }

        if (Yellow_Robot_Rand_motion == 1)                                          // Moving UP => Rand_motion == 1
        {
            Yellow_Robot_Counter++;
            if (Grid[up.i][up.j].getTexture() == &ground || Grid[up.i][up.j].getTexture() == &ground2)
            {

                Movement_Upward(Yellow_Robot, Yellow_Robot_time, Yellow_Robot_clock, Yellow_Robot_position, Yellow_Robot_size, Yellow_Robot_speed);

            }
            else
            {
                Yellow_Robot_Counter = 250;
            }

        }


        else if (Yellow_Robot_Rand_motion == 2)                                 // Moving Down => Rand_motion == 2
        {
            Yellow_Robot_Counter++;
            if (Grid[down.i][down.j].getTexture() == &ground || Grid[down.i][down.j].getTexture() == &ground2)
            {
                Movement_Downward(Yellow_Robot, Yellow_Robot_time, Yellow_Robot_clock, Yellow_Robot_position, Yellow_Robot_size, Yellow_Robot_speed);
            }

            else
            {
                Yellow_Robot_Counter = 250;
            }
        }


        else if (Yellow_Robot_Rand_motion == 3)                                 // Moving Right => Rand_motion == 3
        {
            Yellow_Robot_Counter++;
            if (Grid[right.i][right.j].getTexture() == &ground || Grid[right.i][right.j].getTexture() == &ground2)
            {
                Movement_Right(Yellow_Robot, Yellow_Robot_time, Yellow_Robot_clock, Yellow_Robot_position, Yellow_Robot_size, Yellow_Robot_speed);
            }
            else
            {
                Yellow_Robot_Counter = 250;
            }
        }


        else if (Yellow_Robot_Rand_motion == 4)                                 // Moving Left => Rand_motion == 4
        {
            Yellow_Robot_Counter++;
            if (Grid[left.i][left.j].getTexture() == &ground || Grid[left.i][left.j].getTexture() == &ground2)
            {
                Movement_Left(Yellow_Robot, Yellow_Robot_time, Yellow_Robot_clock, Yellow_Robot_position, Yellow_Robot_size, Yellow_Robot_speed);
            }
            else
            {
                Yellow_Robot_Counter = 250;
            }

        }

        // Skeleton movement
        Skeleton_xindx = (float)((float)(Skeleton.getPosition().x - 183) / 53 + 2);
        Skeleton_yindx = (float)((float)(Skeleton.getPosition().y - 74) / 48 + 2);
        right.i = GetXindx(Skeleton.getPosition().x + 20); right.j = Skeleton_yindx;
        left.i = GetXindx(Skeleton.getPosition().x - 20); left.j = Skeleton_yindx;
        up.i = Skeleton_xindx; up.j = GetYindx(Skeleton.getPosition().y - 7);
        down.i = Skeleton_xindx; down.j = GetYindx(Skeleton.getPosition().y + 7);

        // Skeleton Movement
        if (Skeleton_counter >= 250)
        {
            Skeleton_Rand_motion = rand() % 4 + 1;
            Skeleton_counter = 0;
        }

        if (Skeleton_Rand_motion == 1)                                          // Moving UP => Rand_motion == 1
        {
            Skeleton_counter++;
            if (Grid[up.i][up.j].getTexture() == &ground || Grid[up.i][up.j].getTexture() == &ground2)
            {
                Movement_Upward(Skeleton, Skeleton_time, Skeleton_clock, Skeleton_position, Skeleton_size, Random_Monsters_Speed);
            }
            else
            {
                Skeleton_counter = 250;
            }

        }


        else if (Skeleton_Rand_motion == 2)                                 // Moving Down => Rand_motion == 2
        {
            Skeleton_counter++;
            if (Grid[down.i][down.j].getTexture() == &ground || Grid[down.i][down.j].getTexture() == &ground2)
            {
                Movement_Downward(Skeleton, Skeleton_time, Skeleton_clock, Skeleton_position, Skeleton_size, Random_Monsters_Speed);
            }

            else
            {
                Skeleton_counter = 250;
            }
        }


        else if (Skeleton_Rand_motion == 3)                                 // Moving Right => Rand_motion == 3
        {
            Skeleton_counter++;
            if (Grid[right.i][right.j].getTexture() == &ground || Grid[right.i][right.j].getTexture() == &ground2)
            {
                Movement_Right(Skeleton, Skeleton_time, Skeleton_clock, Skeleton_position, Skeleton_size, Random_Monsters_Speed);


            }
            else
            {
                Skeleton_counter = 250;
            }
        }


        else if (Skeleton_Rand_motion == 4)                                 // Moving Left => Rand_motion == 4
        {
            Skeleton_counter++;
            if (Grid[left.i][left.j].getTexture() == &ground || Grid[left.i][left.j].getTexture() == &ground2)
            {

                Movement_Left(Skeleton, Skeleton_time, Skeleton_clock, Skeleton_position, Skeleton_size, Random_Monsters_Speed);

            }
            else
            {
                Skeleton_counter = 250;
            }

        }

        //######################################################################################################
        // White_Robot movement
        White_Robot_xindx = (float)((float)(White_Robot.getPosition().x - 183) / 53 + 2);
        White_Robot_yindx = (float)((float)(White_Robot.getPosition().y - 74) / 48 + 2);
        right.i = GetXindx(White_Robot.getPosition().x + 20); right.j = White_Robot_yindx;
        left.i = GetXindx(White_Robot.getPosition().x - 20); left.j = White_Robot_yindx;
        up.i = White_Robot_xindx; up.j = GetYindx(White_Robot.getPosition().y - 7);
        down.i = White_Robot_xindx; down.j = GetYindx(White_Robot.getPosition().y + 7);
        //######################################################################################################

        //######################################################################################################
        // White_Robot Movement
        if (White_Robot_counter >= 250)
        {
            White_Robot_Rand_motion = rand() % 4 + 1;
            White_Robot_counter = 0;
        }

        if (White_Robot_Rand_motion == 1)                                           // Moving UP => Rand_motion == 1
        {
            White_Robot_counter++;
            if (Grid[up.i][up.j].getTexture() == &ground || Grid[up.i][up.j].getTexture() == &ground2)
            {
                Movement_Upward(White_Robot, White_Robot_time, White_Robot_clock, White_Robot_position, White_Robot_size, Random_Monsters_Speed);
            }
            else
            {
                White_Robot_counter = 250;
            }

        }


        else if (White_Robot_Rand_motion == 2)                                  // Moving Down => Rand_motion == 2
        {
            White_Robot_counter++;
            if (Grid[down.i][down.j].getTexture() == &ground || Grid[down.i][down.j].getTexture() == &ground2)
            {
                Movement_Downward(White_Robot, White_Robot_time, White_Robot_clock, White_Robot_position, White_Robot_size, Random_Monsters_Speed);
            }

            else
            {
                White_Robot_counter = 250;
            }
        }


        else if (White_Robot_Rand_motion == 3)                                  // Moving Right => Rand_motion == 3
        {
            White_Robot_counter++;
            if (Grid[right.i][right.j].getTexture() == &ground || Grid[right.i][right.j].getTexture() == &ground2)
            {
                Movement_Right(White_Robot, White_Robot_time, White_Robot_clock, White_Robot_position, White_Robot_size, Random_Monsters_Speed);

            }
            else
            {
                White_Robot_counter = 250;
            }
        }


        else if (White_Robot_Rand_motion == 4)                                  // Moving Left => Rand_motion == 4
        {
            White_Robot_counter++;
            if (Grid[left.i][left.j].getTexture() == &ground || Grid[left.i][left.j].getTexture() == &ground2)
            {
                Movement_Left(White_Robot, White_Robot_time, White_Robot_clock, White_Robot_position, White_Robot_size, Random_Monsters_Speed);
            }
            else
            {
                White_Robot_counter = 250;
            }

        }

        //######################################################################################################

        // Player Movement
        Player_xindx = (float)((float)(player.getPosition().x - 183) / 53 + 2);
        Player_yindx = (float)((float)(player.getPosition().y - 74) / 48 + 2);
        right.i = GetXindx(player.getPosition().x + 20); right.j = Player_yindx;
        left.i = GetXindx(player.getPosition().x - 20); left.j = Player_yindx;
        up.i = Player_xindx; up.j = GetYindx(player.getPosition().y - 7);
        down.i = Player_xindx; down.j = GetYindx(player.getPosition().y + 7);

        if (Keyboard::isKeyPressed(Keyboard::Key::Right) && (Grid[right.i][right.j].getTexture() == &ground || Grid[right.i][right.j].getTexture() == &ground2))      // Moving Right
        {
            Movement_Right(player, player_time, player_clock, player_position, player_size, player_speed);
        }
        else if (Keyboard::isKeyPressed(Keyboard::Key::Left) && (Grid[left.i][left.j].getTexture() == &ground || Grid[left.i][left.j].getTexture() == &ground2))         // Moving Left
        {
            Movement_Left(player, player_time, player_clock, player_position, player_size, player_speed);
        }
        else if (Keyboard::isKeyPressed(Keyboard::Key::Up) && (Grid[up.i][up.j].getTexture() == &ground || Grid[up.i][up.j].getTexture() == &ground2))           // Moving Up
        {
            Movement_Upward(player, player_time, player_clock, player_position, player_size, player_speed);
        }
        else if (Keyboard::isKeyPressed(Keyboard::Key::Down) && (Grid[down.i][down.j].getTexture() == &ground || Grid[down.i][down.j].getTexture() == &ground2))         // Moving Down
        {
            Movement_Downward(player, player_time, player_clock, player_position, player_size, player_speed);
        }

        //######################################################################################################

        Event event;
        while (Level_1.pollEvent(event))
        {
            if (event.type == sf::Event::Closed || Keyboard::isKeyPressed(Keyboard::Enter))
                Level_1.close();

        }
        Level_1.clear();
        // Drawing of the Wallpaper
        Level_1.draw(Wallpaper);
        //#####################################################################################################
        // Bombing stuff
        // bombing
        if (bomb_placement_timer < 200)
        {
            bomb_placement_timer++;
        }

        if (Keyboard::isKeyPressed(Keyboard::Key::Space) && bomb_placement_timer == 200) {

            bombs.push_back(bomb_template);


            bombs[bombs.size() - 1].bomb_clock.restart();
            bombs[bombs.size() - 1].explosion_clock.restart();
            bombs[bombs.size() - 1].start_clock.restart();



            bombs[bombs.size() - 1].bomb_placed = 1;
            bombs[bombs.size() - 1].x_pos = player.getPosition().x;
            bombs[bombs.size() - 1].y_pos = player.getPosition().y;
            bombs[bombs.size() - 1].x_index = GetXindx(bombs[bombs.size() - 1].x_pos);
            bombs[bombs.size() - 1].y_index = GetYindx(bombs[bombs.size() - 1].y_pos);
            bomb_placement_timer = 0;
        }

        //if (bombs.size()>0){
        for (int io = 0; io < bombs.size(); io++)
        {

            if (bombs[io].bomb_placed == 1) {
                bombs[io].bomb_time = bombs[io].bomb_clock.getElapsedTime();
                bombs[io].start_explosion = bombs[io].start_clock.getElapsedTime();
                if (bombs[io].bomb_time.asSeconds() >= 0.2) {
                    bombs[io].bomb_clock.restart();
                    bombs[io].sprt.setPosition(bombs[io].x_pos, bombs[io].y_pos + 25);
                    bombs[io].sprt.setTextureRect(IntRect(0, text_size_bomb.y*bombs[io].bomb_animation_y, text_size_bomb.x, text_size_bomb.y));
                    bombs[io].bomb_animation_y += 2;
                    if (bombs[io].bomb_animation_y > 2)
                        bombs[io].bomb_animation_y = 0;
                }
                if (bombs[io].start_explosion.asSeconds() >= 3) {
                    bombs[io].bomb_exploded = 1;
                    bombs[io].bomb_placed = 0;
                    //                bombs[number_of_bombs].sprt.setColor(Color::Transparent);
                    for (int k = 0; k <= range_of_bomb; k++)
                    {
                        bombs[io].range_right.push_back(exp);
                        bombs[io].range_left.push_back(exp);
                        bombs[io].range_up.push_back(exp);
                        bombs[io].range_down.push_back(exp);
                        //                     v[z].push_back(exp);
                    }
                }
            }
            //cout<<player.getPosition().x<<' '<<player.getPosition().y<<endl;
            if (bombs[io].bomb_exploded) {
                bombs[io].explosion_time = bombs[io].explosion_clock.getElapsedTime();
                if (bombs[io].explosion_time.asSeconds() >= 0.3) {
                    bombs[io].explosion_clock.restart();

                    for (int n = 0, k = 0; k <= range_of_bomb, n <= range_of_bomb * 50; k++, n += 50)
                        bombs[io].range_right[k].setPosition(bombs[io].x_pos + n, bombs[io].y_pos);

                    for (int n = 0, k = 0; k <= range_of_bomb, n <= range_of_bomb * 50; k++, n += 50)
                        bombs[io].range_right[k].setTextureRect(IntRect(text_size_exp.x*bombs[io].exp_animation_x, text_size_bomb.y*bombs[io].exp_animation_y, text_size_exp.x, text_size_exp.y));

                    for (int n = 0, k = 0; k <= range_of_bomb, n <= range_of_bomb * 50; k++, n += 50)
                        bombs[io].range_left[k].setPosition(bombs[io].x_pos - n, bombs[io].y_pos);

                    for (int n = 0, k = 0; k <= range_of_bomb, n <= range_of_bomb * 50; k++, n += 50)
                        bombs[io].range_left[k].setTextureRect(IntRect(text_size_exp.x*bombs[io].exp_animation_x, text_size_bomb.y*bombs[io].exp_animation_y, text_size_exp.x, text_size_exp.y));

                    for (int n = 0, k = 0; k <= range_of_bomb, n <= range_of_bomb * 50; k++, n += 50)
                        bombs[io].range_up[k].setPosition(bombs[io].x_pos, bombs[io].y_pos - n);

                    for (int n = 0, k = 0; k <= range_of_bomb, n <= range_of_bomb * 50; k++, n += 50)
                        bombs[io].range_up[k].setTextureRect(IntRect(text_size_exp.x*bombs[io].exp_animation_x, text_size_bomb.y*bombs[io].exp_animation_y, text_size_exp.x, text_size_exp.y));

                    for (int n = 0, k = 0; k <= range_of_bomb, n <= range_of_bomb * 50; k++, n += 50)
                        bombs[io].range_down[k].setPosition(bombs[io].x_pos, bombs[io].y_pos + n);

                    for (int n = 0, k = 0; k <= range_of_bomb, n <= range_of_bomb * 50; k++, n += 50)
                        bombs[io].range_down[k].setTextureRect(IntRect(text_size_exp.x*bombs[io].exp_animation_x, text_size_bomb.y*bombs[io].exp_animation_y, text_size_exp.x, text_size_exp.y));

                    /*if(Grid[a][b+1].getTexture()==&breakable)
                        {
                            if (a%2==(b+1)%2) {Grid[a][b+1].setTexture(ground);}
                            else {Grid[a][b+1].setTexture(ground2);}
                        }
                     else if(Grid[a+1][b].getTexture()==&breakable)
                        {
                            if ((a+1)%2==b%2) {Grid[a+1][b].setTexture(ground);}
                            else {Grid[a+1][b].setTexture(ground2);}
                        }
                    else if(Grid[a-1][b].getTexture()==&breakable)
                        {
                            if ((a-1)%2==b%2) {Grid[a-1][b].setTexture(ground);}
                            else {Grid[a-1][b].setTexture(ground2);}
                        }
                    else if(Grid[a][b-1].getTexture()==&breakable)
                        {
                            if (a%2==(b-1)%2) {Grid[a][b-1].setTexture(ground);}
                            else {Grid[a][b-1].setTexture(ground2);}
                        }*/
                    cout << bombs[io].exp_animation_x << "          " << bombs[io].exp_animation_y << endl;
                    bombs[io].exp_animation_x++;
                    if (bombs[io].exp_animation_x == 3) {
                        bombs[io].exp_animation_x = 0, bombs[io].exp_animation_y++;
                        if (bombs[io].exp_animation_y == 3) {
                            bombs[io].bomb_exploded = 0;
                            //  bombs[io].explosion_clock.restart();
                                  /*for(int z=0;z<=3;z++)
                              {
                                      bombs[number_of_bombs].range_right[z].setColor(Color::Transparent);
                                      bombs[number_of_bombs].range_left[z].setColor(Color::Transparent);
                                      bombs[number_of_bombs].range_up[z].setColor(Color::Transparent);
                                      bombs[number_of_bombs].range_down[z].setColor(Color::Transparent);

                              }*/
                            bombs.erase(bombs.begin() + 1);

                        }
                    }
                }
            }
        }
        //}
        //#####################################################################################################
        bool death_flag = 0;




        //Drawing of The Map
        for (int i = 2; i < width; i++)
        {
            for (int j = 2; j < length; j++)
            {
                if (Grid[i][j].getTexture() == &ground || Grid[i][j].getTexture() == &ground2)
                {
                    Level_1.draw(Grid[i][j]);
                }
            }

        }

        for (int j = 1; j <= length; j++)
        {
            for (int i = 1; i <= width; i++)
            {
                if (Grid[i][j].getTexture() == &ground || Grid[i][j].getTexture() == &ground2)
                {
                    continue;
                }

                Level_1.draw(Grid[i][j]);

                if (GetYindx(player.getPosition().y) >= j)
                {
                    Level_1.draw(player);
                }

                if (GetYindx(Yellow_Robot.getPosition().y) >= j)
                {
                    Level_1.draw(Yellow_Robot);
                }
                if (GetYindx(Skeleton.getPosition().y) >= j)
                {
                    Level_1.draw(Skeleton);
                }
                if (GetYindx(White_Robot.getPosition().y) >= j)
                {
                    Level_1.draw(White_Robot);
                }

            }
        }
        //############################################################################################
        // Drawing Bombs
         //if (bombs.size()>0)
    //{
        for (int io = 0; io < bombs.size(); io++)
        {
            if (bombs[io].bomb_placed)
                Level_1.draw(bombs[io].sprt);
            if (bombs[io].bomb_exploded)
            {
                //for(int h=0;h<=3;h++)
                for (int g = 0; g <= range_of_bomb && bombs[io].flag_range_right; g++)
                {

                    Level_1.draw(bombs[io].range_right[g]);

                    if ((Grid[bombs[io].x_index + g][bombs[io].y_index].getTexture() == &breakable))
                    {


                        destroy_breakable_walls(bombs[io].x_index + g, bombs[io].y_index, Grid, ground, ground2);

                        bombs[io].flag_range_right = 0;
                        break;


                    }
                    else if (Grid[bombs[io].x_index + g][bombs[io].y_index].getTexture() == &wall)
                    {

                        bombs[io].flag_range_right = 0;
                        break;
                    }
                }

                for (int g = 0; g <= range_of_bomb && bombs[io].flag_range_left; g++)
                {



                    Level_1.draw(bombs[io].range_left[g]);

                    if ((Grid[bombs[io].x_index - g][bombs[io].y_index].getTexture() == &breakable))
                    {


                        destroy_breakable_walls(bombs[io].x_index - g, bombs[io].y_index, Grid, ground, ground2);

                        bombs[io].flag_range_left = 0;
                        break;


                    }
                    else if (Grid[bombs[io].x_index - g][bombs[io].y_index].getTexture() == &wall)
                    {

                        bombs[io].flag_range_left = 0;
                        break;
                    }



                }

                for (int g = 0; g <= range_of_bomb && bombs[io].flag_range_up; g++)
                {

                    Level_1.draw(bombs[io].range_up[g]);

                    if ((Grid[bombs[io].x_index][bombs[io].y_index - g].getTexture() == &breakable))
                    {


                        destroy_breakable_walls(bombs[io].x_index, bombs[io].y_index - g, Grid, ground, ground2);

                        bombs[io].flag_range_up = 0;
                        break;


                    }
                    else if (Grid[bombs[io].x_index][bombs[io].y_index - g].getTexture() == &wall)
                    {

                        bombs[io].flag_range_up = 0;
                        break;
                    }


                }





                for (int g = 0; g <= range_of_bomb && bombs[io].flag_range_down; g++)
                {



                    Level_1.draw(bombs[io].range_down[g]);
                    if ((Grid[bombs[io].x_index][bombs[io].y_index + g].getTexture() == &breakable))
                    {


                        destroy_breakable_walls(bombs[io].x_index, bombs[io].y_index + g, Grid, ground, ground2);

                        bombs[io].flag_range_down = 0;
                        break;


                    }
                    else if (Grid[bombs[io].x_index][bombs[io].y_index + g].getTexture() == &wall)
                    {

                        bombs[io].flag_range_down = 0;
                        break;
                    }


                }

            }
        }
        //############################################################################################

        if (player_status.lives == 2) {

        }
        else if (player_status.lives == 1) {

        }
        else if (player_status.lives <= 0) { // player dead
            ingame.stop();
            Level_1.draw(RIP_Photo);
            death_flag = 1;
        }


        if ((GetXindx(player.getPosition().x) == GetXindx(White_Robot.getPosition().x) && GetYindx(player.getPosition().y) == GetYindx(White_Robot.getPosition().y))) {
            if (Clock_Damgae.getElapsedTime().asSeconds() >= 1) {
                --player_status.lives;
                Clock_Damgae.restart();
            }
            Level_1.draw(Hurt);

        }

        if (GetXindx(player.getPosition().x) == GetXindx(Yellow_Robot.getPosition().x) && GetYindx(player.getPosition().y) == GetYindx(Yellow_Robot.getPosition().y))
        {
            if (Clock_Damgae.getElapsedTime().asSeconds() >= 1) {
                --player_status.lives;
                Clock_Damgae.restart();
            }
            Level_1.draw(Hurt);
        }

        if (GetXindx(player.getPosition().x) == GetXindx(Skeleton.getPosition().x) && GetYindx(player.getPosition().y) == GetYindx(Skeleton.getPosition().y))
        {
            if (Clock_Damgae.getElapsedTime().asSeconds() >= 1) {
                --player_status.lives;
                Clock_Damgae.restart();
            }
            Level_1.draw(Hurt);
        }

        for (int i = 0; i < 2; i++) {
            Level_1.draw(timebombS[i]);
        }

        if (death_flag) {
            // player dead reactions
        }




        Level_1.draw(lifeS);
        Level_1.draw(rangeS);
        Level_1.draw(bombS);
        Level_1.display();


    }

}
void Advanced_Level()
{
    Music ingame; ingame.openFromFile("ingame.wav");
    ingame.play();
    //======================================================================//
                        // Making of Player //
    RectangleShape player(Vector2f(100, 120));
    Texture player_texture;
    Vector2u player_size;
    Clock player_clock;
    Time player_time;
    float player_position = 0;
    const int player_speed = 2;
    Generate_Charcter(player, player_texture, player_size, "mainplayer.png", 10, 2);
    //======================================================================//
    Texture healskill, bombskill, rangeskill;
    healskill.loadFromFile("Heal .png");
    bombskill.loadFromFile("bomb skill .png");
    rangeskill.loadFromFile("Range skill.png");
    Sprite healS2[3], bombskillS2[9], rangeskillS2[10];//superpowers level2


    //======================================================================//
                        // Player abilities //

    // Making of Grid
    Texture wall, ground, wallpaper, ground2, breakable, life, bomb, range, hurt, one, two, three, choice;
    if (!breakable.loadFromFile("breakable.png"))
    {
        cout << "error loading breakable wall pic";
    }
    if (!wallpaper.loadFromFile("wallpaper.jpg"))
    {
        cout << "error loading wallpaper pic";
    }
    if (!wall.loadFromFile("3d wall.png"))
    {
        cout << "error loading wall pic";
    }

    if (!ground.loadFromFile("ground 1.png"))
    {
        cout << "error loading ground pic";
    }
    if (!ground2.loadFromFile("grass.png"))
    {
        cout << "error loading grass pic";
    }

    if (!life.loadFromFile("flife.png"))
    {
        cout << "error loading life pic";
    }
    if (!range.loadFromFile("frange.png"))
    {

        cout << "error loading range pic";
    }
    if (!bomb.loadFromFile("fbomb.png"))
    {
        cout << "error loading bomb pic";
    }

    if (!hurt.loadFromFile("hurt.png"))
    {
        cout << "error loading  hurt pic";
    }
    if (!one.loadFromFile("one.png"))
    {

        cout << "error loading range pic";
    }
    if (!two.loadFromFile("two.png"))
    {

        cout << "error loading range pic";
    }
    if (!three.loadFromFile("three.png"))
    {

        cout << "error loading range pic";
    }


    life.setSmooth(1);
    bomb.setSmooth(1);
    hurt.setSmooth(1);
    range.setSmooth(1);
    // player stuff
    Clock Clock_Damgae;
    Sprite lifeS, bombS, rangeS, Hurt;
    lifeS.setTexture(life);
    lifeS.setPosition(0, 180);
    lifeS.setScale(0.3f, 0.3f);

    rangeS.setTexture(range);
    rangeS.setPosition(0, 250);
    rangeS.setScale(0.3f, 0.3f);

    bombS.setTexture(bomb);
    bombS.setPosition(0, 320);
    bombS.setScale(0.3f, 0.3f);

    Hurt.setTexture(hurt);

    //======================================================================//

    //======================================================================//
                     // Making of Yellow Robot //

    RectangleShape Yellow_Robot(Vector2f(100, 120));
    Texture Yellow_Robot_text;
    Vector2u Yellow_Robot_size;
    Clock Yellow_Robot_clock;
    Time Yellow_Robot_time;
    float Yellow_Robot_speed = 1;
    float Yellow_Robot_position = 0;
    int Yellow_Robot_Counter = 0;
    int Yellow_Robot_Rand_motion = rand() % 4 + 1;
    Generate_Charcter(Yellow_Robot, Yellow_Robot_text, Yellow_Robot_size, "yellow_robot.png", 10, 7);
    //======================================================================//


    //======================================================================//
                      // Making of White Robot //

    RectangleShape  White_Robot(Vector2f(100, 120));
    Texture  White_Robot_text;
    Vector2u  White_Robot_size;
    Clock  White_Robot_clock;
    Time  White_Robot_time;
    float White_Robot_speed = 1;
    float White_Robot_position = 0;
    int White_Robot_Counter = 0;
    int White_Robot_Rand_motion = rand() % 4 + 1;
    Generate_Charcter(White_Robot, White_Robot_text, White_Robot_size, "white_robot.png", 10, 2);
    //======================================================================//


    //======================================================================//
                // Making of  Blue Skeleton  //

    RectangleShape Blue_Skeleton(Vector2f(100, 120));
    Texture Blue_Skeleton_text;
    Vector2u Blue_Skeleton_size;
    Clock Blue_Skeleton_clock;
    Time Blue_Skeleton_time;
    float Blue_Skeleton_speed = 0.5;
    float Blue_Skeleton_position = 0;
    Generate_Charcter(Blue_Skeleton, Blue_Skeleton_text, Blue_Skeleton_size, "smart_skeleton.png", 3, 7);
    //======================================================================//



    //======================================================================//
                    // Making of White Skeleton //

    RectangleShape White_Skeleton(Vector2f(100, 120));
    Texture White_Skeleton_text;
    Vector2u White_Skeleton_text_size;
    Clock White_Skeleton_clock;
    Time White_Skeleton_time;
    float White_Skeleton_speed = 1;
    float  White_Skeleton_position = 0;
    int White_Skeleton_Counter = 0;
    int White_Skeleton_Rand_motion = rand() % 4 + 1;
    Generate_Charcter(White_Skeleton, White_Skeleton_text, White_Skeleton_text_size, "monster (5).png", 10, 2);
    //======================================================================//


    //###############################################################################
    // Movement stuff
    leftmovement left; rightmovement right; upmovement up; downmovement down;
    int Player_xindx = 0, Player_yindx = 0, White_Robot_xindx = 0, White_Robot_yindx = 0, Skeleton_xindx = 0, Skeleton_yindx = 0, Robot_xindx = 0, Robot_yindx = 0;
    //###############################################################################




                       // Making of Grid //
    //======================================================================//
                       // MAP DEFINATION //

    Sprite Wallpaper;
    Wallpaper.setTexture(wallpaper);
    //======================================================================//

    //======================================================================//
          // Distribution of wall ,breakable and ground on the Grid //


    Sprite Grid[width + 1][length + 1];

    for (int i = 1; i <= width; i++)      //  Distribution of wall and ground
    {
        for (int j = 1; j <= length; j++)
        {
            if (i % 2 != 0 && j % 2 != 0)
            {

                Grid[i][j].setTexture(wall);
                Grid[i][j].setPosition((i + 1.97)*53.15, (j + 0.255) * 48);
                Grid[i][j].setScale(Vector2f(0.1009, 0.165));

            }

            else if (i == 1 || i == width)
            {
                Grid[i][j].setTexture(wall);
                Grid[i][j].setPosition((i + 1.97)*53.15, (j + 0.255) * 48);
                Grid[i][j].setScale(Vector2f(0.1009, 0.165));
            }
            else if (j == 1 || j == length)
            {
                Grid[i][j].setTexture(wall);
                Grid[i][j].setPosition((i + 1.97)*53.15, (j + 0.255) * 48);
                Grid[i][j].setScale(Vector2f(0.1009, 0.165));
            }
            else
            {
                if (i % 2 == j % 2) { Grid[i][j].setTexture(ground); }
                else { Grid[i][j].setTexture(ground2); }
                Grid[i][j].setPosition((i + 2) * 53, (j + 0.8) * 48);
                Grid[i][j].setScale(0.1, 0.101);
            }
        }
    }

    for (int i = 1; i <= 40; i++)       //  Distribution of breakable
    {
        int x = rand() % 16 + 2, y = rand() % 9 + 2;
        if (x % 2 != 0 && y % 2 != 0)
        {
            x++;
        }
        Grid[x][y].setTexture(breakable);
        Grid[x][y].setPosition((x + 1.97)*53.15, (y + 0.255) * 48);
        Grid[x][y].setScale(Vector2f(0.1009, 0.165));
    }



    int l = 9;
    for (int i = 0; i < l; i++)
    {

        int x = rand() % 16 + 2, y = rand() % 8 + 2;
        if (Grid[x][y].getTexture() != &breakable || x % 2 != 0 || y % 2 == 0)
        {

            l++;
            continue;

        }

        rangeskillS2[l - i].setTexture(rangeskill);
        rangeskillS2[l - i].setScale(0.5, 0.3);
        rangeskillS2[l - i].setPosition((x + 2.065)*53.15, (y + 0.43)*50.5);
    }
    int f = 8;
    for (int i = 0; i < f; i++)
    {

        int x = rand() % 16 + 2, y = rand() % 8 + 2;
        if (Grid[x][y].getTexture() != &breakable || x % 2 != 0 || y % 2 == 0)
        {

            f++;
            continue;

        }

        bombskillS2[f - i].setTexture(bombskill);
        bombskillS2[f - i].setScale(0.5, 0.3);
        bombskillS2[f - i].setPosition((x + 2.065)*53.15, (y + 0.43)*50.5);

    }

    int h = 2;
    for (int i = 0; i < h; i++)
    {

        int x = rand() % 16 + 2, y = rand() % 8 + 2;
        if (Grid[x][y].getTexture() != &breakable || x % 2 != 0 || y % 2 == 0)
        {

            h++;
            continue;

        }

        healS2[h - i].setTexture(healskill);
        healS2[h - i].setScale(0.5, 0.3);
        healS2[h - i].setPosition((x + 2.065)*53.15, (y + 0.43)*50.5);

    }

    Texture Timer_Bomb;
    if (!Timer_Bomb.loadFromFile("time-bomb.png"))
    {
        cout << "fuckssssss" << endl;
    }
    Sprite TIMER_BOMB;
    TIMER_BOMB.setTexture(Timer_Bomb);
    TIMER_BOMB.setPosition(GetXpostion(2), GetYpostion(2));
    TIMER_BOMB.setScale(0.05, 0.05);
    //=======================================================================================//

    //=======================================================================================//

    RenderWindow window(VideoMode(1280, 768), "Advanced Level");

    while (window.isOpen())
    {
        //=======================================================================================//
                            // Random Movment of Yellow Robot //
        if (Yellow_Robot_Counter >= 5000)
        {
            Yellow_Robot_Rand_motion = rand() % 4 + 1;
            Yellow_Robot_Counter = 0;
        }

        if (Yellow_Robot_Rand_motion == 1)                                          // Moving UP => Rand_motion == 1
        {
            Yellow_Robot_Counter++;
            if (Grid[GetXindx(Yellow_Robot.getPosition().x)][GetYindx(Yellow_Robot.getPosition().y - 7)].getTexture() == &ground || Grid[GetXindx(Yellow_Robot.getPosition().x)][GetYindx(Yellow_Robot.getPosition().y - 7)].getTexture() == &ground2)
            {
                Movement_Upward(Yellow_Robot, Yellow_Robot_time, Yellow_Robot_clock, Yellow_Robot_position, Yellow_Robot_size, Yellow_Robot_speed);
            }
            else
            {
                Yellow_Robot_Counter = 5000;
            }

        }
        else if (Yellow_Robot_Rand_motion == 2)                                 // Moving Down => Rand_motion == 2
        {
            Yellow_Robot_Counter++;
            if (Grid[GetXindx(Yellow_Robot.getPosition().x)][GetYindx(Yellow_Robot.getPosition().y + 7)].getTexture() == &ground || Grid[GetXindx(Yellow_Robot.getPosition().x)][GetYindx(Yellow_Robot.getPosition().y + 7)].getTexture() == &ground2)
            {
                Movement_Downward(Yellow_Robot, Yellow_Robot_time, Yellow_Robot_clock, Yellow_Robot_position, Yellow_Robot_size, Yellow_Robot_speed);
            }

            else
            {
                Yellow_Robot_Counter = 5000;
            }
        }


        else if (Yellow_Robot_Rand_motion == 3)                                 // Moving Right => Rand_motion == 3
        {
            Yellow_Robot_Counter++;
            if (Grid[GetXindx(Yellow_Robot.getPosition().x + 12)][GetYindx(Yellow_Robot.getPosition().y)].getTexture() == &ground || Grid[GetXindx(Yellow_Robot.getPosition().x + 12)][GetYindx(Yellow_Robot.getPosition().y)].getTexture() == &ground2)
            {
                Movement_Right(Yellow_Robot, Yellow_Robot_time, Yellow_Robot_clock, Yellow_Robot_position, Yellow_Robot_size, Yellow_Robot_speed);
            }
            else
            {
                Yellow_Robot_Counter = 5000;
            }
        }


        else if (Yellow_Robot_Rand_motion == 4)                                 // Moving Left => Rand_motion == 4
        {
            Yellow_Robot_Counter++;
            if (Grid[GetXindx(Yellow_Robot.getPosition().x - 12)][GetYindx(Yellow_Robot.getPosition().y)].getTexture() == &ground || Grid[GetXindx(Yellow_Robot.getPosition().x - 12)][GetYindx(Yellow_Robot.getPosition().y)].getTexture() == &ground2)
            {
                Movement_Left(Yellow_Robot, Yellow_Robot_time, Yellow_Robot_clock, Yellow_Robot_position, Yellow_Robot_size, Yellow_Robot_speed);
            }
            else
            {
                Yellow_Robot_Counter = 5000;
            }

        }
        //=======================================================================================//

        //=======================================================================================//
                                // Random Movment of White Robot //
        if (White_Robot_Counter >= 5000)
        {
            White_Robot_Rand_motion = rand() % 4 + 1;
            White_Robot_Counter = 0;
        }

        if (White_Robot_Rand_motion == 1)                                           // Moving UP => Rand_motion == 1
        {
            White_Robot_Counter++;
            if (Grid[GetXindx(White_Robot.getPosition().x)][GetYindx(White_Robot.getPosition().y - 7)].getTexture() == &ground || Grid[GetXindx(White_Robot.getPosition().x)][GetYindx(White_Robot.getPosition().y - 7)].getTexture() == &ground2)
            {
                Movement_Upward(White_Robot, White_Robot_time, White_Robot_clock, White_Robot_position, White_Robot_size, White_Robot_speed);
            }
            else
            {
                White_Robot_Counter = 5000;
            }

        }
        else if (White_Robot_Rand_motion == 2)                                  // Moving Down => Rand_motion == 2
        {
            White_Robot_Counter++;
            if (Grid[GetXindx(White_Robot.getPosition().x)][GetYindx(White_Robot.getPosition().y + 7)].getTexture() == &ground || Grid[GetXindx(White_Robot.getPosition().x)][GetYindx(White_Robot.getPosition().y + 7)].getTexture() == &ground2)
            {
                Movement_Downward(White_Robot, White_Robot_time, White_Robot_clock, White_Robot_position, White_Robot_size, White_Robot_speed);
            }

            else
            {
                White_Robot_Counter = 5000;
            }
        }


        else if (White_Robot_Rand_motion == 3)                                  // Moving Right => Rand_motion == 3
        {
            White_Robot_Counter++;
            if (Grid[GetXindx(White_Robot.getPosition().x + 12)][GetYindx(White_Robot.getPosition().y)].getTexture() == &ground || Grid[GetXindx(White_Robot.getPosition().x + 12)][GetYindx(White_Robot.getPosition().y)].getTexture() == &ground2)
            {
                Movement_Right(White_Robot, White_Robot_time, White_Robot_clock, White_Robot_position, White_Robot_size, White_Robot_speed);
            }
            else
            {
                White_Robot_Counter = 5000;
            }
        }


        else if (White_Robot_Rand_motion == 4)                                  // Moving Left => Rand_motion == 4
        {
            White_Robot_Counter++;
            if (Grid[GetXindx(White_Robot.getPosition().x - 12)][GetYindx(White_Robot.getPosition().y)].getTexture() == &ground || Grid[GetXindx(White_Robot.getPosition().x - 12)][GetYindx(White_Robot.getPosition().y)].getTexture() == &ground2)
            {
                Movement_Left(White_Robot, White_Robot_time, White_Robot_clock, White_Robot_position, White_Robot_size, White_Robot_speed);
            }
            else
            {
                White_Robot_Counter = 5000;
            }

        }
        //=======================================================================================//


        //=======================================================================================//
                            // Random Movment of White Skeleton //
        if (White_Skeleton_Counter >= 5000)
        {
            White_Skeleton_Rand_motion = rand() % 4 + 1;
            White_Skeleton_Counter = 0;
        }

        if (White_Skeleton_Rand_motion == 1)                                            // Moving UP => Rand_motion == 1
        {
            White_Skeleton_Counter++;
            if (Grid[GetXindx(White_Skeleton.getPosition().x)][GetYindx(White_Skeleton.getPosition().y - 7)].getTexture() == &ground || Grid[GetXindx(White_Skeleton.getPosition().x)][GetYindx(White_Skeleton.getPosition().y - 7)].getTexture() == &ground2)
            {
                Movement_Upward(White_Skeleton, White_Skeleton_time, White_Skeleton_clock, White_Skeleton_position, White_Skeleton_text_size, White_Skeleton_speed);
            }
            else
            {
                White_Skeleton_Counter = 5000;
            }

        }
        else if (White_Skeleton_Rand_motion == 2)                                   // Moving Down => Rand_motion == 2
        {
            White_Skeleton_Counter++;
            if (Grid[GetXindx(White_Skeleton.getPosition().x)][GetYindx(White_Skeleton.getPosition().y + 7)].getTexture() == &ground || Grid[GetXindx(White_Skeleton.getPosition().x)][GetYindx(White_Skeleton.getPosition().y + 7)].getTexture() == &ground2)
            {
                Movement_Downward(White_Skeleton, White_Skeleton_time, White_Skeleton_clock, White_Skeleton_position, White_Skeleton_text_size, White_Skeleton_speed);
            }

            else
            {
                White_Skeleton_Counter = 5000;
            }
        }


        else if (White_Skeleton_Rand_motion == 3)                                   // Moving Right => Rand_motion == 3
        {
            White_Skeleton_Counter++;
            if (Grid[GetXindx(White_Skeleton.getPosition().x + 12)][GetYindx(White_Skeleton.getPosition().y)].getTexture() == &ground || Grid[GetXindx(White_Skeleton.getPosition().x + 12)][GetYindx(White_Skeleton.getPosition().y)].getTexture() == &ground2)
            {
                Movement_Right(White_Skeleton, White_Skeleton_time, White_Skeleton_clock, White_Skeleton_position, White_Skeleton_text_size, White_Skeleton_speed);
            }
            else
            {
                White_Skeleton_Counter = 5000;
            }
        }


        else if (White_Skeleton_Rand_motion == 4)                                   // Moving Left => Rand_motion == 4
        {
            White_Skeleton_Counter++;
            if (Grid[GetXindx(White_Skeleton.getPosition().x - 12)][GetYindx(White_Skeleton.getPosition().y)].getTexture() == &ground || Grid[GetXindx(White_Skeleton.getPosition().x - 12)][GetYindx(White_Skeleton.getPosition().y)].getTexture() == &ground2)
            {
                Movement_Left(White_Skeleton, White_Skeleton_time, White_Skeleton_clock, White_Skeleton_position, White_Skeleton_text_size, White_Skeleton_speed);
            }
            else
            {
                White_Skeleton_Counter = 5000;
            }

        }
        //=======================================================================================//


        //=======================================================================================//
                            // BFS Movement of Blue Skeleton

        BFS(GetXindx(player.getPosition().x), GetYindx(player.getPosition().y), GetXindx(Blue_Skeleton.getPosition().x), GetYindx(Blue_Skeleton.getPosition().y), Grid, ground, ground2);
        if (Smart_Skeleton_Movement.i == GetXindx(Blue_Skeleton.getPosition().x) && Smart_Skeleton_Movement.j - GetYindx(Blue_Skeleton.getPosition().y) == 1)
        {
            Movement_Downward(Blue_Skeleton, Blue_Skeleton_time, Blue_Skeleton_clock, Blue_Skeleton_position, Blue_Skeleton_size, Blue_Skeleton_speed); // Moving Downward
        }
        else if (Smart_Skeleton_Movement.i == GetXindx(Blue_Skeleton.getPosition().x) && Smart_Skeleton_Movement.j - GetYindx(Blue_Skeleton.getPosition().y) == -1)
        {
            Movement_Upward(Blue_Skeleton, Blue_Skeleton_time, Blue_Skeleton_clock, Blue_Skeleton_position, Blue_Skeleton_size, Blue_Skeleton_speed);       // Moving Upward
        }
        else if (Smart_Skeleton_Movement.i - GetXindx(Blue_Skeleton.getPosition().x) == 1 && Smart_Skeleton_Movement.j == GetYindx(Blue_Skeleton.getPosition().y))
        {
            Movement_Right(Blue_Skeleton, Blue_Skeleton_time, Blue_Skeleton_clock, Blue_Skeleton_position, Blue_Skeleton_size, Blue_Skeleton_speed);        // Moving Right
        }
        else if (Smart_Skeleton_Movement.i - GetXindx(Blue_Skeleton.getPosition().x) == -1 && Smart_Skeleton_Movement.j == GetYindx(Blue_Skeleton.getPosition().y))
        {
            Movement_Left(Blue_Skeleton, Blue_Skeleton_time, Blue_Skeleton_clock, Blue_Skeleton_position, Blue_Skeleton_size, Blue_Skeleton_speed);     // Moving Left
        }

        //=======================================================================================//

        //=======================================================================================//
        // Player Movement
        Player_xindx = (float)((float)(player.getPosition().x - 183) / 53 + 2);
        Player_yindx = (float)((float)(player.getPosition().y - 74) / 48 + 2);
        right.i = GetXindx(player.getPosition().x + 20); right.j = Player_yindx;
        left.i = GetXindx(player.getPosition().x - 20); left.j = Player_yindx;
        up.i = Player_xindx; up.j = GetYindx(player.getPosition().y - 7);
        down.i = Player_xindx; down.j = GetYindx(player.getPosition().y + 7);

        if (Keyboard::isKeyPressed(Keyboard::Key::Right) && (Grid[right.i][right.j].getTexture() == &ground || Grid[right.i][right.j].getTexture() == &ground2))      // Moving Right
        {
            Movement_Right(player, player_time, player_clock, player_position, player_size, player_speed);
        }
        else if (Keyboard::isKeyPressed(Keyboard::Key::Left) && (Grid[left.i][left.j].getTexture() == &ground || Grid[left.i][left.j].getTexture() == &ground2))         // Moving Left
        {
            Movement_Left(player, player_time, player_clock, player_position, player_size, player_speed);
        }
        else if (Keyboard::isKeyPressed(Keyboard::Key::Up) && (Grid[up.i][up.j].getTexture() == &ground || Grid[up.i][up.j].getTexture() == &ground2))           // Moving Up
        {
            Movement_Upward(player, player_time, player_clock, player_position, player_size, player_speed);
        }
        else if (Keyboard::isKeyPressed(Keyboard::Key::Down) && (Grid[down.i][down.j].getTexture() == &ground || Grid[down.i][down.j].getTexture() == &ground2))         // Moving Down
        {
            Movement_Downward(player, player_time, player_clock, player_position, player_size, player_speed);
        }

        //=======================================================================================//


        //=======================================================================================//
        Event event;
        while (window.pollEvent(event))
        {
            if (event.type == sf::Event::Closed || Keyboard::isKeyPressed(Keyboard::Enter))
                window.close();
        }
        window.clear();
        // Drawing of the Wallpaper
        window.draw(Wallpaper);

        // Drawing of The Map //

    // super with player
        for (int i = 0; i < 10; i++) {
            int sumP = 0; int sumR = 0;
            sumP = GetXindx(player.getPosition().x) + GetYindx(player.getPosition().y);

            sumR = GetXindx(rangeskillS2[i].getPosition().x) + GetYindx(rangeskillS2[i].getPosition().y);

            if (sumR == sumP + 1 && (GetXindx(rangeskillS2[i].getPosition().x) == GetXindx(player.getPosition().x))) {

                rangeskillS2[i].setColor(Color::Transparent);


            }
        }
        for (int i = 0; i < 9; i++) {
            int sumP = 0; int sumB = 0;
            sumP = GetXindx(player.getPosition().x) + GetYindx(player.getPosition().y);

            sumB = GetXindx(bombskillS2[i].getPosition().x) + GetYindx(bombskillS2[i].getPosition().y);
            //cout << GetXindx(player.getPosition().x) << "\t" << GetYindx(player.getPosition().y) << endl;
            //cout << GetXindx(healS[i].getPosition().x) << "\t" << GetYindx(healS[i].getPosition().y) << endl;

            if (sumB == sumP + 1 && (GetXindx(bombskillS2[i].getPosition().x) == GetXindx(player.getPosition().x))) {
                bombskillS2[i].setColor(Color::Transparent);



            }
        }

        for (int i = 0; i < 3; i++) {
            int sumP = 0; int sumH = 0;
            sumP = GetXindx(player.getPosition().x) + GetYindx(player.getPosition().y);

            sumH = GetXindx(healS2[i].getPosition().x) + GetYindx(healS2[i].getPosition().y);

            if (sumH == sumP + 1 && (GetXindx(healS2[i].getPosition().x) == GetXindx(player.getPosition().x))) {

                healS2[i].setColor(Color::Transparent);

            }
        }
//=======================================================================================//
                        // Drawing of The Ground //

        for (int i = 2; i < width; i++)
        {
            for (int j = 2; j < length; j++)
            {
                if (Grid[i][j].getTexture() == &ground || Grid[i][j].getTexture() == &ground2)
                {
                    window.draw(Grid[i][j]);
                }
            }

        }

        //=======================================================================================//

        //=======================================================================================//
                                    // Drawing of Wall and Breakable //
        for (int j = 1; j <= length; j++)
        {
            for (int i = 1; i <= width; i++)
            {
                if (Grid[i][j].getTexture() == &ground || Grid[i][j].getTexture() == &ground2)
                {
                    continue;
                }

                window.draw(Grid[i][j]);

                if (GetYindx(player.getPosition().y) >= j)              // Drawing of Player //
                {
                    window.draw(player);
                }
                if (GetYindx(White_Robot.getPosition().y) >= j)         // Drawing of White_Robot //
                {
                    window.draw(White_Robot);
                }
                if (GetYindx(Yellow_Robot.getPosition().y) >= j)        // Drawing of Yellow_Robot //
                {
                    window.draw(Yellow_Robot);
                }
                if (GetYindx(White_Skeleton.getPosition().y) >= j)      // Drawing of White_Skeleton //
                {
                    window.draw(White_Skeleton);
                }
                if (GetYindx(Blue_Skeleton.getPosition().y) >= j)       // Drawing of Blue_Skeleton //
                {
                    window.draw(Blue_Skeleton);
                }
            }
        }
        //=======================================================================================//
        for (int i = 0; i < 10; i++) {
            window.draw(rangeskillS2[i]);
        }
        for (int i = 0; i < 9; i++) {
            window.draw(bombskillS2[i]);
        }
        for (int i = 0; i < 3; i++) {
            window.draw(healS2[i]);
        }

        // player damage
        if (GetXindx(player.getPosition().x) == GetXindx(White_Robot.getPosition().x) && GetYindx(player.getPosition().y) == GetYindx(White_Robot.getPosition().y))
        {
            if (Clock_Damgae.getElapsedTime().asSeconds() >= 1) {
                --player_status.lives;
                Clock_Damgae.restart();
            }
            window.draw(Hurt);

        }

        if (GetXindx(player.getPosition().x) == GetXindx(White_Robot.getPosition().x) && GetYindx(player.getPosition().y) == GetYindx(White_Robot.getPosition().y))
        {
            if (Clock_Damgae.getElapsedTime().asSeconds() >= 1) {
                --player_status.lives;
                Clock_Damgae.restart();
            }
            window.draw(Hurt);
        }

        if (GetXindx(player.getPosition().x) == GetXindx(Blue_Skeleton.getPosition().x) && GetYindx(player.getPosition().y) == GetYindx(Blue_Skeleton.getPosition().y))
        {
            if (Clock_Damgae.getElapsedTime().asSeconds() >= 1) {
                --player_status.lives;
                Clock_Damgae.restart();
            }
            window.draw(Hurt);
        }

        if (GetXindx(player.getPosition().x) == GetXindx(Yellow_Robot.getPosition().x) && GetYindx(player.getPosition().y) == GetYindx(Yellow_Robot.getPosition().y))
        {
            if (Clock_Damgae.getElapsedTime().asSeconds() >= 1) {
                --player_status.lives;
                Clock_Damgae.restart();
            }
            window.draw(Hurt);
        }

        cout << player_status.lives << endl;
        window.draw(TIMER_BOMB);
        window.draw(lifeS);
        window.draw(rangeS);
        window.draw(bombS);
        window.display();
    }
}
void Legendary_Mode() {

    Music ingame; ingame.openFromFile("ingame.wav");
    ingame.play();
    //###############################################################################
    // Making of Player
    RectangleShape player(Vector2f(100, 120));
    Texture player_texture;
    Vector2u player_size;
    Clock player_clock;
    Time player_time;
    float player_position = 0;
    const int player_speed = 2;
    Generate_Charcter(player, player_texture, player_size, "mainplayer.png", 10, 2);
    //###############################################################################

    //###############################################################################
    // Making of Red_Monster(Smart)
    RectangleShape Red_Robot(Vector2f(100, 120));
    Texture Red_Robot_texture;
    Vector2u Red_Robot_size;
    Clock Red_Robot_clock;
    Time Red_Robot_time;
    float Red_Robot_position = 0;
    float Red_Robot_Speed = 0.6;
    Generate_Charcter(Red_Robot, Red_Robot_texture, Red_Robot_size, "red_robot.png", 10, 2);
    //###############################################################################

    //###############################################################################
    // Making of Blue_Skeleton(smart)
    RectangleShape Blue_Skeleton(Vector2f(100, 120));
    Texture Blue_Skeleton_text;
    Vector2u Blue_Skeleton_text_size;
    Clock Blue_Skeleton_clock;
    Time Blue_Skeleton_time;
    float Blue_Skeleton_speed = 0.3;
    float Blue_Skeleton_position = 0;
    Generate_Charcter(Blue_Skeleton, Blue_Skeleton_text, Blue_Skeleton_text_size, "smart_skeleton.png", 10, 2);
    //###############################################################################

    //###############################################################################
    // Making of Skeleton
    RectangleShape Skeleton(Vector2f(100, 120));
    Texture Skeleton_texture;
    Vector2u Skeleton_size;
    Clock Skeleton_clock;
    Time Skeleton_time;
    int Skeleton_Rand_motion = rand() % 4 + 1;
    int Skeleton_counter = 0;
    float Skeleton_position = 0;
    Generate_Charcter(Skeleton, Skeleton_texture, Skeleton_size, "monster (5).png", 7, 8);
    //###############################################################################

    //###############################################################################
    // Making of White_Robot
    RectangleShape White_Robot(Vector2f(100, 120));
    Texture White_Robot_texture;
    Vector2u White_Robot_size;
    Clock White_Robot_clock;
    Time White_Robot_time;
    int White_Robot_Rand_motion = rand() % 4 + 1;
    int White_Robot_counter = 0;
    float White_Robot_position = 0;
    Generate_Charcter(White_Robot, White_Robot_texture, White_Robot_size, "white_robot.png", 14, 8);
    //###############################################################################

    //###############################################################################
    // Movement stuff
    leftmovement left; rightmovement right; upmovement up; downmovement down;
    int Player_xindx = 0, Player_yindx = 0, White_Robot_xindx = 0, White_Robot_yindx = 0, Skeleton_xindx = 0, Skeleton_yindx = 0, Blue_Skeleton_xindx = 0, Blue_Skeleton_yindx = 0, Red_Robot_xindx = 0, Red_Robot_yindx = 0;
    //###############################################################################

 // Making of Grid
    Texture wall, ground, wallpaper, ground2, breakable, life, bomb, range, hurt, one, two, three, choice;
    if (!breakable.loadFromFile("breakable.png"))
    {
        cout << "error loading breakable wall pic";
    }
    if (!wallpaper.loadFromFile("wallpaper.jpg"))
    {
        cout << "error loading wallpaper pic";
    }
    if (!wall.loadFromFile("3d wall.png"))
    {
        cout << "error loading wall pic";
    }

    if (!ground.loadFromFile("ground 1.png"))
    {
        cout << "error loading ground pic";
    }
    if (!ground2.loadFromFile("grass.png"))
    {
        cout << "error loading grass pic";
    }

    if (!life.loadFromFile("flife.png"))
    {
        cout << "error loading life pic";
    }
    if (!range.loadFromFile("frange.png"))
    {

        cout << "error loading range pic";
    }
    if (!bomb.loadFromFile("fbomb.png"))
    {
        cout << "error loading bomb pic";
    }

    if (!hurt.loadFromFile("hurt.png"))
    {
        cout << "error loading  hurt pic";
    }
    if (!one.loadFromFile("one.png"))
    {

        cout << "error loading range pic";
    }
    if (!two.loadFromFile("two.png"))
    {

        cout << "error loading range pic";
    }
    if (!three.loadFromFile("three.png"))
    {

        cout << "error loading range pic";
    }

    Texture timebomb;
    timebomb.loadFromFile("time-bomb.png");
    Sprite timebombS[2];


    life.setSmooth(1);
    bomb.setSmooth(1);
    hurt.setSmooth(1);
    range.setSmooth(1);


    //###############################################################################
    // Player abilities
    Sprite lifeS, bombS, rangeS, Hurt, Wallpaper;
    lifeS.setTexture(life);
    lifeS.setPosition(0, 180);
    lifeS.setScale(0.4, 0.4);

    rangeS.setTexture(range);
    rangeS.setPosition(0, 250);
    rangeS.setScale(0.4, 0.4);

    bombS.setTexture(bomb);
    bombS.setPosition(0, 330);
    bombS.setScale(0.4, 0.4);

    Hurt.setTexture(hurt);
    Wallpaper.setTexture(wallpaper);
    // Numbers
    Clock Clock_Damgae;
    //###############################################################################


    // Distribution of wall & ground on the Grid

    Sprite Grid[width + 1][length + 1];

    for (int i = 1; i <= width; i++)
    {
        for (int j = 1; j <= length; j++)
        {
            if (i % 2 != 0 && j % 2 != 0)
            {

                Grid[i][j].setTexture(wall);
                Grid[i][j].setPosition((i + 1.97)*53.15, (j + 0.255) * 48);
                Grid[i][j].setScale(Vector2f(0.1009, 0.165));

            }

            else if (i == 1 || i == width)
            {
                Grid[i][j].setTexture(wall);
                Grid[i][j].setPosition((i + 1.97)*53.15, (j + 0.255) * 48);
                Grid[i][j].setScale(Vector2f(0.1009, 0.165));
            }
            else if (j == 1 || j == length)
            {
                Grid[i][j].setTexture(wall);
                Grid[i][j].setPosition((i + 1.97)*53.15, (j + 0.255) * 48);
                Grid[i][j].setScale(Vector2f(0.1009, 0.165));
            }
            else
            {
                if (i % 2 == j % 2) { Grid[i][j].setTexture(ground); }
                else { Grid[i][j].setTexture(ground2); }
                Grid[i][j].setPosition((i + 2) * 53, (j + 0.8) * 48);
                Grid[i][j].setScale(0.1, 0.101);
            }
        }
    }



    for (int i = 1; i <= 30; i++)
    {
        int x = rand() % 15 + 2, y = rand() % 9 + 2;
        if (x % 2 != 0 && y % 2 != 0)
        {
            x++;
        }
        Grid[x][y].setTexture(breakable);
        Grid[x][y].setPosition((x + 1.97)*53.15, (y + 0.255) * 48);
        Grid[x][y].setScale(Vector2f(0.1009, 0.165));
    }

    int z = 1;
    for (int i = 0; i < z; i++)
    {

        int x = rand() % 16 + 2, y = rand() % 8 + 2;
        if (Grid[x][y].getTexture() != &breakable || x % 2 != 0 || y % 2 == 0)
        {

            z++;
            continue;

        }

        timebombS[z - i].setTexture(timebomb);
        timebombS[z - i].setScale(0.05, 0.05);
        //  timebombS[z - i].setPosition((x + 2.065)*53.15, (y + 0.43)*50.5);
        timebombS[z - i].setPosition(GetXpostion(2), GetYpostion(2));

    }
    //###############################################################################
    // Game Window
    RenderWindow Level_3(VideoMode(1280, 768), "Fuck");
    while (Level_3.isOpen())
    {

        // Player Movement
        Player_xindx = (float)((float)(player.getPosition().x - 183) / 53 + 2);
        Player_yindx = (float)((float)(player.getPosition().y - 74) / 48 + 2);
        right.i = GetXindx(player.getPosition().x + 20); right.j = Player_yindx;
        left.i = GetXindx(player.getPosition().x - 20); left.j = Player_yindx;
        up.i = Player_xindx; up.j = GetYindx(player.getPosition().y - 7);
        down.i = Player_xindx; down.j = GetYindx(player.getPosition().y + 7);

        if (Keyboard::isKeyPressed(Keyboard::Key::Right) && (Grid[right.i][right.j].getTexture() == &ground || Grid[right.i][right.j].getTexture() == &ground2))      // Moving Right
        {
            Movement_Right(player, player_time, player_clock, player_position, player_size, player_speed);
        }
        else if (Keyboard::isKeyPressed(Keyboard::Key::Left) && (Grid[left.i][left.j].getTexture() == &ground || Grid[left.i][left.j].getTexture() == &ground2))         // Moving Left
        {
            Movement_Left(player, player_time, player_clock, player_position, player_size, player_speed);
        }
        else if (Keyboard::isKeyPressed(Keyboard::Key::Up) && (Grid[up.i][up.j].getTexture() == &ground || Grid[up.i][up.j].getTexture() == &ground2))           // Moving Up
        {
            Movement_Upward(player, player_time, player_clock, player_position, player_size, player_speed);
        }
        else if (Keyboard::isKeyPressed(Keyboard::Key::Down) && (Grid[down.i][down.j].getTexture() == &ground || Grid[down.i][down.j].getTexture() == &ground2))         // Moving Down
        {
            Movement_Downward(player, player_time, player_clock, player_position, player_size, player_speed);
        }

        //######################################################################################################



        //######################################################################################################
        // Smart_Skeleton movement
        Blue_Skeleton_xindx = (float)((float)(Blue_Skeleton.getPosition().x - 183) / 53 + 2);
        Blue_Skeleton_yindx = (float)((float)(Blue_Skeleton.getPosition().y - 74) / 48 + 2);
        right.i = GetXindx(Blue_Skeleton.getPosition().x + 20); right.j = Blue_Skeleton_yindx;
        left.i = GetXindx(Blue_Skeleton.getPosition().x - 20); left.j = Blue_Skeleton_yindx;
        up.i = Blue_Skeleton_xindx; up.j = GetYindx(Blue_Skeleton.getPosition().y - 7);
        down.i = Blue_Skeleton_xindx; down.j = GetYindx(Blue_Skeleton.getPosition().y + 7);

        // Call BFS
        BFS(Player_xindx, Player_yindx, Blue_Skeleton_xindx, Blue_Skeleton_yindx, Grid, ground, ground2);

        // Movement
        if (Smart_Skeleton_Movement.i == Blue_Skeleton_xindx && Smart_Skeleton_Movement.j - Blue_Skeleton_yindx == 1) {
            Movement_Downward(Blue_Skeleton, Blue_Skeleton_time, Blue_Skeleton_clock, Blue_Skeleton_position, Blue_Skeleton_text_size, Blue_Skeleton_speed);    // Moving Downward
        }
        else if (Smart_Skeleton_Movement.i == Blue_Skeleton_xindx && Smart_Skeleton_Movement.j - Blue_Skeleton_yindx == -1) {
            Movement_Upward(Blue_Skeleton, Blue_Skeleton_time, Blue_Skeleton_clock, Blue_Skeleton_position, Blue_Skeleton_text_size, Blue_Skeleton_speed);      // Moving Upward
        }
        else if (Smart_Skeleton_Movement.i - Blue_Skeleton_xindx == 1 && Smart_Skeleton_Movement.j == Blue_Skeleton_yindx) {
            Movement_Right(Blue_Skeleton, Blue_Skeleton_time, Blue_Skeleton_clock, Blue_Skeleton_position, Blue_Skeleton_text_size, Blue_Skeleton_speed);       // Moving Right
        }
        else if (Smart_Skeleton_Movement.i - Blue_Skeleton_xindx == -1 && Smart_Skeleton_Movement.j == Blue_Skeleton_yindx) {
            Movement_Left(Blue_Skeleton, Blue_Skeleton_time, Blue_Skeleton_clock, Blue_Skeleton_position, Blue_Skeleton_text_size, Blue_Skeleton_speed);        // Moving Left
        }

        //######################################################################################################


        //######################################################################################################
        // Red_Robot movement
        Red_Robot_xindx = (float)((float)(Red_Robot.getPosition().x - 183) / 53 + 2);
        Red_Robot_yindx = (float)((float)(Red_Robot.getPosition().y - 74) / 48 + 2);
        right.i = GetXindx(Red_Robot.getPosition().x + 20); right.j = Red_Robot_yindx;
        left.i = GetXindx(Red_Robot.getPosition().x - 20); left.j = Red_Robot_yindx;
        up.i = Red_Robot_xindx; up.j = GetYindx(Red_Robot.getPosition().y - 7);
        down.i = Red_Robot_xindx; down.j = GetYindx(Red_Robot.getPosition().y + 7);

        // Call BFS
        BFS(Player_xindx, Player_yindx, Red_Robot_xindx, Red_Robot_yindx, Grid, ground, ground2);

        // Movement
        if (Red_Robot_Movement.i == Red_Robot_xindx && Red_Robot_Movement.j - Red_Robot_yindx == 1) {
            Movement_Downward(Red_Robot, Red_Robot_time, Red_Robot_clock, Red_Robot_position, Red_Robot_size, Red_Robot_Speed); // Moving Downward
        }
        else if (Red_Robot_Movement.i == Red_Robot_xindx && Red_Robot_Movement.j - Red_Robot_yindx == -1) {
            Movement_Upward(Red_Robot, Red_Robot_time, Red_Robot_clock, Red_Robot_position, Red_Robot_size, Red_Robot_Speed);   // Moving Upward
        }
        else if (Red_Robot_Movement.i - Red_Robot_xindx == 1 && Red_Robot_Movement.j == Red_Robot_yindx) {
            Movement_Right(Red_Robot, Red_Robot_time, Red_Robot_clock, Red_Robot_position, Red_Robot_size, Red_Robot_Speed);    // Movement Right
        }
        else if (Red_Robot_Movement.i - Red_Robot_xindx == -1 && Red_Robot_Movement.j == Red_Robot_yindx) {
            Movement_Left(Red_Robot, Red_Robot_time, Red_Robot_clock, Red_Robot_position, Red_Robot_size, Red_Robot_Speed); // Moving left
        }

        //######################################################################################################




        // Skeleton movement
        Skeleton_xindx = (float)((float)(Skeleton.getPosition().x - 183) / 53 + 2);
        Skeleton_yindx = (float)((float)(Skeleton.getPosition().y - 74) / 48 + 2);
        right.i = GetXindx(Skeleton.getPosition().x + 20); right.j = Skeleton_yindx;
        left.i = GetXindx(Skeleton.getPosition().x - 20); left.j = Skeleton_yindx;
        up.i = Skeleton_xindx; up.j = GetYindx(Skeleton.getPosition().y - 7);
        down.i = Skeleton_xindx; down.j = GetYindx(Skeleton.getPosition().y + 7);
        //######################################################################################################

        //######################################################################################################
        // Skeleton Movement
        if (Skeleton_counter >= 250)
        {
            Skeleton_Rand_motion = rand() % 4 + 1;
            Skeleton_counter = 0;
        }

        if (Skeleton_Rand_motion == 1)                                          // Moving UP => Rand_motion == 1
        {
            Skeleton_counter++;
            if (Grid[up.i][up.j].getTexture() == &ground || Grid[up.i][up.j].getTexture() == &ground2)
            {

                Movement_Upward(Skeleton, Skeleton_time, Skeleton_clock, Skeleton_position, Skeleton_size, Random_Monsters_Speed);

            }
            else
            {
                Skeleton_counter = 250;
            }

        }


        else if (Skeleton_Rand_motion == 2)                                 // Moving Down => Rand_motion == 2
        {
            Skeleton_counter++;
            if (Grid[down.i][down.j].getTexture() == &ground || Grid[down.i][down.j].getTexture() == &ground2)
            {
                Movement_Downward(Skeleton, Skeleton_time, Skeleton_clock, Skeleton_position, Skeleton_size, Random_Monsters_Speed);

            }

            else
            {
                Skeleton_counter = 250;
            }
        }


        else if (Skeleton_Rand_motion == 3)                                 // Moving Right => Rand_motion == 3
        {
            Skeleton_counter++;
            if (Grid[right.i][right.j].getTexture() == &ground || Grid[right.i][right.j].getTexture() == &ground2)
            {
                Movement_Right(Skeleton, Skeleton_time, Skeleton_clock, Skeleton_position, Skeleton_size, Random_Monsters_Speed);

            }
            else
            {
                Skeleton_counter = 250;
            }
        }


        else if (Skeleton_Rand_motion == 4)                                 // Moving Left => Rand_motion == 4
        {
            Skeleton_counter++;
            if (Grid[left.i][left.j].getTexture() == &ground || Grid[left.i][left.j].getTexture() == &ground2)
            {
                Movement_Left(Skeleton, Skeleton_time, Skeleton_clock, Skeleton_position, Skeleton_size, Random_Monsters_Speed);

            }
            else
            {
                Skeleton_counter = 250;
            }

        }

        //######################################################################################################
        // White_Robot movement
        White_Robot_xindx = (float)((float)(White_Robot.getPosition().x - 183) / 53 + 2);
        White_Robot_yindx = (float)((float)(White_Robot.getPosition().y - 74) / 48 + 2);
        right.i = GetXindx(White_Robot.getPosition().x + 20); right.j = White_Robot_yindx;
        left.i = GetXindx(White_Robot.getPosition().x - 20); left.j = White_Robot_yindx;
        up.i = White_Robot_xindx; up.j = GetYindx(White_Robot.getPosition().y - 7);
        down.i = White_Robot_xindx; down.j = GetYindx(White_Robot.getPosition().y + 7);
        //######################################################################################################

        //######################################################################################################
        // White_Robot Movement
        if (White_Robot_counter >= 250)
        {
            White_Robot_Rand_motion = rand() % 4 + 1;
            White_Robot_counter = 0;
        }

        if (White_Robot_Rand_motion == 1)                                           // Moving UP => Rand_motion == 1
        {
            White_Robot_counter++;
            if (Grid[up.i][up.j].getTexture() == &ground || Grid[up.i][up.j].getTexture() == &ground2)
            {

                Movement_Upward(White_Robot, White_Robot_time, White_Robot_clock, White_Robot_position, White_Robot_size, Random_Monsters_Speed);

            }
            else
            {
                White_Robot_counter = 250;
            }

        }


        else if (White_Robot_Rand_motion == 2)                                  // Moving Down => Rand_motion == 2
        {
            White_Robot_counter++;
            if (Grid[down.i][down.j].getTexture() == &ground || Grid[down.i][down.j].getTexture() == &ground2)
            {
                Movement_Downward(White_Robot, White_Robot_time, White_Robot_clock, White_Robot_position, White_Robot_size, Random_Monsters_Speed);
            }

            else
            {
                White_Robot_counter = 250;
            }
        }


        else if (White_Robot_Rand_motion == 3)                                  // Moving Right => Rand_motion == 3
        {
            White_Robot_counter++;
            if (Grid[right.i][right.j].getTexture() == &ground || Grid[right.i][right.j].getTexture() == &ground2)
            {
                Movement_Right(White_Robot, White_Robot_time, White_Robot_clock, White_Robot_position, White_Robot_size, Random_Monsters_Speed);
            }
            else
            {
                White_Robot_counter = 250;
            }
        }


        else if (White_Robot_Rand_motion == 4)                                  // Moving Left => Rand_motion == 4
        {
            White_Robot_counter++;
            if (Grid[left.i][left.j].getTexture() == &ground || Grid[left.i][left.j].getTexture() == &ground2)
            {
                Movement_Left(White_Robot, White_Robot_time, White_Robot_clock, White_Robot_position, White_Robot_size, Random_Monsters_Speed);
            }
            else
            {
                White_Robot_counter = 250;
            }

        }

        //######################################################################################################



        Event event;
        while (Level_3.pollEvent(event))
        {
            if (event.type == sf::Event::Closed || Keyboard::isKeyPressed(Keyboard::Enter))
                Level_3.close();

        }
        Level_3.clear();

        // Drawing of the Wallpaper
        Level_3.draw(Wallpaper);

        //Drawing of The Map
        for (int i = 2; i < width; i++)
        {
            for (int j = 2; j < length; j++)
            {
                if (Grid[i][j].getTexture() == &ground || Grid[i][j].getTexture() == &ground2)
                {
                    Level_3.draw(Grid[i][j]);
                }
            }

        }

        for (int j = 1; j <= length; j++)
        {
            for (int i = 1; i <= width; i++)
            {
                if (Grid[i][j].getTexture() == &ground || Grid[i][j].getTexture() == &ground2)
                {
                    continue;
                }

                Level_3.draw(Grid[i][j]);

                if (GetYindx(player.getPosition().y) >= j)
                {
                    Level_3.draw(player);
                }

                if (GetYindx(Skeleton.getPosition().y) >= j)
                {
                    Level_3.draw(Skeleton);
                }

                if (GetYindx(White_Robot.getPosition().y) >= j)
                {
                    Level_3.draw(White_Robot);
                }

                if (GetYindx(Blue_Skeleton.getPosition().y) >= j)
                {
                    Level_3.draw(Blue_Skeleton);
                }

                if (GetYindx(Red_Robot.getPosition().y) >= j)
                {
                    Level_3.draw(Red_Robot);
                }
            }
        }
        if (player_status.lives == 2) {

        }
        else if (player_status.lives == 1) {
        }
        else if (player_status.lives <= 0) {
            // start lay lay (you are fucked up)
            // show game over screen
            // what else ?!!
            cout << "you are fucked uppp" << endl;
        }


        // player damage
        if (GetXindx(player.getPosition().x) == GetXindx(White_Robot.getPosition().x) && GetYindx(player.getPosition().y) == GetYindx(White_Robot.getPosition().y))
        {
            if (Clock_Damgae.getElapsedTime().asSeconds() >= 1) {
                --player_status.lives;
                Clock_Damgae.restart();
            }
            Level_3.draw(Hurt);

        }

        if (GetXindx(player.getPosition().x) == GetXindx(Skeleton.getPosition().x) && GetYindx(player.getPosition().y) == GetYindx(Skeleton.getPosition().y))
        {
            if (Clock_Damgae.getElapsedTime().asSeconds() >= 1) {
                --player_status.lives;
                Clock_Damgae.restart();
            }
            Level_3.draw(Hurt);
        }

        if (GetXindx(player.getPosition().x) == GetXindx(Blue_Skeleton.getPosition().x) && GetYindx(player.getPosition().y) == GetYindx(Blue_Skeleton.getPosition().y))
        {
            if (Clock_Damgae.getElapsedTime().asSeconds() >= 1) {
                --player_status.lives;
                Clock_Damgae.restart();
            }
            Level_3.draw(Hurt);
        }

        if (GetXindx(player.getPosition().x) == GetXindx(Red_Robot.getPosition().x) && GetYindx(player.getPosition().y) == GetYindx(Red_Robot.getPosition().y))
        {
            if (Clock_Damgae.getElapsedTime().asSeconds() >= 1) {
                --player_status.lives;
                Clock_Damgae.restart();
            }
            Level_3.draw(Hurt);
        }

        cout << player_status.lives << endl;
        for (int i = 0; i < 2; i++)
        {
            Level_3.draw(timebombS[i]);
        }
        Level_3.draw(lifeS);
        Level_3.draw(rangeS);
        Level_3.draw(bombS);
        Level_3.display();


    }

}

void Multiplayer()
{

    Font dis_time;
    if (!dis_time.loadFromFile("Chocolate Bar Demo.otf"))
    {
        cout << "error font";
    }
    //timer stuff
    int display_timer;
    Clock c, timer_clock;
    Time times, timer;
    //map stuff
    Texture wall, ground, wallpaper, ground2, breakable, zone_warning_text, hurt;
    Texture death;
    Sprite Death;
    if (!death.loadFromFile("death.png"))
        cout << "error to load death " << endl;

    Death.setTexture(death);
    // songs load
    Music ingame; ingame.openFromFile("ingame.wav");
    ingame.play();
    Music lost;
    lost.openFromFile("For the Damaged Coda.wav");
    // zone stuff
    Sprite zone_warning_sprt, Hurt;
    if (!zone_warning_text.loadFromFile("zone.png")) {
        cout << "error to load zone " << endl;
    }
    zone_warning_sprt.setTexture(zone_warning_text);
    zone_warning_sprt.setScale(0.5, 0.5);
    zone_warning_sprt.setPosition(440, 520);
    int zone_limit = 1;
    if (!breakable.loadFromFile("breakable.png")) {
        cout << "error to load breakable " << endl;
    }
    if (!hurt.loadFromFile("hurt.png")) {
        cout << "error to load breakable " << endl;
    }
    Hurt.setTexture(hurt);
    if (!wallpaper.loadFromFile("wallpaper.jpg")) {
        cout << "error to load wallpaper " << endl;
    }

    if (!wall.loadFromFile("3d wall.png")) {
        cout << "error to load 3d wall " << endl;
    }
    if (!ground.loadFromFile("ground 1.png")) {
        cout << "error to load ground " << endl;
    }




    if (!ground2.loadFromFile("grass.png")) {
        cout << "error to load grass " << endl;
    }


    Sprite lifeS, rangeS, bombS, Wallpaper;

    Wallpaper.setTexture(wallpaper);


    // Distribution of wall & ground on the Grid

    const int length = 9, width = 17;

    Sprite Grid[width + 1][length + 1];

    for (int i = 1; i <= width; i++)
    {
        for (int j = 1; j <= length; j++)
        {
            if (i % 2 != 0 && j % 2 != 0)
            {

                Grid[i][j].setTexture(wall);
                Grid[i][j].setPosition((i + 1.97) * 53, (j + 0.255) * 48);
                Grid[i][j].setScale(Vector2f(0.1009, 0.165));

            }

            else if (i == 1 || i == width)
            {
                Grid[i][j].setTexture(wall);
                Grid[i][j].setPosition((i + 1.97) * 53, (j + 0.255) * 48);
                Grid[i][j].setScale(Vector2f(0.1009, 0.165));
            }
            else if (j == 1 || j == length)
            {
                Grid[i][j].setTexture(wall);
                Grid[i][j].setPosition((i + 1.97) * 53, (j + 0.255) * 48);
                Grid[i][j].setScale(Vector2f(0.1009, 0.165));
            }
            else
            {
                if (i % 2 == j % 2)
                {
                    Grid[i][j].setTexture(ground);
                }
                else
                {
                    Grid[i][j].setTexture(ground2);
                }
                Grid[i][j].setPosition((i + 2) * 53, (j + 0.8) * 48);
                Grid[i][j].setScale(0.1009, 0.101);
            }
        }
    }
    for (int i = 1; i <= 30; i++)
    {
        int x = rand() % 14 + 2, y = rand() % 7 + 2;
        if (x % 2 != 0 && y % 2 != 0)
        {
            x++;
        }
        Grid[x][y].setTexture(breakable);
        Grid[x][y].setPosition((x + 1.97) * 53, (y + 0.255) * 48);
        Grid[x][y].setScale(Vector2f(0.1009, 0.165));
    }

    // player 1 creation
    const int players_speed = 2;
    //###############################################################################
    // Making of Player1
    RectangleShape player1(Vector2f(100, 120));
    Texture player1_texture;
    Vector2u player1_size;
    Clock player1_clock;
    Time player1_time;
    float player1_position = 0;
    Generate_Charcter(player1, player1_texture, player1_size, "mainplayer.png", 2, 2);

    //###############################################################################
  // Making of Player2
    RectangleShape player2(Vector2f(100, 120));
    Texture player2_texture;
    Vector2u player2_size;
    Clock player2_clock;
    Time player2_time;
    float player2_position = 0;
    Generate_Charcter(player2, player2_texture, player2_size, "mainplayer.png", 10, 2);


    //###############################################################################
   // Movement stuff
    leftmovement left; rightmovement right; upmovement up; downmovement down;
    int player1_xindx = 0, player1_yindx = 0, player2_xindx = 0, player2_yindx = 0;
    //###############################################################################



    //bomb stuff

    Time times2, t, ti;
    Clock clocks2, cs, clocks;

    Time music_time;
    Clock music_clock;

    int death_music_duration = 0;

    bool death_flag = 0;
    //Game Window
    RenderWindow window(VideoMode(1280, 768), "our first try with SFML");
    while (window.isOpen())
    {



        Event event;
        while (window.pollEvent(event))
        {
            if (event.type == sf::Event::Closed || Keyboard::isKeyPressed(Keyboard::Enter))
                window.close();
        }


        if (Keyboard::isKeyPressed(Keyboard::N))
        {
            death_flag = 1;
            music_clock.restart();
            lost.play();
        }

        music_time = music_clock.getElapsedTime();
        death_music_duration = music_time.asSeconds();




        // Timer
        Text txt;
        timer = timer_clock.getElapsedTime();
        display_timer = timer.asSeconds();
        string s1, s2;
        //int  minu=display_timer/60;
        s1 = to_string(30 - (display_timer));
        //s2=to_string(1-minu);
        //s2+=" : ";
        //s2+=s1;

        txt.setFont(dis_time);
        txt.setString("0:" + s1);
        txt.setPosition(512, 22);


        if (display_timer >= 30)
        {
            timer_clock.restart();


            for (int j = 2; j < length; j++)
            {
                Grid[zone_limit + 1][j].setTexture(wall);

                Grid[width - zone_limit][j].setTexture(wall);

                Grid[zone_limit + 1][j].setPosition((zone_limit + 1 + 1.97) * 53, (j + 0.255) * 48);

                if ((GetXindx(player1.getPosition().x)) == zone_limit + 1) {
                    death_flag = 1;
                    music_clock.restart();
                    ingame.stop();
                    lost.play();
                }

                if ((GetXindx(player2.getPosition().x)) == zone_limit + 1) {
                    death_flag = 1;
                    music_clock.restart();
                    ingame.stop();
                    lost.play();
                }

                Grid[width - zone_limit][j].setPosition((width - zone_limit + 1.97) * 53, (j + 0.255) * 48);

                Grid[zone_limit + 1][j].setScale(Vector2f(0.1009, 0.165));

                Grid[width - zone_limit][j].setScale(Vector2f(0.1009, 0.165));



                if ((GetXindx(player1.getPosition().x)) == width - zone_limit) {
                    death_flag = 1;
                    music_clock.restart();
                    ingame.stop();
                    lost.play();

                }

                if ((GetXindx(player2.getPosition().x)) == width - zone_limit) {
                    death_flag = 1;
                    music_clock.restart();
                    ingame.stop();
                    lost.play();

                }






            }
            zone_limit++;
        }





        // player1 1 Movement
        player1_xindx = (float)((float)(player1.getPosition().x - 183) / 53 + 2);
        player1_yindx = (float)((float)(player1.getPosition().y - 74) / 48 + 2);
        right.i = GetXindx(player1.getPosition().x + 20); right.j = player1_yindx;
        left.i = GetXindx(player1.getPosition().x - 20); left.j = player1_yindx;
        up.i = player1_xindx; up.j = GetYindx(player1.getPosition().y - 7);
        down.i = player1_xindx; down.j = GetYindx(player1.getPosition().y + 7);

        if (Keyboard::isKeyPressed(Keyboard::Key::Right) && (Grid[right.i][right.j].getTexture() == &ground || Grid[right.i][right.j].getTexture() == &ground2))      // Moving Right
        {
            Movement_Right(player1, player1_time, player1_clock, player1_position, player1_size, players_speed);
        }
        else if (Keyboard::isKeyPressed(Keyboard::Key::Left) && (Grid[left.i][left.j].getTexture() == &ground || Grid[left.i][left.j].getTexture() == &ground2))         // Moving Left
        {
            Movement_Left(player1, player1_time, player1_clock, player1_position, player1_size, players_speed);
        }
        else if (Keyboard::isKeyPressed(Keyboard::Key::Up) && (Grid[up.i][up.j].getTexture() == &ground || Grid[up.i][up.j].getTexture() == &ground2))           // Moving Up
        {
            Movement_Upward(player1, player1_time, player1_clock, player1_position, player1_size, players_speed);
        }
        else if (Keyboard::isKeyPressed(Keyboard::Key::Down) && (Grid[down.i][down.j].getTexture() == &ground || Grid[down.i][down.j].getTexture() == &ground2))         // Moving Down
        {
            Movement_Downward(player1, player1_time, player1_clock, player1_position, player1_size, players_speed);
        }


        // Player 2 Movement
        player2_xindx = (float)((float)(player2.getPosition().x - 183) / 53 + 2);
        player2_yindx = (float)((float)(player2.getPosition().y - 74) / 48 + 2);
        right.i = GetXindx(player2.getPosition().x + 20); right.j = player2_yindx;
        left.i = GetXindx(player2.getPosition().x - 20); left.j = player2_yindx;
        up.i = player2_xindx; up.j = GetYindx(player2.getPosition().y - 7);
        down.i = player2_xindx; down.j = GetYindx(player2.getPosition().y + 7);

        if (Keyboard::isKeyPressed(Keyboard::Key::D) && (Grid[right.i][right.j].getTexture() == &ground || Grid[right.i][right.j].getTexture() == &ground2))      // Moving Right
        {
            Movement_Right(player2, player2_time, player2_clock, player2_position, player2_size, players_speed);
        }
        else if (Keyboard::isKeyPressed(Keyboard::Key::A) && (Grid[left.i][left.j].getTexture() == &ground || Grid[left.i][left.j].getTexture() == &ground2))         // Moving Left
        {
            Movement_Left(player2, player2_time, player2_clock, player2_position, player2_size, players_speed);
        }
        else if (Keyboard::isKeyPressed(Keyboard::Key::W) && (Grid[up.i][up.j].getTexture() == &ground || Grid[up.i][up.j].getTexture() == &ground2))           // Moving Up
        {
            Movement_Upward(player2, player2_time, player2_clock, player2_position, player2_size, players_speed);
        }
        else if (Keyboard::isKeyPressed(Keyboard::Key::S) && (Grid[down.i][down.j].getTexture() == &ground || Grid[down.i][down.j].getTexture() == &ground2))         // Moving Down
        {
            Movement_Downward(player2, player2_time, player2_clock, player2_position, player2_size, players_speed);
        }



        window.clear();
        // Drawing of the Wallpaper
        window.draw(Wallpaper);

        //Drawing of The Map
        for (int i = 2; i < width; i++)
        {
            for (int j = 2; j < length; j++)
            {
                if (Grid[i][j].getTexture() == &ground || Grid[i][j].getTexture() == &ground2)
                {
                    window.draw(Grid[i][j]);
                }
            }

        }

        for (int j = 1; j <= length; j++)
        {
            for (int i = 1; i <= width; i++)
            {
                if (Grid[i][j].getTexture() == &ground || Grid[i][j].getTexture() == &ground2)
                {
                    continue;
                }

                window.draw(Grid[i][j]);

                if (GetYindx(player1.getPosition().y) >= j)
                {
                    window.draw(player1);
                }


                if (GetYindx(player2.getPosition().y) >= j)
                {
                    window.draw(player2);
                }
            }
        }

        window.draw(txt);
        if (display_timer >= 25)
        {
            window.draw(zone_warning_sprt); window.draw(Hurt);
        }
        //window.draw(Death);
        if (death_flag && death_music_duration <= 16) {
            window.draw(Death);
            if (death_music_duration == 16)
                exit(0);
        }
        //if (death_flag && death_music_duration>16) {exit(0);}
        window.display();

    }



}
int main()
{
    Music outgame; outgame.openFromFile("Main menu.wav");
    outgame.play();
    //###############################################################################
    // Menu Shits
    RenderWindow background(VideoMode(1024, 680), "Fuck");
    setmenustatus(background.getSize().x, background.getSize().y);
    Texture backgroundwall;
    backgroundwall.loadFromFile("FantasyLand.png");
    Sprite Menuwall; Menuwall.setTexture(backgroundwall);
    //Menu choices
    Sprite Choice, Choice2;
    Texture choice;
    if (!choice.loadFromFile("Untitled-1-Recovered.png"))
    {
        cout << "choice not found";
    }
    Choice.setTexture(choice);
    Choice.setPosition(0, 415);
    Choice.setScale(0.3, 0.27);

    Choice2.setTexture(choice);
    Choice2.setPosition(1024 - (0.3 * 1307), 315);
    Choice2.setScale(0.3, 0.27);
    //###############################################################################

    bool singleplayer = 0;

    while (background.isOpen())
    {
        // Menu choices Animation
        if (Choice.getPosition().x < 310)
        {
            Choice.move(0.5, 0);
        }
        if (Choice2.getPosition().x > 310)
        {
            Choice2.move(-0.5, 0);
        }

        Event evnt;
        while (background.pollEvent(evnt))
        {
            switch (evnt.type)
            {
            case sf::Event::KeyReleased:
                switch (evnt.key.code)
                {
                case sf::Keyboard::Up:
                    MoveUp();
                    break;

                case sf::Keyboard::Down:
                    MoveDown();
                    break;

                case sf::Keyboard::Return:
                    switch (GetPressedItem())
                    {
                    case 0:
                        singleplayer = 1;
                        background.close();
                        break;
                    case 1:
                        outgame.stop();
                        background.close();
                        Multiplayer();
                        break;
                    case 2:
                        cout << "About Us button has been pressed \n";
                    case 3:
                        background.close();
                        //window.close();
                        return(0);
                        break;
                    }

                    break;
                }

                break;
            case Event::Closed:
                background.close();
                return 0;
                break;
            }
        }

        if ((Mouse::isButtonPressed(Mouse::Left)) && (Mouse::getPosition().x >= 615 && Mouse::getPosition().x <= 680)) {
            background.close();
            break;

        }
        background.clear();
        background.draw(Menuwall);
        background.draw(Choice);
        background.draw(Choice2);
        drawmenu(background);
        background.display();

    }
    RenderWindow levels(VideoMode(1024, 680), "levels");
    setlevelsstatus(levels.getSize().x, levels.getSize().y);
    Texture levelwall;
    levelwall.loadFromFile("levelwall.png");
    Sprite levelwallS; levelwallS.setTexture(levelwall);
    Choice2.setPosition(1024 - (0.3 * 1307), 315); Choice.setPosition(0, 415);
    while (levels.isOpen()&&singleplayer)
    {
        // Menu choices Animation
        if (Choice.getPosition().x < 310)
        {
            Choice.move(0.5, 0);
        }
        if (Choice2.getPosition().x > 310)
        {
            Choice2.move(-0.5, 0);
        }

        Event evntlev;
        while (levels.pollEvent(evntlev))
        {
            switch (evntlev.type)
            {
            case Event::KeyReleased:
                switch (evntlev.key.code)
                {
                case Keyboard::Up:
                    MoveUplev();
                    break;

                case Keyboard::Down:
                    MoveDownlev();
                    break;

                case Keyboard::Return:
                    switch (GetPressedlevel())
                    {
                    case 0:
                        outgame.stop();
                        levels.close();
                        Beginner_Mode();
                        break;
                    case 1:
                        outgame.stop();
                        levels.close();
                        Advanced_Level();
                        break;
                    case 2:
                        outgame.stop();
                        levels.close();
                        Legendary_Mode();
                        break;
                    }

                    break;
                }

                break;
            case Event::Closed:
                background.close();
                return 0;
                break;
            }


        }
        if ((Mouse::isButtonPressed(Mouse::Left)) && (Mouse::getPosition().x >= 615 && Mouse::getPosition().x <= 680)) {
            background.close();
            break;

        }

        levels.clear();
        levels.draw(levelwallS);
        levels.draw(Choice);
        levels.draw(Choice2);
        drawlev(levels);
        levels.display();

    }




}