main.cpp

#include <SFML/Graphics.hpp>
#include <math.h>
#include "world.h"
#include "corpuscle.h"
#include "planetoid.h"
#include "camera.h"
#include <iostream>

sf::VertexArray* getDashed(std::vector<Object*> *objects, float mass, sf::Vector2f pos, sf::Vector2f vel, float dt, int count = 1000) {
    sf::VertexArray* dashedLine = new sf::VertexArray(sf::PrimitiveType::Points, 0);
    sf::Vector2f F;
    for (int i = 0; i < count; i++) {
        (*dashedLine).append(sf::Vertex());
        (*dashedLine)[i].position = pos;
        //(*dashedLine).append(sf::Vertex());
        //(*dashedLine)[i + 1].position = pos + (vel * dt / 2.f);
        F = {0.f, 0.f};
        for (auto i_objects{objects->begin()}; i_objects != objects->end(); i_objects++) {
            if ((*i_objects)->getPos() == pos) {
                continue;
            }
            if (((*i_objects)->getPos() - pos).length() <= (*i_objects)->getR()) {
                return dashedLine;
            }
            F += ((*i_objects)->getPos() - pos).normalized() * mass * (*i_objects)->getMass() / ((*i_objects)->getPos() - pos).lengthSquared() * 1000.f;
        }
        vel += F / mass * dt;
        pos += vel * dt;
    }
    return dashedLine;
}

sf::VertexArray* getDashed(std::vector<Object*> *objects, Object* obj, float dt, int count = 1000) {
    sf::VertexArray* dashedLine = new sf::VertexArray(sf::PrimitiveType::Points, 0);
    sf::Vector2f F;
    sf::Vector2f pos = obj->getPos(), vel = obj->getVel();
    float mass = obj->getMass();
    for (int i = 0; i < count; i++) {
        (*dashedLine).append(sf::Vertex());
        (*dashedLine)[i].position = pos;
        //(*dashedLine).append(sf::Vertex());
        //(*dashedLine)[i + 1].position = pos + (vel * dt / 2.f);
        F = {0.f, 0.f};
        for (auto i_objects{objects->begin()}; i_objects != objects->end(); i_objects++) {
            if ((*i_objects) == obj) {
                continue;
            }
            if (((*i_objects)->getPos() - pos).length() <= (*i_objects)->getR()) {
                return dashedLine;
            }
            F += ((*i_objects)->getPos() - pos).normalized() * mass * (*i_objects)->getMass() / ((*i_objects)->getPos() - pos).lengthSquared() * 1000.f;
        }
        vel += F / mass * dt;
        pos += vel * dt;
    }
    return dashedLine;
}

