Переопределение размера массива указателей

template <class TypeName>
class DinamicMassive
{
public:
    TypeName **Massive;
    int N;
    bool Seted = false;
    DinamicMassive()
    {
        N = 1;
        Massive = new TypeName*[N];
    }
    ~DinamicMassive()
    {
        delete Massive;
    }
    void ChangeLenght(int NewLenght)
    {
        TypeName **Massive2 = new TypeName*[NewLenght];
        int i2 = 0;
        for (int i = 0; i < N; i++)
        {
            if (Massive[i + i2] != 0)
            {
                Massive2[i] = Massive[i + i2];
            }
            else
            {
                i2++;
            }
        }
        N = NewLenght;
        delete Massive;
        Massive = Massive2;
    }
private:
};

#pragma once
#include "Vector2.hpp";
#include "DinamicMassive.cpp";
#include <iostream>;
#include <string>;
#include <random>;  
#include <math.h>;
 
using namespace sf;
using namespace std;
 
class Body
{
public:
    Vector2f Velocity;    // Тип - float
    Vector2f Force;       // Тип - float
    int ColType;
    float X, Y;
    float Mass;
    float R;
    float p = 1.0f;
    float Temp = 0.0f;
    float q = 0.0f;
    float e = 0.0f;
    bool Dinamic = true;
    bool Collided = false;
    bool Continue = false;
    Body()
    {
 
    }
    ~Body()
    {
 
    }
    void SetBody(Vector2f Vel, float Mas, float p1, int col, bool din)
    {
        Velocity = Vel;
        if (Mas == 0)
        {
            Mass = 0.0000001f;
        }
        else
        {
            Mass = Mas;
        }
        if (p1 == 0)
        {
            p = 1;
        }
        else
        {
            p = p1;
        }
        Dinamic = din;
        ColType = col;
        R = sqrt((Mass / p) / _Pi);
    }
    void AddVel(Vector2f Vel)
    {
        Velocity += Vel;
    }
    void AddForce(Vector2f force)
    {
        Force += force;
    }
    void CalcVel(float Time)
    {
        Velocity.x = Velocity.x + (Force.x*Time) / (Mass);
        Velocity.y = Velocity.y + (Force.y*Time) / (Mass);
        Force = { 0, 0 };
    }
    void SumB(Body *b2)
    {
        Velocity.x = ((Mass * Velocity.x) + (b2->Mass*b2->Velocity.x)) / (Mass + b2->Mass);
        Velocity.y = ((Mass * Velocity.y) + (b2->Mass*b2->Velocity.y)) / (Mass + b2->Mass);
        Mass = Mass + b2->Mass;
        p = sqrt(pow(p, 2) + pow(b2->p, 2));
        R = sqrt((Mass / p) / _Pi);
        X = X - b2->R * (X - b2->X) / (R + b2->R);
        Y = Y - b2->R * (Y - b2->Y) / (R + b2->R);
    }
    Vector2f Move(Vector2f Pos, float Time)
    {
        return(Pos + Velocity*Time);
    }
private:
};
 
class RenderSettings
{
public:
    float Time = 0.0f;
    bool Gravity = false;
    bool Magnet = true;
    bool Elemental = true;
    bool Rubber = false;
    bool Vectors = false;
    bool NoExit = true;
    int LBorder = 0;
    int RBorder = 0;
    int UBorder = 0;
    int DBorder = 0;
    float ForceScale = 1.0f;
    float Elk = 100.0f;
    float G = 0.0000000000667384f;
    float k = 8988000000.0f;
    void SetUp(bool G, bool R, bool V, bool X)
    {
        Gravity = G;
        Rubber = R;
        Vectors = V;
        NoExit = X;
    }
    void SetBorders(int L, int R, int U, int D)
    {
        LBorder = L;
        RBorder = R;
        UBorder = U;
        DBorder = D;
    }
private:
};
 
