Пул объектов

#pragma once
 
#include "Sprite2.h"
class Entity 
{
public:
    Sprite2 sprite;
    RenderTarget* target;
    bool active;
    Entity()
    {
        active = false;
    }
 
    void setTarget( RenderTarget* target)
    {
        this->target = target;
        
    }
    void setTexture(Texture* texture)
    {
        sprite.getTexture() = *texture;
    }
 
    void setPos(float x, float y)
    {
        sprite.sprite.setPosition(x, y);
    }
 
    void setActive(bool active)
    {
        this->active = active;
            
    }
 
    virtual void render(RenderTarget* target)
    {
        if (active)
            sprite.render(target);
    }
};

#pragma once
 
#include "PoolObject.h"
#include <assert.h>
#include <iostream>
#include <list>
class EntityPool
{
private:
    std::list<Entity*> resources;
 
    static EntityPool* instance;
    EntityPool() {}
 
public:
 
    static EntityPool* getInstance()
    {
        if (instance == 0)
        {
            instance = new EntityPool;
        }
        return instance;
    }
 
    Entity* getResource()
    {
        if (resources.empty())
        {
            std::cout << "Creating new." << std::endl;
            return new Entity;
        }
        else
        {
            std::cout << "Reusing existing." << std::endl;
            Entity* entity = resources.front();
            resources.pop_front();
            return entity;
        }
    }
 
    void returnResource(Entity* object)
    {
        object->setActive(false);
        resources.push_back(object);
    }
};

lvl1()
{
buttonTexture.loadFromFile("textures/Untitled.png");
o1 = pool->getResource();
    o1->setTexture(&buttonTexture);
}
update(const float& deltatime)
{
if (Mouse::isButtonPressed(Mouse::Left))
    {
        o1->setActive(true);
        o1->setPos(Mouse::getPosition().x, Mouse::getPosition().y);
    }
    if (o1->active)
    {
        o1->setPos(o1->sprite.getPosition().x, o1->sprite.getPosition().y - 1 * deltatime);
    }
    //if (o1->sprite.getPosition().y >= windowSize.height / 2)
    if (Mouse::isButtonPressed(Mouse::Right))
    {
        o1->setActive(false);
        pool->returnResource(o1);
    }
}
render(RenderTarget* target)
{
o1->setTarget(target);
o1->render(target);
}

void lvl1::updateIcon(const float& dt)
{
    for (size_t i{}; i < m_bullets.size();)
    {
        if (m_bullets[i]->life_time < 0 )
        {
            std::swap(m_bullets[i], m_bullets.back());
            EntityPool::instance().destroy(m_bullets.back());
            m_bullets.pop_back();
        }
        else
        {
            m_bullets[i]->update(dt);
            ++i;
        }
    }
}
void lvl1::shoot(sf::Vector2f target)
{
    const auto pos = bullet_sprite.getPosition();
    target -= pos;
    target /= std::hypot(target.x, target.y);
    auto bull = EntityPool::instance().create(pos, target);
    if (bull) m_bullets.push_back(bull);
}
void lvl1::update(const float& deltatime)
{
    updateIcon(deltatime);
        if (Mouse::isButtonPressed(Mouse::Left))
        {
            bullet_sprite.setPosition(mousePosView);
            std::cout << "a";
            shoot(Vector2f(bullet_sprite.getPosition().x, windowSize.height));
 
        }
}
void lvl1::render(RenderTarget* target, RenderStates* states)
{
auto st = *states;
    for (auto bull : m_bullets)
    {
        st.transform = states->transform;
        st.transform.translate(bull->m_pos);
        target->draw(bullet_sprite);
    }
    states->transform *= bullet_sprite.getTransform();
 
}

class Entity 
{
    const sf::Vector2f nullVector = sf::Vector2f(0, 0);
    sf::Texture nullTexture;
    static constexpr float speed = 200.0f;
 
