CoreHandlers-SDL2-Framework/GameObjectHandler.cpp at main · CodingPluto/CoreHandlers-SDL2-Framework · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
#include <iostream>
#include "GameObjectHandler.h"
#include "../gameData/GameObject.h"
#include "../utils/utils.h"
using namespace std;

GameObjectHandler::GameObjectHandler():Handler(hp_OnUpdate)
{
    debugName = "GameObject Handler";
    GameObject::linkGameObjects(game);
}
GameObjectHandler::~GameObjectHandler()
{
}
HandlerError* GameObjectHandler::tick()
{
    game->debugLog("Pending GameObjects: " + to_string(pendingGameObjects.size()));
    for (GameObject *gameObject : pendingGameObjects)
    {
        game->debugLog("Pending GameObject: " + gameObject->getDebugName() + " : " + addressToString(gameObject));
        gameObjects.emplace_back(gameObject);
    }

    game->debugLog("trying to remove " + to_string(pendingRemovalGameObjects.size()) + " GameObjects.");
    game->debugLog("There are currently " + to_string(gameObjects.size()) + " GameObjects.");
    if (pendingRemovalGameObjects.size() > 0)
    {
        for (int i = 0; i < gameObjects.size(); i++)
        {
            for (GameObject *pendingRemovalGameObject : pendingRemovalGameObjects)
            {
                if (gameObjects[i] == pendingRemovalGameObject)
                {
                    gameObjects.erase(gameObjects.begin() + i);
                    i--;
                }
            }
        }
    }

    if (pendingGameObjects.size() > 0 || pendingRemovalGameObjects.size() > 0)
    {
        reloadGameObjectPriorities();
    }
    pendingGameObjects.clear();
    pendingRemovalGameObjects.clear();
    game->debugLog("There are now " + to_string(gameObjects.size()) + " GameObjects.");
    game->debugLog("--- UPDATING gameObjects ---");
    for (GameObject *gameObject : gameObjects)
    {
        if (gameObject->getGameObjectStatus())
        {
            game->debugLog(gameObject->getDebugName() + " : " + addressToString(gameObject));
            gameObject->update();
        }
    }
    game->debugLog("--- UPDATING gameObjects ---");

    game->debugLog("--- DELETING gameObjectsToBeDeleted ---");
    for (GameObject *gameObject : gameObjectsToBeDeleted)
    {
        delete gameObject;
    }
    game->debugLog("--- DELETED gameObjectsToBeDeleted ---");
    gameObjectsToBeDeleted.clear();
    return nullptr;
}
bool GameObjectHandler::initalize()
{
    reloadGameObjectPriorities();
    return true;
}


void GameObjectHandler::addGameObject(GameObject *address)
{
    pendingGameObjects.emplace_back(address);
}
void GameObjectHandler::removeGameObject(GameObject *address)
{
    pendingRemovalGameObjects.emplace_back(address);
}


void GameObjectHandler::deleteAtFrameEnd(GameObject *address)
{
    gameObjectsToBeDeleted.emplace_back(address);
}


void GameObjectHandler::reloadGameObjectPriorities()
{
    /*
    if (game->getTickPoint() == hp_OnUpdate)
    {
        throw runtime_error("Can't reload GameObjects as updating!");
    }*/
    int previousUpdateOrder = numeric_limits<int>::max();
    int updateOrder;
    for (vector<GameObject*>::size_type i = 0; i < gameObjects.size(); ++i)
    {
        updateOrder = gameObjects[i]->getUpdateOrder();
        if (i > 0)
        {
            previousUpdateOrder = gameObjects[i - 1]->getUpdateOrder();
        }
        else
        {
            previousUpdateOrder = numeric_limits<int>::max();
        }
        while (updateOrder > previousUpdateOrder)
        {
            GameObject *movingObject = gameObjects[i];
            i --;
            GameObject *displacedObject = gameObjects[i];
            gameObjects[i] = movingObject;
            gameObjects[i + 1] = displacedObject;
            if (i > 0)
            {
                previousUpdateOrder = gameObjects[i - 1]->getUpdateOrder();
            }
            else
            {
                previousUpdateOrder = numeric_limits<int>::max();
            }
            updateOrder = gameObjects[i]->getUpdateOrder();
        }
    }
}