class PHYSICS
{
public:
    RenderSettings Settings;
    PHYSICS(float Time)
    {
        Settings.Time = Time;
    }
    ~PHYSICS()
    {
 
    }
    void render(float loops, bool joints, bool movement, bool collision)
    {
        if (loops == 0)
        {
            loops = 1;
        }
        for (int L = 0; L < loops; L++)
        {
            if (joints)
            {
                for (i = 0; i < Bodies.N; i++)
                {
                    for (i2 = 0; i2 < Bodies.N; i2++)
                    {
                        if (i != i2)
                        {
                            Joints(Settings.Time / loops, Bodies.Massive[i], Bodies.Massive[i2]);
                        }
                    }
                }
            }
            if (collision)
            {
                for (i = 0; i < Bodies.N; i++)
                {
                    for (i2 = 0; i2 < Bodies.N; i2++)
                    {
                        if (i != i2)
                        {
                            CheckCollision(Settings.Time / loops, Bodies.Massive[i], Bodies.Massive[i2]);
                        }
                    }
                }
            }
            if (movement)
            {
                for (i = 0; i < Bodies.N; i++)
                {
                    Movement(Settings.Time / loops, Bodies.Massive[i]);
                }
            }
        }
    }
    void AddToRander(Body *Obj)
    {
        if (Bodies.Seted)
        {
            Bodies.ChangeLenght(Bodies.N + 1);
        }
        else
        {
            Bodies.Seted = true;
        }
        Bodies.Massive[Bodies.N - 1] = Obj;
    }
    void DelFromRander(int Num)
    {
        Bodies.Massive[Num]->R = -(Bodies.Massive[Num]->R * 2);
        Bodies.Massive[Num]->Dinamic = false;
        Bodies.Massive[Num] = 0;
        Bodies.ChangeLenght(Bodies.N - 1);
    }
    Body *GetFromRender(int N1)
    {
        return(Bodies.Massive[N1]);
    }
    int GetNumFromRender(Body *b1)
    {
        int Num = 0;
        while (b1 != Bodies.Massive[Num])
        {
            Num++;
        }
        return(Num);
    }
    void StopObj()
    {
        for (i = 0; i < Bodies.N; i++)
        {
            Bodies.Massive[i]->Velocity = { 0, 0 };
            Bodies.Massive[i]->Force = { 0, 0 };
        }
    }
    Vector2f RubberJoint(float X, float X1, float Y, float Y1, float Div)
    {
        if (Div == 0)
        {
            Div = 1;
        }
        Div = Div / 10;
        Vector2f Vel;
        Vel.x = -(X - X1) / Div;        
        Vel.y = -(Y - Y1) / Div;
        return(Vel);
    }
    Vector2f MagnetJoint(Body *b1, Body *b2)
    {
        Vector2f Vel1;
        float Vel2;
        Vel2 = Settings.ForceScale * -1 * Settings.k * (b1->q*b2->q) / (pow(b1->X - b2->X, 2) + pow(b1->Y - b2->Y, 2));
        Vel1.x = (Vel2 / sqrt(pow((b2->X - b1->X), 2) + pow((b2->Y - b1->Y), 2)))*(b2->X - b1->X);
        Vel1.y = (Vel2 / sqrt(pow((b2->X - b1->X), 2) + pow((b2->Y - b1->Y), 2)))*(b2->Y - b1->Y);
        return(Vel1);
    }
    Vector2f ElementJoint(Body *b1, Body *b2)
    {
        Vector2f Vel1;
        float Vel2;
        float Vel3;
        Vel2 = Settings.ForceScale * pow(sqrt(b1->e*b2->e) / (sqrt(pow(b1->X - b2->X, 2) + pow(b1->Y - b2->Y, 2))), 6);
        Vel3 = Settings.ForceScale * pow(sqrt(b1->e*b2->e) / (sqrt(pow(b1->X - b2->X, 2) + pow(b1->Y - b2->Y, 2))), 12);
        Vel2 = Settings.Elk * (Vel3 - Vel2);
        Vel1.x = (Vel2 / sqrt(pow((b2->X - b1->X), 2) + pow((b2->Y - b1->Y), 2)))*(b2->X - b1->X);
        Vel1.y = (Vel2 / sqrt(pow((b2->X - b1->X), 2) + pow((b2->Y - b1->Y), 2)))*(b2->Y - b1->Y);
        return(Vel1);
    }
    Vector2f GravityJoint(Body *b1, Body *b2)
    {
        Vector2f Vel1;
        float Vel2;
        Vel2 = Settings.ForceScale * Settings.G * (b1->Mass*b2->Mass) / (pow(b1->X - b2->X, 2) + pow(b1->Y - b2->Y, 2));
        Vel1.x = (Vel2 / sqrt(pow((b2->X - b1->X), 2) + pow((b2->Y - b1->Y), 2)))*(b2->X - b1->X);
        Vel1.y = (Vel2 / sqrt(pow((b2->X - b1->X), 2) + pow((b2->Y - b1->Y), 2)))*(b2->Y - b1->Y);
        return(Vel1);
    }
private:
    DinamicMassive <Body> Bodies;
    int i = 0;
    int i2 = 0;
    void Joints(float T, Body *body1, Body *body2)
    {   
        if (body1 != body2)
        {
            if (body1->Dinamic)
            {
                if (Settings.Gravity)
                {
                    body1->AddForce(GravityJoint(body1, body2));
                }
                if (Settings.Magnet)
                {
                    body1->AddForce(MagnetJoint(body1, body2));
                }
                if (Settings.Elemental)
                {
                    body1->AddForce(ElementJoint(body1, body2));
                }
            }
        }
        body1->CalcVel(T);
    }
    void Movement(float T, Body *body1)
    {
        if (body1->Dinamic)
        {
            if (!body1->Continue)
            {
                body1->X = body1->Move({ body1->X, body1->Y }, T).x;
                body1->Y = body1->Move({ body1->X, body1->Y }, T).y;
                if (Settings.NoExit)
                {
                    if (body1->X >= Settings.RBorder)
                    {
                        body1->X = Settings.LBorder + 1;
                    }
                    if (body1->X <= Settings.LBorder)
                    {
                        body1->X = Settings.RBorder - 1;
                    }
                    if (body1->Y >= Settings.DBorder)
                    {
                        body1->Y = Settings.UBorder + 1;
                    }
                    if (body1->Y <= Settings.UBorder)
                    {
                        body1->Y = Settings.DBorder - 1;
                    }
                }
            }
            else
            {
                body1->Continue = false;
            }
        }
    }
    void CheckCollision(float T, Body *body1, Body *body2)смогу.
    {
        if (body1->ColType != 0 && body2->ColType != 0 && body1 != body2)
        {
            if (!body1->Continue && !body2->Continue)
            {
                float Length = 0.0f;
                float Radius = 0.0f;
                float Value = 0.0f;
                Vector2f Point1 = { body1->X, body1->Y };
                Vector2f Point2 = { body1->X + body1->Velocity.x*T,
                    body1->Y + body1->Velocity.y*T };
                Vector2f Point3 = { body2->X, body2->Y };
                Vector2f Point4 = { body2->X + body2->Velocity.x*T,
                    body2->Y + body2->Velocity.y*T };
                if (Point1.x > Point2.x)
                {
                    Value = Point1.x;
                    Point1.x = Point2.x;
                    Point2.x = Value;
                }
                if (Point1.y > Point2.y)
                {
                    Value = Point1.y;
                    Point1.y = Point2.y;
                    Point2.y = Value;
                }
                if (Point3.x > Point4.x)
                {
                    Value = Point3.x;
                    Point3.x = Point4.x;
                    Point3.x = Value;
                }
                if (Point3.y > Point4.y)
                {
                    Value = Point3.y;
                    Point3.y = Point4.y;
                    Point4.y = Value;
                }
                Point1.x = Point1.x - body1->R;
                Point2.x = Point2.x + body1->R;
                Point1.y = Point1.y - body1->R;
                Point2.y = Point2.y + body1->R;
 
                Point3.x = Point3.x - body2->R;
                Point4.x = Point4.x + body2->R;
                Point3.y = Point3.y - body2->R;
                Point4.y = Point4.y + body2->R;
                if ((Point3.x <= Point1.x && Point1.x <= Point4.x) || (Point1.x <= Point3.x && Point3.x <= Point2.x))
                {
                    if ((Point3.y <= Point1.y && Point1.y <= Point4.y) || (Point1.y <= Point3.y && Point3.y <= Point2.y))
                    {
                        Radius = body1->R + body2->R;
                        float speed = 0.0f;
                        if (abs(body1->Velocity.x*T) + abs(body2->Velocity.x*T)
                            > abs(body1->Velocity.y*T) + abs(body2->Velocity.y*T))
                        {
                            speed = abs(body1->Velocity.x*T) + abs(body2->Velocity.x*T);
                        }
                        else
                        {
                            speed = abs(body1->Velocity.y*T) + abs(body2->Velocity.y*T);
                        }
                        float DT = T * Radius / speed;
                        if (DT > T)
                        {
                            DT = T;
                        }
                        int Num = T / DT;
                        int Collided = 0;
                        for (float ii = 0; ii <= Num; ii++)
                        {
                            if (Collided == 0)
                            {
                                Length = sqrt(pow(body1->X - body2->X, 2)
                                    + pow(body1->Y - body2->Y, 2));
                                if (Length <= Radius)
                                {
                                    switch (body1->ColType)
                                    {
                                        case 1:
                                        {
                                            break;
                                        }
                                        case 2:
                                        {
                                            if (Collided != 1)
                                            {
                                                if (body1->Mass >= body2->Mass)
                                                {
                                                    body1->SumB(body2);
                                                    DelFromRander(i2);
                                                    Collided = 2;
 
                                                    i2--;
                                                    if (i > i2)
                                                    {
                                                        i--;
                                                    }
                                                }
                                                Movement(DT, body1);
                                                break;
                                            }
                                        }
                                        default:
                                        {
                                            break;
                                        }
                                    }
                                    switch (body2->ColType)
                                    {
                                        case 1:
                                        {
                                            break;
                                        }
                                        case 2:
                                        {
                                            if (Collided != 2)
                                            {
                                                if (body2->Mass > body1->Mass)
                                                {
                                                    body2->SumB(body1);
                                                    DelFromRander(i);
                                                    Collided = 1;
                                                    i--;
                                                    i2 = Bodies.N;
                                                }
                                                Movement(DT, body2);
                                                break;
                                            }
                                        }
                                        default:
                                        {
                                            break;
                                        }
                                    }
                                }
                            }
                            Movement(DT, body1);
                            Movement(DT, body2);
                        }
                        body1->Continue = true;
                        body2->Continue = true;
                    }
                }
            }
        }
    }
    void ColTypes(Body *body1, Body *body2, float DT)
    {
        if (body1->ColType == body2->ColType)
        {
            switch (body1->ColType)
            {
                case 1:
                {
                    Movement(DT, body1);
                    Movement(DT, body2);
                }
                case 2:
                {
                    if (body1->Collided)
                    {
                        if (body1->ColType == 2 && body2->ColType == 2)
                        {
                            if (body1->Mass <= body2->Mass)
                            {
                                body2->SumB(body1);
                                DelFromRander(GetNumFromRender(body1));
                            }
                            if (GetNumFromRender(body1) > GetNumFromRender(body2))
                            {
                                //i--;
                            }
                        }
                    }
                    default:
                    {
                        Movement(DT, body1);
                        Movement(DT, body2);
                    }
                }
            }
        }
    }
};