    sf::Vector2f position;
    sf::Vector2f direction;
    sf::Sprite sprite;
    bool active=false;
 
public:
    
 
    Entity() { active = true; }
 
    void setActive(bool act) { active = act; }
    void setTexture(sf::Texture* texture) { sprite.setTexture(*texture); }
    void setTextureRect(sf::IntRect intrect) { sprite.setTextureRect(intrect); }
    void setPosition(sf::Vector2f pos) { position = pos; }
    sf::Vector2f getPos() { return position; }
 
    void shoot(sf::Vector2f dir)
    {
        
        direction = dir;
        
    }
 
    void reset()
    {
        position = nullVector;
        direction = nullVector;
        sprite.setTexture(nullTexture);
        active = false;
    }
 
    void update(float dt)
    {
        
            position += direction * dt * speed;
            sprite.setPosition(position);
        
        
    }
 
    void render(RenderTarget* target)
    {
        if(active)
            target->draw(sprite);
    }
};

class EntityPool
{
    EntityPool(){}
    std::list<Entity*> entities;
    static EntityPool* instance;
public:
    
    static EntityPool* getInstance()
    {
        if (instance == 0)
        {
            instance = new EntityPool;
        }
        return instance;
    }
 
    Entity* create(Vector2f pos, Texture* tex, IntRect offset)
    {
        if (!entities.empty())
        {
            std::cout << "reusing";
            Entity* entity = entities.front();
            entity->setPosition(pos);
            entity->setTexture(tex);
            entity->setTextureRect(offset);
            entity->setActive(true);
            entities.pop_front();
            return entity;
        }
        else
        {
            std::cout << "new";
            Entity* ent = new Entity;
            ent->setPosition(pos);
            ent->setTexture(tex);
            ent->setTextureRect(offset);
            return ent;
        }
        
    }
 
    void returnObj(Entity* ent)
    {
        
        ent->reset();
        entities.push_back(ent);
    }
};

void lvl1::updateSomething(const float& deltatime)
{
    if (foodIcon.sprite.getColor() == Color(255, 255, 255, 255) && !foodMenu)
    {
        if (Mouse::isButtonPressed(sf::Mouse::Left))
        {
            Entity* tempEnt = pool->create(mousePosView, &buttonTexture, offsetX);
            std::cout << tempEnt << std::endl;
            objs.push_front(tempEnt);
            //p.setPosition(mousePosView);
            std::cout << "a";
            //p.shoot(Vector2f(p.getPosition().x, windowSize.height));
        }
    }
    for (auto i : objs)
    {
        //i->shoot(Vector2f(i->getPos().x, windowSize.height));
        i->shoot(Vector2f(0, 1));
        i->update(deltatime);
        //
        
        if (i->getPos().y >= windowSize.height/2)
        {
 
            pool->returnObj(i);
        }
    }
}

#include "lvl1.h"
EntityPool* EntityPool::instance = 0;
lvl1::lvl1(RenderWindow* window)
    : Scene(window)
{
    std::ifstream ifs("config.ini");
 
    if (ifs.is_open())
    {
        ifs >> windowSize.width >> windowSize.height;
    }
    ifs.close();
    menuRect.setPosition(0, 0);
    menuRect.setFillColor(Color(37, 197, 230));
    background.setPosition(0, menuRect.getSize().y);
    background.setFillColor(Color(255, 255, 255));
    foodI.setColor(Color::Black);
    foodI.setScale(0.4, 0.4);
    cirniS.setScale(1.4, 1.4);
    countText.setPos(15, 8);
    foodIcon.setScale(1, 1);
    foodIcon.setColorSimple(Color(255, 255, 255, 0));
 
    menu();
}
 
