Destroyable

sdlpp.hpp

@@ -3,10 +3,12 @@
 
 #include <SDL2/SDL.h>
 #include <SDL2/SDL_image.h>
+#include <algorithm>
 #include <cmath>
 #include <iostream>
 #include <limits>
 #include <memory>
+#include <mutex>
 #include <vector>
 
 namespace SDLPP {
@@ -157,6 +159,8 @@ protected:
     bool infinite = false;
 };
 
+class Scene;
+
 class RenderObject {
 public:
     RenderObject(std::shared_ptr<Renderer> &r) : renderer(r) {}
@@ -170,6 +174,7 @@ public:
     virtual int collisionPushY() = 0;
     virtual int collisionWidth() = 0;
     virtual int collisionHeight() = 0;
+    virtual void specialAction(int code) = 0;
     virtual std::pair<std::pair<double,double>,std::pair<double,double>> getDoubleRect() = 0;
     virtual void setPos(double x, double y) = 0;
     bool colidesWith(const RenderObject &other) const {
@@ -230,6 +235,13 @@ public:
     bool getHidden() const {
         return hidden;
     }
+    void destroy() {
+        setHidden(true);
+        kill = true;
+    }
+    bool getKilled() {
+        return kill;
+    }
     void setColiderColor(const std::string &color) {
         colider_color = getColorsHEX(color);
     }
@@ -245,7 +257,14 @@ protected:
     std::vector<std::shared_ptr<RenderObject>> colidedWith;
     uint64_t id;
     bool hidden = false;
+    bool kill = false;
     std::tuple<int,int,int> colider_color = {0x00, 0xFF, 0xFF};
+    uint64_t scene_id;
+private:
+    void setSceneID(int id) {
+        scene_id = id;
+    }
+    friend Scene;
 };
 
 class Scene {
@@ -255,7 +274,9 @@ public:
         prev_ticks = SDL_GetTicks();
     }
     void addObject(const std::shared_ptr<RenderObject> &obj) {
+        render_mutex.lock();
         renderObjects.push_back(obj);
+        obj->setSceneID(++max_object_id);
         if(obj->hasCollisions()) {
             collisionObjects.push_back(obj);
         }
@@ -272,16 +293,20 @@ public:
             if(rect.first.first + rect.second.first > rightmost_rect.first.first + rightmost_rect.second.first)
                 rightmost_obj = obj;
         }
+        render_mutex.unlock();
     }
     std::shared_ptr<RenderObject> getObject(int index) {
         return renderObjects[index];
     }
     void movement() {
+        checkKilled();
+        render_mutex.lock();
         int now_ticks = SDL_GetTicks();
         for( const auto &x : renderObjects ) {
             x->move(now_ticks - prev_ticks);
         }
         prev_ticks = now_ticks;
+        render_mutex.unlock();
     }
     std::vector<std::shared_ptr<RenderObject>> getCollisions(RenderObject &r) {
         if(r.getHidden())
@@ -295,11 +320,14 @@ public:
         return ret;
     }
     void renderScene() {
+        checkKilled();
+        render_mutex.lock();
         SDL_RenderClear(renderer->getRendererPtr());
         SDL_RenderCopy(renderer->getRendererPtr(), background->getTexturePtr(), NULL, NULL);
         for( const auto &x : renderObjects ) {
             x->render();
         }
+        render_mutex.unlock();
     }
     void presentScene() {
         SDL_RenderPresent(renderer->getRendererPtr());
@@ -311,18 +339,24 @@ public:
         background = std::make_shared<Texture>(renderer, img_path);
     }
     void updateSizeAndPosition() {
+        checkKilled();
+        render_mutex.lock();
         for( auto &x : renderObjects ) {
             x->updateSizeAndPosition();
             for( auto &col : x->getCollisions() ) {
                 col->updateCollision(x->collisionPushX(), x->collisionPushY(), x->collisionWidth(), x->collisionHeight());
             }
         }
+        render_mutex.unlock();
     }
     void moveEverything(double x, double y) {
+        checkKilled();
+        render_mutex.lock();
         for( auto &obj : renderObjects ) {
             auto curPos = obj->getDoubleRect();
             obj->setPos( curPos.first.first + x, curPos.first.second + y );
         }
+        render_mutex.unlock();
     }
     const std::shared_ptr<RenderObject> &leftmost() {
         return leftmost_obj;
@@ -346,6 +380,20 @@ public:
         prev_ticks = ticks;
     }
 private:
+    void checkKilled() {
+        render_mutex.lock();
+        std::vector<int> killed;
+        for( long unsigned int i = 0; i < renderObjects.size(); i++ ) {
+            if(renderObjects[i]->getKilled())
+                killed.push_back(i);
+        }
+        std::reverse(killed.begin(), killed.end());
+        for(auto &index : killed) {
+            renderObjects.erase(renderObjects.begin() + index);
+        }
+        render_mutex.unlock();
+    }
+
     std::vector<std::shared_ptr<RenderObject>> renderObjects;
     std::vector<std::shared_ptr<RenderObject>> collisionObjects;
     std::shared_ptr<Renderer> renderer;
@@ -353,6 +401,8 @@ private:
     int prev_ticks = 0;
     std::shared_ptr<RenderObject> leftmost_obj;
     std::shared_ptr<RenderObject> rightmost_obj;
+    uint64_t max_object_id = 0;
+    std::mutex render_mutex;
 };
 
 class RectangleRender : public RenderObject {
@@ -377,6 +427,7 @@ public:
         auto texture = std::make_shared<Texture>(r, img_path);
         setTexture(texture);
     }
+    virtual void specialAction(int /*UNUSED*/) {};
     virtual void render() {
         if(texture != NULL && !getHidden())
             SDL_RenderCopy(renderer->getRendererPtr(), texture->getTexturePtr(), NULL, &rect);