#include <SFML/Graphics.hpp>;
#include <iostream>;
#include <string>;
#include <random>;
#include <math.h>;
#include <time.h>;
#include <stdio.h>;
#include <stdlib.h>; 
 
#include "Pragmas.cpp";
 
using namespace sf;
using namespace std;
 
ContextSettings settings;
 
int main()
{
    setlocale(LC_ALL, "Russian");
    cout << "SPACEv0.8.9" << endl << endl;
    cout << "*ВАЖНО*" << endl << endl;
    cout << "Для корректной работы программы переключите раскладку на английскую." << endl;
    cout << "После появления окна кликнете по нему, чтоб сфокусироваться на нём." << endl << endl;
    cout << "*УПРАВЛЕНИЕ*" << endl << "(Все буквы английские)" << endl << endl;
    cout << "P: Пауза" << endl;
    cout << "R: Остановить тела" << endl;
    cout << "G: Включить/выключить гравитацию" << endl;
    cout << "V: Включить/выключить вектора" << endl;
    cout << "S: Просчёт одной единицы времени" << endl;
    cout << "+/-: Увеличить/уменьшить скорость симуляции" << endl;
    cout << "ПКМ: Включить/выключить гравитацию курсора" << endl;
    cout << "СКМ: Приблизить/отдалить камеру" << endl << endl;
    float T = 1;
    if (T < 0.125f)
    {
        T = 0.125f;
    }
    Object Objects[100];
    PHYSICS World1(T);
    Game GUI(T, &Objects);
    World1.Settings.SetUp(false, false, false, true);
    World1.Settings.SetBorders(-100, 1124, -100, 868);
    //World1.Settings.SetBorders(256, 768, 192, 576);
    //VARS-----------------------------------------------------------
      //SFML:
        Clock clock;
        int X = (float)GUI.window.getSize().x;
        int Y = (float)GUI.window.getSize().y;
      //Other:
        int Time = 0;
        //bool Timer = false;
    //VARS-----------------------------------------------------------
    for (int i = 0; i < 100; i++)
    {
        srand(time(NULL)*rand());
        Objects[i].SetPosition(rand() % X, rand() % Y, false);
        World1.AddToRander(&Objects[i].body);
        GUI.AddToGRander(&Objects[i]);
    }
    GUI.MainLoop(&World1);
}