void lvl1::menu()
{
    fmriSize = Vector2f(windowSize.width / 1.23, windowSize.height / 1.23);
    foodMenuRectIn = RectangleShape(fmriSize);
    foodMenuRectIn.setPosition(windowSize.width / 13, windowSize.height / 9);
    foodMenuRectIn.setFillColor(Color(37, 197, 230));
 
    fmroSize = Vector2f(windowSize.width / 1.2, windowSize.height / 1.2);
    foodMenuRectOut = RectangleShape(fmroSize);
    foodMenuRectOut.setPosition(windowSize.width / 15, windowSize.height / 10);
    foodMenuRectOut.setFillColor(Color(28, 159, 186));
 
    buttonTexture.loadFromFile("textures/Untitled.png");
}
 
lvl1::~lvl1()
{
}
 
void lvl1::endScene()
{
    //saving
}
 
void lvl1::updateSomething(const float& deltatime)
{
    if (foodIcon.sprite.getColor() == Color(255, 255, 255, 255) && !foodMenu)
    {
        if (Mouse::isButtonPressed(sf::Mouse::Left))
        {
            Entity* tempEnt = pool->create(mousePosView, &buttonTexture, offsetX);
            std::cout << tempEnt << std::endl;
            objs.push_front(tempEnt);
            //p.setPosition(mousePosView);
            std::cout << "a";
            //p.shoot(Vector2f(p.getPosition().x, windowSize.height));
        }
    }
    for (auto i : objs)
    {
        //i->shoot(Vector2f(i->getPos().x, windowSize.height));
        i->shoot(Vector2f(0, 1));
        i->update(deltatime);
        //
        
        if (i->getPos().y >= windowSize.height/2)
        {
 
            pool->returnObj(i);
        }
    }
}
 
void lvl1::updateSfmlEvents(Event event)
{
    if (event.type == sf::Event::MouseButtonPressed)
    {
        if (cirniS.getRect().contains(Mouse::getPosition(*window)) && event.mouseButton.button == sf::Mouse::Left && !foodMenu)
        {
            countText.setString(std::to_string(count));
            count++;
        }
        if (foodI.getRect().contains(Mouse::getPosition(*window)) && event.mouseButton.button == sf::Mouse::Left)
        {
            foodMenu = !foodMenu;
        }
        
    }
}
void lvl1::updateInput(const float& deltatime)
{
    checkForQuit();
}
 
void lvl1::updateMenu()
{
    buttonsMesh.resize(6, std::vector<button>());
 
    if (foodMenu)
    {
        for (int x = 0; x < 6; x++)
        {
            buttonsMesh[x].resize(6, button());
            for (int y = 0; y < 6; y++)
            {
                buttonsMesh[x][y] = button(windowSize.width / 10 + x * gridSize, windowSize.width / 8 + y * gridSize, 440, 100, "some text", &buttonTexture, Color::White, Color::Yellow, Color::Green);
                buttonsMesh[x][y].buttonS.setTextureRect(IntRect(x * 40, 0, 40, 40));
                buttonsMesh[x][y].update(mousePosView);
                if (buttonsMesh[x][y].isPressed())
                {
                    offsetX = IntRect(x * 40, 0, 40, 40);
                    foodIcon.setColorSimple(Color(255, 255, 255, 255));
                    foodIcon.sprite.setTextureRect(offsetX);
                    
                }
            }
        }
    }
}
 
void lvl1::update(const float& deltatime)
{
    //p.update(deltatime);
    updateSomething(deltatime);
 
    updateInput(deltatime);
    updateMousePosition();
 
    updateMenu();
 
    //
}
 
void lvl1::render(RenderTarget* target, RenderStates* states)
{
    if (!target)
        target = window;
 
    target->draw(background);
    target->draw(menuRect);
    foodI.render(target);
    cirniS.render(target);
    countText.render(target);
    foodIcon.render(target);
    if (foodMenu)
    {
        target->draw(foodMenuRectOut);
        target->draw(foodMenuRectIn);
    }
    for (int x = 0; x < 6; x++)
    {
        for (int y = 0; y < 1; y++)
        {
            if (foodMenu)
            {
                buttonsMesh[x][y].render(target);
            }
            //target->draw(p);
            for (auto i : objs)
            {
                i->render(target);
            }
        }
    }
}