Fixes for singleplayer

Author: catastropher

CMakeLists.txt

@@ -2,24 +2,10 @@ cmake_minimum_required(VERSION 3.2 FATAL_ERROR)
 
 project(Engine VERSION 1 LANGUAGES C CXX)
 
-message(${CMAKE_TOOLCHAIN_FILE})
-
 if (UNIX AND NOT APPLE)
 	set(LINUX TRUE)
 endif()
 
-find_program(VCPKG_EXECUTABLE
-		vcpkg PATHS "${CMAKE_CURRENT_LIST_DIR}")
-if (NOT VCPKG_EXECUTABLE)
-	if (WIN32)
-		execute_process(COMMAND "${CMAKE_CURRENT_LIST_DIR}/bootstrap-vcpkg.bat"
-				WORKING_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}")
-	else ()
-		execute_process(COMMAND  "${CMAKE_CURRENT_LIST_DIR}/bootstrap-vcpkg.sh"
-				WORKING_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}")
-	endif ()
-endif ()
-
 # Enable exception unwind semantics
 if(MSVC)
 	add_compile_options("/EHsc")

src/CMakeLists.txt

@@ -183,6 +183,7 @@ target_include_directories(Strife.Engine
 
 find_package(Vorbis REQUIRED)
 find_package(Torch REQUIRED)
+find_package(robin_hood REQUIRED)
 
 target_link_libraries(Strife.Engine PUBLIC
     SDL2::SDL2
@@ -192,6 +193,7 @@ target_link_libraries(Strife.Engine PUBLIC
     OALWrapper
     SLikeNet
     Strife.ML
+	robin_hood
     )
 
 if(APPLE)

src/Memory/DLinkNode.hpp

@@ -1,60 +1,128 @@
 #pragma once
 
-template <typename TLink>
-struct DLinkNode
+template<typename T>
+struct DLinkedList;
+
+template<typename TElement>
+struct DLinkedNode
 {
-    DLinkNode()
-        : next(nullptr),
-          prev(nullptr)
+    TElement* GetElement() { return static_cast<TElement*>(this); }
+    TElement* GetElement() const { return static_cast<const TElement*>(this); }
+
+    void Unlink()
     {
+        if (owner != nullptr)
+        {
+            prev->next = next;
+            next->prev = prev;
+
+            next = nullptr;
+            prev = nullptr;
+        }
     }
 
-    void InsertAfterThis(TLink* link)
+    TElement* next;
+    TElement* prev;
+    DLinkedList<TElement>* owner;
+};
+
+template<typename T>
+struct DLinkedListIterator
+{
+    DLinkedListIterator(DLinkedNode<T>* node)
+        : current(node)
     {
-        link->prev = static_cast<TLink*>(this);
-        link->next = next;
 
-        if (next != nullptr)
-            next->prev = link;
+    }
 
-        next = link;
+    bool operator==(const DLinkedListIterator& rhs) const
+    {
+        return current == rhs.current;
     }
 
-    void InsertBeforeThis(TLink* link)
+    bool operator!=(const DLinkedListIterator& rhs) const
     {
-        link->next = static_cast<TLink*>(this);
-        link->prev = prev;
+        return !(*this == rhs);
+    }
 
-        if (prev != nullptr)
-            prev->next = link;
+    T& operator*()
+    {
+        return current->GetElement();
+    }
 
-        prev = link;
+    DLinkedListIterator operator++()
+    {
+        current = current->next;
+        return DLinkedListIterator(current);
     }
 
-    void InsertMeBetween(TLink* prev, TLink* next)
+    DLinkedListIterator operator--()
     {
-        this->next = next;
-        this->prev = prev;
+        current = current->prev;
+        return DLinkedListIterator();
+    }
 
-        if (next != nullptr)
-            next->prev = static_cast<TLink*>(this);
+    DLinkedNode<T>* current;
+};
 
-        if (prev != nullptr)
-            prev->next = static_cast<TLink*>(this);
-    }
+// A doubly-linked list implementation. It's intended to be inherited from. Note that it uses a dummy head and tail node
+// to simplify inserting/deleting.
+template<typename T>
+struct DLinkedList
+{
+    using Node = DLinkedNode<T>;
 
-    void Unlink()
-    {
-        if (prev)
-            prev->next = next;
+    DLinkedList();
 
-        if (next)
-            next->prev = prev;
+    DLinkedListIterator<T> begin()
+    {
+        return DLinkedListIterator<T>(head.next);
+    }
 
-        next = nullptr;
-        prev = nullptr;
+    DLinkedListIterator<T> end()
+    {
+        return DLinkedListIterator<T>(&tail);
     }
 
-    TLink* next;
-    TLink* prev;
+    void Append(Node* node);
+    void Remove(Node* node);
+    void InsertBefore(Node* node, Node* before);
+
+    Node head;
+    Node tail;
 };
+
+template<typename T>
+void DLinkedList<T>::Append(DLinkedList::Node* node)
+{
+    node->owner = this;
+    InsertBefore(&tail);
+}
+
+template<typename T>
+void DLinkedList<T>::Remove(DLinkedList::Node* node)
+{
+    assert(node->owner == this);
+}
+
+template<typename T>
+void DLinkedList<T>::InsertBefore(Node* node, Node* before)
+{
+    assert(node->owner == nullptr);
+
+    before->prev->next = node;
+    node->prev = before->prev;
+
+    node->next = before;
+    before->prev = node;
+}
+
+template<typename T>
+DLinkedList<T>::DLinkedList()
+{
+    head.next = &tail;
+    head.prev = nullptr;
+
+    tail.next = nullptr;
+    tail.prev = &head;
+}

src/Renderer/Renderer.cpp

@@ -124,15 +124,17 @@ void Renderer::RenderString(const FontSettings& fontSettings, const char* str, V
 
 void Renderer::RenderRectangle(const Rectangle& rect, Color color, float depth, float angle)
 {
-//    _spriteBatcher.RenderSolidColor(
-//        color,
-//        Vector3(
-//            rect.topLeft.x + _renderOffset.x,
-//            rect.topLeft.y + _renderOffset.y,
-//            depth),
-//        rect.Size(),
-//        nullptr,
-//        angle);
+    RenderVertex v[4];
+    Vector2 points[4];
+    rect.GetPoints(points);
+
+    for (int i = 0; i < 4; ++i)
+    {
+        v[i].position = Vector3(points[i], depth);
+        v[i].color = color.ToVector4();
+    }
+
+    spriteEffect->RenderPolygon(v, _solidColor.get());
 }
 
 void Renderer::RenderLine(Vector2 start, Vector2 end, Color color, float depth)

src/Renderer/TilemapRenderer.cpp

@@ -98,13 +98,10 @@ void TilemapRenderer::Render(Renderer* renderer) const
                     TileProperties* tile = tileMap[i][j];
                     if (tile != nullptr)
                     {
-//                        renderer->GetSpriteBatcher()->RenderSprite(
-//                            tile->sprite,
-//                            Vector3(layer.Offset() + Vector2(j, i) * tileSize, depth),
-//                            Vector2(1, 1),
-//                            0,
-//                            false,
-//                            Color());
+                        renderer->RenderSprite(
+                            &tile->sprite,
+                            Vector2(layer.Offset() + Vector2(j, i) * tileSize),
+                            depth);
                     }
                 }
             }

src/Scene/Entity.hpp

@@ -16,6 +16,7 @@
 
 #include "Sound/SoundManager.hpp"
 #include "EntitySerializer.hpp"
+#include "Memory/DLinkNode.hpp"
 
 class b2Body;
 
@@ -63,7 +64,7 @@ struct ISyncVar;
 /// <summary>
 /// The base class of all entities. Do not inherit from this directly. Instead, use the macro <see cref="DEFINE_ENTITY"/>
 /// </summary>
-struct Entity
+struct Entity : DLinkedNode<Entity>
 {
     static const int InvalidEntityId = -1;