#pragma once
#include <SFML/Graphics.hpp>;
#include <SFML/OpenGL.hpp>;
#include <SFML/Audio.hpp>;
#include <iostream>;
#include <string>;
#include <random>;
#include <math.h>; 
 
#include "Physics.cpp";
 
using namespace sf;
using namespace std;
 
class Object
{
public:
    Body body;
    Vertex Vect[2];
    Object()
    {
        srand(time(NULL)*rand());
        body.SetBody({ 0.0, 0.0 }, (rand() % 10000) + 1000000000000, 50000000000, 2, true);
        /*if (Obj.body.Mass < 10 && Obj.GetRadius() < 5)
        {
            int Temp = Obj.body.Mass * 50 + Random(9000);
            int Temp2 = Temp / 1000;
        }*/
    }
    ~Object()
    {
 
    }
    CircleShape GetShape()
    {
        shape.setFillColor(Colour);
        return(shape);
    }
    void Resize(float DX, float DY)
    {
        Vector2f Scal;
        Scal.x = shape.getScale().x * DX;
        Scal.y = shape.getScale().y * DY;
        shape.setScale(Scal);
    }
    void SetScale(float X, float Y)
    {
        shape.setScale(Vector2f(X, Y));
    }
    void SetPosition(float x, float y, bool ShapeOnly)
    {
        if (!ShapeOnly)
        {
            body.X = x;
            body.Y = y;
        }
        shape.setPosition(x - body.R, y - body.R);
    }
    void SetRadius(float r, bool ShapeOnly)
    {
        if (!ShapeOnly)
        {
            body.R = r;
        }
        shape.setRadius(r);
    }
    void CalcVect()
    {
        Vector2f V = { body.X, body.Y };
        Vect[0] = Vertex(V);
        Vect[1] = Vertex(V + body.Velocity);
    }
private:
    CircleShape shape;
    Color Colour = Color::White;
};
 
