//main.cpp #include "gameManager.h" /*cmake -G "MinGW Makefiles" ..*/ int main() { GameManager g

//main.cpp
#include "gameManager.h"
/*cmake -G "MinGW Makefiles" ..*/
int main() {
    GameManager gameManager;
    if (!gameManager.initialize()) {
        return 1;
    }

    sf::RenderWindow& window = gameManager.getWindow();

    while (window.isOpen()) {
        while (const std::optional event = window.pollEvent()) {
            if (event->is<sf::Event::Closed>()) {
                window.close();
            }
        }
        window.clear();
        gameManager.updateWorld(window);
        window.display();
    }
    return 0;
}
//entityImplementation.cpp
#include <SFML/Graphics.hpp>
#include "entity.h"

    Entity::Entity(sf::Texture &texture,sf::Vector2f position):sprite(texture){
        sprite.setPosition(position);
    }
    void Entity::setPos(sf::Vector2f position){
        sprite.setPosition(position);
    }
    sf::Vector2f Entity::getPos(){
        return sprite.getPosition();
    }
    void Entity::setTexture(sf::Texture& texture){
        sprite.setTexture(texture);
    }
    void Entity::draw(sf::RenderWindow& window) {
        window.draw(this->sprite);
    }
     Entity::~Entity(){
     };
//entityManager.cpp
#include <string>
#include "entity.h"
#include <SFML/Graphics.hpp>
#include "entityManager.h"
#include <memory>
#include <exception>
#include "player.h"

sf::Texture* EntityManager::loadTexture(std::string path) {
        auto it = textureMap.find(path);
        if (it != textureMap.end()) {
            return &it->second;
        } else {
            sf::Texture newTexture;
            if (newTexture.loadFromFile(path)) {
                textureMap[path] = newTexture;
                return &textureMap[path];
            } else {
                throw std::runtime_error("Error loading texture: "+ path);
            }
        }
    }
    std::unique_ptr<Entity> EntityManager::entityFactory(std::string entityType,std::string path,sf::Vector2f position){
        sf::Texture* texture = loadTexture(path);
        if (entityType == "Player"){
            return std::make_unique<Player>(*texture,position);
        }
        throw std::runtime_error("Error loading texture: " + path + " of type: " + entityType);
    }
//gameManager.cpp
#include "gameManager.h"
#include <iostream>
#include <stdexcept>

GameManager::GameManager() : initialization_failed(false), window(sf::VideoMode({1920u, 1080u}), "Game") {}

GameManager::~GameManager() {}

bool GameManager::initialize() {
    try {
        player = entityManager.entityFactory("Player", "build/assets/texture/cube.png", sf::Vector2f(250, 250));
        if (player) {
            world = World(std::move(player));
        } else {
            std::cerr << "Error: entityFactory returned null!" << std::endl;
            initialization_failed = true;
        }
    } catch (const std::runtime_error& error) {
        std::cerr << "Error creating game object: " << error.what() << std::endl;
        initialization_failed = true;
    }
    if (initialization_failed) {
        std::cerr << "Game initialization failed. Exiting." << std::endl;
        return false;
    }
    window.setFramerateLimit(144);
    return true;
}

sf::RenderWindow& GameManager::getWindow() {
    return window;
}

void GameManager::updateWorld(sf::RenderWindow& window) {
    world.update(window);
}

void GameManager::runGameLoop() {
    while (window.isOpen()) {
        while (const std::optional event = window.pollEvent()) {
            if (event->is<sf::Event::Closed>()) {
                window.close();
            }
        }
        window.clear();
        updateWorld(window);
        window.display();
    }
}
//player.cpp
#include "entity.h"
#include "player.h"
#include <SFML/Graphics.hpp>

Player::Player(sf::Texture& texture, sf::Vector2f position) : Entity(texture, position){
}
//world.cpp
#include "world.h"
#include "player.h"

World::World(std::unique_ptr<Entity> player):player(std::move(player)){
}

World::World() : player(nullptr) {}

Entity* World::getPlayer() const {
    return player.get();
}

void World::update(sf::RenderWindow& window){
    player->draw(window);

}