AsloEngine/asloengine/scene.cpp

#include "headers/scene.hpp"

namespace asloengine
{

    Scene::Scene(std::string _name)
        : name(_name) {}

    void Scene::draw()
    {

        sf::View default_view = scene_window->getView();
        sf::View view = default_view;
        
        view.reset(camera_2d_rect);
        scene_window->setView(view);

        for (const Layer& objects : layers)
        {
            for (GameObject *const& object : objects)
            {
                object->draw();
            }
        }

        scene_window->setView(default_view);

        for (const Layer& objects : fixed_layers)
        {
            for (GameObject *const& object : objects)
            {
                object->draw();
            }
        }

    }

    void Scene::load()
    {

        on_load();
        
        LOG("Scene '" + name + "' has been Loaded");

    }

    void Scene::update(float delta_time)
    {

        on_update(delta_time);

        sf::View default_view = scene_window->getView();
        sf::View view = default_view;
        
        view.reset(sf::FloatRect(camera_2d_rect));
        scene_window->setView(view);

        for (const Layer& objects : layers)
        {
            for (GameObject *const& object : objects)
            {
                object->update(delta_time);
                if (!object->alive)
                {
                    needs_clean = true;
                }
            }
        }

        scene_window->setView(default_view);
        
        for (const Layer& objects : fixed_layers)
        {
            for (GameObject *const& object : objects)
            {
                object->update(delta_time);
                if (!object->alive)
                {
                    needs_clean = true;
                }
            }
        }

        if (needs_clean)
        {
            clean();
        }

        on_post_update(delta_time);

    }

    void Scene::clean()
    {
        
        for (int i = 0; i < layers.size(); i++)
        {
            for (int j = 0; j < layers[i].size(); i++)
            {
                if (!layers[i][j]->alive)
                {
                    layers[i].erase(layers[i].begin() + j);
                    j--;
                }
            }
        }
        
        for (int i = 0; i < fixed_layers.size(); i++)
        {
            for (int j = 0; j < fixed_layers[i].size(); i++)
            {
                if (!fixed_layers[i][j]->alive)
                {
                    fixed_layers[i].erase(fixed_layers[i].begin() + j);
                    j--;
                }
            }
        }

        needs_clean = false;

    }

    void Scene::start(sf::RenderWindow *window)
    {

        scene_window = window;

        camera_2d_rect = sf::FloatRect(0, 0, scene_window->getSize().x, scene_window->getSize().y);

        for (const Layer& objects : layers)
        {
            for (GameObject *const& object : objects)
            {
                object->start(window);
            }
        }

        for (const Layer& objects : fixed_layers)
        {
            for (GameObject *const& object : objects)
            {
                object->start(window);
            }
        }

        LOG("Scene '" + name + "' has been Started");

    }

    void Scene::destroy()
    {

        on_destroy();
        
        for (const Layer& objects : layers)
        {
            for (GameObject *const& object : objects)
            {
                object->destroy();
            }
        }
        
        for (const Layer& objects : fixed_layers)
        {
            for (GameObject *const& object : objects)
            {
                object->destroy();
            }
        }

        LOG("Scene '" + name + "' has been Destroyed");

    }

    void Scene::move_camera(sf::Vector2f _move)
    {

        camera_2d_rect.left += _move.x;
        camera_2d_rect.top += _move.y;

    }
    
    void Scene::on_load() {}

    void Scene::on_update(float delta_time) {}

    void Scene::on_post_update(float delta_time) {}

    void Scene::on_destroy() {}

}