class GameSettings
{
public:
    ContextSettings settings;
    Vector2f CameraPos = {0, 0};
    int SpawnMode;
    int CameraMoveR = 250;
    float Scale = 1;
    float Frames = 24;
    float Time = 1;
    int Interations = 1;
    bool Pause = true;
};
 
class Game
{
public:
    GameSettings Settings;
    RenderWindow window;
    Font font;
    Text Messages;
    Texture background;
    Sprite sprite;
    Music music;
    Body Cursor;
    bool Curs = true;
    Object (*Arr)[100];
    Game(float Time, Object (*Array)[100])
    {
        Arr = Array;
        Settings.Time = Time;
        Settings.Interations = Settings.Time * 10;
        cout << "Количество временных интераций: " << Settings.Interations << endl;
        float A;
        cout << "Введите массу курсора: ";
        cin >> A;
        Cursor.SetBody({ 0.0, 0.0 }, A, 1, false, false);
        Settings.settings.antialiasingLevel = 8;
        Settings.settings.depthBits = 24;
        Settings.settings.stencilBits = 8;
        Settings.settings.majorVersion = 3;
        Settings.settings.minorVersion = 0;
        window.create(VideoMode(1024, 768), "SPACE", Style::Default, Settings.settings);
        window.setFramerateLimit(Settings.Frames);
        font.loadFromFile("arial.ttf");
        Messages.setFont(font);
        Messages.setCharacterSize(24);
        Messages.setColor(Color::White);
        Messages.setStyle(Text::Bold);
        background.loadFromFile("space.png");
        background.setSmooth(true);
        sprite.setTexture(background);
        sprite.setTextureRect(IntRect(0, 0, 1280, 1024));
        music.openFromFile("music.ogg");
        music.setLoop(true);
        music.play();
        Settings.CameraPos.x = window.getSize().x / 2;
        Settings.CameraPos.y = window.getSize().y / 2;
    }
    ~Game()
    {
 
    }
    void MainLoop(PHYSICS *World1)
    {
        while (window.isOpen())
        {
            Event event;
            while (window.pollEvent(event))
            {
                switch (event.type)
                {
                    case Event::MouseButtonPressed:
                    {
                        /*if (event.mouseButton.button == Mouse::Left && N < 100)
                        {
                            cout << "12345" << endl;
                            srand(time(NULL)*rand());
                            Arr[N]->SetPosition(Mouse::getPosition().x, Mouse::getPosition().y);
                            World1->AddToRander(&Arr[N]->body);
                            AddToGRander(Arr[N]);
                        }*/
                        if (event.mouseButton.button == Mouse::Right)
                        {
                            if (Curs)
                            {
                                World1->AddToRander(&Cursor);
                                Curs = false;
                                cout << "Гравитация курсора включена" << endl;
                            }
                            else
                            {
                                World1->DelFromRander(World1->GetNumFromRender(&Cursor));
                                Curs = true;
                                cout << "Гравитация курсора выключена" << endl;
                            }
                        }
                        if (event.mouseButton.button == Mouse::Left)
                        {
 
                        }
                        break;
                    }
                    case Event::MouseWheelMoved:
                    {
                        if (event.mouseWheel.delta < 0)
                        {
                            Settings.Scale = Settings.Scale / 1.2f;
                        }
                        if (event.mouseWheel.delta > 0)
                        {
                            Settings.Scale = Settings.Scale * 1.2f;
                        }
                        break;
                    }
                    case Event::MouseMoved:
                    {
                        break;
                    }
                    case Event::Closed:
                    {
                        music.stop();
                        window.close();
                        exit(0); //Exit by user
                        break;
                    }
                    case Event::KeyPressed:
                    {
                        switch (event.key.code)
                        {
                            case Keyboard::Up:
                            {
                                Settings.CameraPos.y = Settings.CameraPos.y - 5 / Settings.Scale;
                                break;
                            }
                            case Keyboard::Down:
                            {
                                Settings.CameraPos.y = Settings.CameraPos.y + 5 / Settings.Scale;
                                break;
                            }
                            case Keyboard::Left:
                            {
                                Settings.CameraPos.x = Settings.CameraPos.x - 5 / Settings.Scale;
                                break;
                            }
                            case Keyboard::Right:
                            {
                                Settings.CameraPos.x = Settings.CameraPos.x + 5 / Settings.Scale;
                                break;
                            }
                            case Keyboard::R:
                            {
                                World1->StopObj();
                                break;
                            }
                            case Keyboard::G:
                            {
                                if (World1->Settings.Gravity)
                                {
                                    World1->Settings.Gravity = false;
                                }
                                else
                                {
                                    World1->Settings.Gravity = true;
                                }
                                break;
                            }
                            case Keyboard::F:
                            {
                                if (World1->Settings.Rubber)
                                {
                                    World1->Settings.Rubber = false;
                                }
                                else
                                {
                                    World1->Settings.Rubber = true;
                                }
                                break;
                            }
                            case Keyboard::V:
                            {
                                if (World1->Settings.Vectors)
                                {
                                    World1->Settings.Vectors = false;
                                }
                                else
                                {
                                    World1->Settings.Vectors = true;
                                }
                                break;
                            }
                            case Keyboard::P:
                            {
                                if (Settings.Pause)
                                {
                                    Settings.Pause = false;
                                }
                                else
                                {
                                    Settings.Pause = true;
                                }
                                break;
                            }
                            case Keyboard::S:
                            {
                                if (!Settings.Pause)
                                {
                                    Settings.Pause = true;
                                }
                                Cursor.X = (float)Mouse::getPosition(window).x;
                                Cursor.Y = (float)Mouse::getPosition(window).y;
                                World1->render(Settings.Interations, true, true, true);
                                GraphRender(&window, World1);
                                window.display();
                                break;
                            }
                            case Keyboard::Add:
                            {
                                if (Settings.Time / 2 > 0.4f)
                                {
                                    Settings.Time = Settings.Time / 4;
                                    World1->Settings.Time = 1 / Settings.Time;
                                    Settings.Interations = ceil(2 * Settings.Frames / Settings.Time);
                                }
                                /*else
                                {
                                    Settings.Time = Settings.Time / 4;
                                    World1->Settings.Time = 1 / Settings.Time;
                                    Settings.Interations = 1;
                                }*/
                                break;
                            }
                            case Keyboard::Subtract:
                            {
                                if (Settings.Time >= 0.4f)
                                {
                                    Settings.Time = Settings.Time * 4;
                                    World1->Settings.Time = 1 / Settings.Time;
                                    Settings.Interations = ceil(2 * Settings.Frames / Settings.Time);
                                }
                                /*else
                                {
                                    Settings.Time = Settings.Time * 4;
                                    World1->Settings.Time = 1 / Settings.Time;
                                    Settings.Interations = 1;
                                }*/
                                break;
                            }
                            default:
                            {
                                break;
                            }
                        }
                        break;
                    }
                    case Event::Resized:
                    {
                        window.setSize(sf::Vector2u(1024, 768));
                        break;
                    }
                    default:
                    {
                        break;
                    }
                }
            }
            if (sqrt(pow(float(window.getSize().x) / 2 - float(Mouse::getPosition(window).x), 2)
                + pow(float(window.getSize().y / 2) - float(Mouse::getPosition(window).y), 2))
                > float(window.getSize().y) / 2 - Settings.CameraMoveR)
            {
                float Vel = -5.0f / Settings.Scale * sqrt(pow(float(window.getSize().x) / 2 - Mouse::getPosition(window).x, 2)
                    + pow(float(window.getSize().y) / 2 - Mouse::getPosition(window).y, 2)) / 400;
                float DelX = (Vel / sqrt(pow(float(window.getSize().x) / 2 - Mouse::getPosition(window).x, 2)
                    + pow(float(window.getSize().y) / 2 - Mouse::getPosition(window).y, 2)))
                    *(float(window.getSize().x) / 2 - Mouse::getPosition(window).x);
                float DelY = (Vel / sqrt(pow(float(window.getSize().x) / 2 - Mouse::getPosition(window).x, 2)
                    + pow(float(window.getSize().y) / 2 - Mouse::getPosition(window).y, 2)))
                    *(float(window.getSize().y) / 2 - Mouse::getPosition(window).y);
                Settings.CameraPos.x = Settings.CameraPos.x + DelX;
                Settings.CameraPos.y = Settings.CameraPos.y + DelY;
            }
            window.clear(Color::Black);
            sprite.setPosition((float)((1024.0f - Mouse::getPosition(window).x) / 20 - 128),
                (float)((0.0f - (Mouse::getPosition(window).y) / 20 - 128)));
            //window.draw(sprite);
            Messages.setPosition(0, 0);
            if (Settings.Pause)
            {
                Messages.setString(L"Нажмите [P] чтоб продолжть");
            }
            else
            {
                Messages.setString(L"Нажмите [P] для паузы");
                Cursor.X = (float)Mouse::getPosition(window).x;
                Cursor.Y = (float)Mouse::getPosition(window).y;
                World1->render(Settings.Interations, true, true, true);
            }
            window.draw(Messages);
            GraphRender(&window, World1);
            window.display();
        }
    }
    void AddToGRander(Object *Str)
    {
        if (N < 100)
        {
            Objects[N] = Str;
            N++;
        }
    }
    void DelFromGRander(int i)
    {
        while (i != N)
        {
            Objects[i] = Objects[i + 1];
            i++;
        }
        N--;
    }
    Object *GetFromGRender(int N1)
    {
        return(Objects[N1]);
    }
private:
    int N = 0;
    Object *Objects[100];
    void GraphRender(RenderWindow *window, PHYSICS *World1)
    {
        for (int i = 0; i < N; i++)
        {
            if (Objects[i]->body.R < 0)
            {
                Objects[i]->~Object();
                DelFromGRander(i);
                i--;
                continue;
            }
            Objects[i]->SetRadius(Objects[i]->body.R, true);
            Objects[i]->SetScale(Settings.Scale, Settings.Scale);
            Objects[i]->SetPosition(Settings.Scale * (Objects[i]->body.X - Settings.CameraPos.x) + (window->getSize().x / 2),
                (Settings.Scale * (Objects[i]->body.Y - Settings.CameraPos.y) + (window->getSize().y / 2)), true);
            window->draw(Objects[i]->GetShape());
            if (World1->Settings.Vectors)
            {
                Objects[i]->CalcVect();
                window->draw(Objects[i]->Vect, 2, Lines);
            }
        }
    }
};

#pragma comment(lib, "sfml-graphics")
#pragma comment(lib, "sfml-graphics-d")
#pragma comment(lib, "sfml-graphics-s")
#pragma comment(lib, "sfml-graphics-s-d")
#pragma comment(lib, "sfml-audio")
#pragma comment(lib, "sfml-audio-d")
#pragma comment(lib, "sfml-audio-s")
#pragma comment(lib, "sfml-audio-s-d")
#pragma comment(lib, "sfml-main")
#pragma comment(lib, "sfml-main-d")
#pragma comment(lib, "sfml-network")
#pragma comment(lib, "sfml-network-d")
#pragma comment(lib, "sfml-network-s")
#pragma comment(lib, "sfml-network-s-d")
#pragma comment(lib, "sfml-system")
#pragma comment(lib, "sfml-system-d")
#pragma comment(lib, "sfml-system-s")
#pragma comment(lib, "sfml-system-s-d")
#pragma comment(lib, "sfml-window")
#pragma comment(lib, "sfml-window-d")
#pragma comment(lib, "sfml-window-s")
#pragma comment(lib, "sfml-window-s-d")
#pragma comment(lib, "box2d")
 
#include "Physics.cpp";
#include "GUI.cpp";