int main() {
    std::srand(std::time({}));
    sf::RenderWindow* window = new sf::RenderWindow(sf::VideoMode::getFullscreenModes()[0], "Space");
    window->setVerticalSyncEnabled(true);
    //window->setFramerateLimit(10);
    window->setKeyRepeatEnabled(true);
    //window->setMouseCursorVisible(false);

    sf::Time dt;
    Camera camera{{0.f, 0.f}, sf::Vector2f(window->getSize())};
    World world{&camera};
    sf::Vector2f vel = {0.f, 0.f};
    bool inputingVel = false, changingPlanet = false, pause = false;
    float creatingMass = 1000.f;
    long double dtsumm = 0;
    long long frames = 1;
    sf::RectangleShape center{{5.f, 5.f}};
    center.setFillColor(sf::Color::White);

    //for (int i = 0; i < 800; i++) {
        //world.addObject(new Corpuscle({float(rand() % 4000), float(rand() % 4000)}, {float(rand() % 4001) - 2000, float(rand() % 4001) - 2000}));
    //}

    sf::Clock clock;

    while (window->isOpen()) {
        while (const std::optional event = window->pollEvent()) {
            if (event->is<sf::Event::Closed>()) {
                window->close();
            } else if(const auto* mouseButtonPressed = event->getIf<sf::Event::MouseButtonPressed>()) {
                if (mouseButtonPressed->button == sf::Mouse::Button::Left) {
                    sf::Vector2f mousePos = camera.localToWorld(sf::Vector2f(mouseButtonPressed->position));
                    bool onPlanet = false;
                    for (auto i_objects{world.getObjects()->begin()}; i_objects != world.getObjects()->end(); i_objects++) {
                        if ((mousePos - (*i_objects)->getPos()).length() <= (*i_objects)->getR()) {
                            onPlanet = true;
                            if (camera.isTracking()) {
                                if (camera.getTracker() == *i_objects) {
                                    camera.resetTracked();
                                } else if (changingPlanet) {
                                    camera.setTracked(*i_objects);
                                }
                            } else if (changingPlanet) {
                                camera.setTracked(*i_objects);
                            }
                        }
                    }
                    if (!changingPlanet || !onPlanet) {
                        world.addObject(new Planetoid(pow(creatingMass / M_PI, 0.5f), creatingMass, mousePos, vel));
                    }
                } else if (mouseButtonPressed->button == sf::Mouse::Button::Middle) {
                    camera.setHook(sf::Vector2f(mouseButtonPressed->position));
                } else if (mouseButtonPressed->button == sf::Mouse::Button::Right) {
                    vel = sf::Vector2f(mouseButtonPressed->position);
                    inputingVel = true;
                }
            } else if(const auto* mouseWheelScrolled = event->getIf<sf::Event::MouseWheelScrolled>()) {
                if (changingPlanet) {
                    creatingMass *= 1.f + mouseWheelScrolled->delta * 0.1f;
                } else {
                    camera.setScale(camera.getScale() * (1.f + mouseWheelScrolled->delta * 0.1f));
                }
            } else if(const auto* mouseButtonReleased = event->getIf<sf::Event::MouseButtonReleased>()) {
                if (mouseButtonReleased->button == sf::Mouse::Button::Middle) {
                    camera.resetHook();
                } else if (mouseButtonReleased->button == sf::Mouse::Button::Right) {
                    vel = vel - sf::Vector2f(mouseButtonReleased->position);
                    inputingVel = false;
                }
            } else if(const auto* keyPressed = event->getIf<sf::Event::KeyPressed>()) {
                if (keyPressed->code == sf::Keyboard::Key::C) {
                    world.getObjects()->clear();
                } else if (keyPressed->code == sf::Keyboard::Key::LAlt) {
                    changingPlanet = true;
                } else if (keyPressed->code == sf::Keyboard::Key::Space) {
                    pause = !pause;
                }
            } else if(const auto* keyReleased = event->getIf<sf::Event::KeyReleased>()) {
                if (keyReleased->code == sf::Keyboard::Key::LAlt) {
                    changingPlanet = false;
                }
            }
        }
        window->clear(sf::Color::Black);

        if (sf::Mouse::isButtonPressed(sf::Mouse::Button::Left)) {
            // world.addObject(new Planetoid(pow(creatingMass / M_PI, 0.5f), creatingMass, camera.localToWorld(sf::Vector2f(sf::Mouse::getPosition(*window))), vel));
        }

        dt = clock.restart();
        if (!pause) {
            world.process(dt);
        }

        if (inputingVel) {
            sf::VertexArray vec(sf::PrimitiveType::Lines, 2);
            vec[0].position = sf::Vector2f(sf::Mouse::getPosition(*window));
            vec[1].position = vel;
            window->draw(vec);
        } else {
            sf::VertexArray vec(sf::PrimitiveType::Lines, 2);
            vec[0].position = sf::Vector2f(sf::Mouse::getPosition(*window));
            vec[1].position = sf::Vector2f(sf::Mouse::getPosition(*window)) + vel;
            window->draw(vec);
        }
        if (changingPlanet) {
            bool flag = true;
            sf::VertexArray* dashedLine;
            sf::Vector2f mousePos = camera.localToWorld(sf::Vector2f(sf::Mouse::getPosition(*window)));
            for (auto i_objects{world.getObjects()->begin()}; i_objects != world.getObjects()->end(); i_objects++) {
                if ((mousePos - (*i_objects)->getPos()).length() <= (*i_objects)->getR()) {
                    dashedLine = getDashed(world.getObjects(), *i_objects, dtsumm / frames);
                    flag = false;
                    break;
                }
            }
            if (flag) {
                sf::CircleShape planet{0.f};
                float r = pow(creatingMass / M_PI, 0.5f);
                planet.setRadius(r);
                planet.setFillColor(sf::Color(255, 255, 255, 168));
                planet.setPosition(mousePos - sf::Vector2f{r, r});
                camera.draw(&planet, *window);
                if (inputingVel) {
                    dashedLine = getDashed(world.getObjects(), creatingMass, mousePos, vel  - sf::Vector2f(sf::Vector2f(sf::Mouse::getPosition(*window))), dtsumm / frames);
                } else {
                    dashedLine = getDashed(world.getObjects(), creatingMass, mousePos, vel, dtsumm / frames);
                }
            }
            //std::cout << (*dashedLine)[3].position.x << std::endl;
            camera.draw(dashedLine, *window);
            delete dashedLine;
        }
        sf::Vector2f vecSum{0.f, 0.f};
        float massSum = 0.f;
        for (auto i_objects{world.getObjects()->begin()}; i_objects != world.getObjects()->end(); i_objects++) {
            vecSum += (*i_objects)->getPos() * (*i_objects)->getMass();
            massSum += (*i_objects)->getMass();
        }
        if (float(world.getObjects()->size()) * massSum != 0){
            center.setPosition(vecSum / (float(world.getObjects()->size()) * (massSum / float(world.getObjects()->size()))) - sf::Vector2f{5.f, 5.f});
        }

        camera.update(sf::Vector2f(sf::Mouse::getPosition(*window)));
        camera.render(world.getObjects(), *window);

        camera.draw(&center, *window);
        window->display();
        dtsumm += dt.asSeconds();
        frames += 1;
    }
    window->close();
    delete window;

    return 0;
}