prog

src/dawn/games/vn/events/VNChoiceEvent.hpp

@@ -41,5 +41,12 @@ namespace Dawn {
           }
         }, getScene()->eventSceneUpdate);
       }
+
+    public:
+      std::string getChoiceKey() {
+        auto it = choices.begin();
+        std::advance(it, choice);
+        return it->first;
+      }
   };
 }

src/dawnliminal/vnscenes/ScenePrologue8.hpp

@@ -0,0 +1,82 @@
+#pragma once
+
+#include "scenes/SceneMonologue.hpp"
+#include "games/vn/events/VNDummyEvent.hpp"
+#include "games/vn/events/VNSetDefaultFontEvent.hpp"
+#include "games/vn/events/VNTextEvent.hpp"
+#include "games/vn/events/VNChoiceEvent.hpp"
+#include "games/vn/events/VNIfEvent.hpp"
+#include "games/vn/events/VNSceneChangeEvent.hpp"
+#include "games/vn/events/VNChoiceSetEvent.hpp"
+#include "vnscenes/ScenePrologue9.hpp"
+
+namespace Dawn {
+  class ScenePrologue8CustomEventForChoiceSet : public VNChoiceEvent {
+    protected:
+      void onStart() override {
+        auto scene = dynamic_cast<ScenePrologue8*>this->manager->getScene();
+        assertNotNull(scene, "ScenePrologue8CustomEventForChoiceSet - Scene is null?");
+
+        this->choices = scene->remainingChoices;
+        this->key = "killer";
+        this->text = "It is...";
+
+        VNChoiceSetEvent::onStart();
+      }
+  };
+
+  class ScenePrologue8CustomEventForAfterChoice : public VNEvent {
+    protected:
+      void onStart() override {
+        auto prev = dynamic_cast<ScenePrologue8CustomEventForChoiceSet*>(this->previous);
+        assertNotNull(prev, "ScenePrologue8CustomEventForAfterChoice - Previous is null?");
+        auto scene = dynamic_cast<ScenePrologue8*>this->manager->getScene();
+        assertNotNull(scene, "ScenePrologue8CustomEventForAfterChoice - Scene is null?");
+
+        auto key = prev->getChoiceKey();
+        scene->remainingChoices.erase(key);
+
+        this->next();
+      }
+  };
+
+  class ScenePrologue8 : public SceneMonologue {
+    public:
+      std::map<std::string, std::string> remainingChoices;
+
+      ScenePrologue8(DawnGame *game) : SceneMonologue(game) {
+      }
+      
+      std::vector<Asset*> getRequiredAssets() override {
+        auto man = &this->game->assetManager;
+        std::vector<Asset*> assets = SceneMonologue::getRequiredAssets();
+        return assets;
+      }
+      
+      void stage() override {
+        SceneMonologue::stage();
+
+        remainingChoices["ave"] = "Ave?";
+        remainingChoices["ronin"] = "Ronin?";
+        remainingChoices["craig"] = "Craig?";
+
+        auto man = &this->game->assetManager;
+        assertNotNull(vnManager, "VNSceneGenInit - VN Manager is null?");
+        VNEvent *previous = vnManager->createEvent<VNDummyEvent>();
+        auto eventStart = previous;
+
+        auto event0 = vnManager->createEvent<VNSetDefaultFontEvent>();
+        event0->font = "<font font=\"font_main\" size=\"32.0f\">{{ text }}</font>";
+
+        auto event1 = vnManager->createEvent<ScenePrologue8CustomEventForChoiceSet>();
+        auto event2 = vnManager->createEvent<ScenePrologue8CustomEventForAfterChoice>();
+        auto sceneChange = vnManager->createEvent<VNSceneChangeEvent<ScenePrologue9>>();
+        
+        eventStart->then(event0);
+        event0->then(event1);
+        event1->then(event2);
+        event2->then(sceneChange);
+        vnManager->setEvent(eventStart);
+      }
+  };
+}

src/dawnosx/host/DawnHostOSX.cpp

@@ -10,6 +10,8 @@ using namespace Dawn;
 int32_t main(int32_t argc, char **args) {
   int32_t result;
 
+  memoryInit();
+
   // Create the host
   auto host = new DawnHost();
   auto game = new DawnGame(host);
@@ -40,9 +42,7 @@ int32_t main(int32_t argc, char **args) {
   delete game;
   delete host;
 
-  #if DAWN_DEBUG_BUILD
-    assertTrue(dawnAllocatedItemCount == 0, "DawnHostOSX: Failed to free all allocated items.");
-  #endif
+  memoryDispose();
 
   // Success
   return 0;

src/dawnshared/util/Xml.cpp

@@ -281,7 +281,8 @@ Xml * Xml::getFirstChildOfType(std::string type) {
 Xml::~Xml() {
   auto it = this->children.begin();
   while(it != this->children.end()) {
-    delete *it;
+    Xml *child = *it;
+    delete child;
     ++it;
   }
 }

src/dawnshared/util/Xml.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 #include "dawnsharedlibs.hpp"
+#include "util/memory.hpp"
 #include "assert/assert.hpp"
 #include "util/array.hpp"
 

src/dawnshared/util/memory.cpp

@@ -6,60 +6,40 @@
 #include "memory.hpp"
 #include "assert/assert.hpp"
 
-uint64_t dawnAllocatedItemCount = -1;
-
-void memoryInit() {
-  dawnAllocatedItemCount = 0;
+void * operator new(size_t size) noexcept {
+  return memoryAllocate(size);
 }
 
-void memoryDispose() {
-  assertTrue(dawnAllocatedItemCount <= 0, "memoryDispose: !!!Leaked memory detected (not enough free)!!!");
-  assertTrue(dawnAllocatedItemCount >= 0, "memoryDispose: !!!Leaked memory detected (too much free)!!!");
-  dawnAllocatedItemCount = -1;
+void operator delete (void *p) noexcept {
+  return memoryFree(p);
 }
 
 void * memoryAllocate(const size_t size) {
-  assertTrue(dawnAllocatedItemCount >= 0, "memoryAllocate: Either a memory leak or memoryInit was not called.");
   assertTrue(size >= 0, "memoryAllocate: size must be greater than 0 or equal to.");
-  if(size == 0) {
-    // Technically this is an implementation specific case, I think it should
-    // basically be undefined behaviour tbh.
-    return memoryCallMalloc(size);
-  }
-  dawnAllocatedItemCount++;
-  auto x = (void *)memoryCallMalloc(size);
+  void *x = (void *)memoryCallMalloc(size);
   assertNotNull(x, "memoryAllocate: Failed to allocate memory");
   return x;
 }
 
 void * memoryAllocateEmpty(const size_t count, const size_t size) {
-  assertTrue(dawnAllocatedItemCount >= 0, "memoryAllocateEmpty: Either a memory leak or memoryInit was not called.");
   assertTrue(count >= 0, "memoryAllocateEmpty: count must be greater than or equal to 0");
   assertTrue(size >= 0, "memoryAllocateEmpty: size must be greater than or equal to 0");
-  if(count == 0 || size == 0) {
-    // Technically this is an implementation specific case, I think it should
-    // basically be undefined behaviour tbh.
-    return memoryCallCalloc(count, size);
-  }
-  dawnAllocatedItemCount++;
-  auto x = (void*)memoryCallCalloc(count, size);
+  void *x = (void *)memoryCallCalloc(count, size);
+  
   assertNotNull(x, "memoryAllocateEmpty: Failed to allocate memory");
   return x;
 }
 
 void memoryFree(void *pointer) {
-  assertTrue(dawnAllocatedItemCount > 0, "memoryFree: Either a memory leak or memoryInit was not called.");
-  if(pointer == nullptr || pointer == NULL) {
-    // Technically this is an implementation specific case, I think it should
-    // basically be undefined behaviour tbh.
-    return memoryCallFree(pointer);
-  }
-  dawnAllocatedItemCount--;
   memoryCallFree(pointer);
 }
 
+void * memoryReallocate(void *ptr, size_t newSize) {
+  assertTrue(newSize >= 0, "memoryReallocate: newSize must be greater than or equal to 0");
+  return memoryCallRealloc(ptr, newSize);
+}
+
 void memoryCopy(void *source, void *destination, size_t size) {
-  assertTrue(dawnAllocatedItemCount >= 0, "memoryAllocate: Either a memory leak or memoryInit was not called.");
   assertNotNull(source, "memoryCopy: source must not be null");
   assertNotNull(destination, "memoryCopy: destination must not be null");
   assertTrue(destination != source, "memoryCopy: destination must not be source");
@@ -68,32 +48,21 @@ void memoryCopy(void *source, void *destination, size_t size) {
 }
 
 int32_t memoryCompare(const void *left, const void *right, const size_t size) {
-  assertTrue(dawnAllocatedItemCount >= 0, "memoryAllocate: Either a memory leak or memoryInit was not called.");
   assertTrue(left != right, "memoryCompare: left must not be right");
   assertTrue(size > 0, "memoryCompare: size must be greater than 0");
   return memcmp(left, right, size);
 }
 
 void memorySet(void *dest, uint8_t data, size_t length) {
-  assertTrue(dawnAllocatedItemCount >= 0, "memoryAllocate: Either a memory leak or memoryInit was not called.");
   assertNotNull(dest, "memorySet: dest must not be null");
   assertTrue(length > 0, "memorySet: length must be greater than 0");
   memset(dest, data, length);
 }
 
-size_t memoryReallocate(void **pointer, size_t currentSize, size_t newSize) {
-  // Create the new buffer
-  void *newBuffer = memoryAllocate(newSize);
-  memoryCopy(*pointer, newBuffer, currentSize);
-  memoryFree(*pointer);
-  *pointer = newBuffer;
-  return newSize;
+void memoryInit() {
+
 }
 
-void * operator new(size_t size) {
-  return memoryAllocate(size);
-}
-
-void operator delete(void *pointer) {
-  memoryFree(pointer);
+void memoryDispose() {
+  
 }

src/dawnshared/util/memory.hpp

@@ -8,7 +8,7 @@
 #pragma once
 #include "dawnsharedlibs.hpp"
 
-extern uint64_t dawnAllocatedItemCount;
+#define DAWN_MEMORY_TRACKING 1
 
 static void * memoryCallMalloc(const size_t size) {
   return malloc(size);
@@ -22,15 +22,9 @@ static void memoryCallFree(void *p) {
   free(p);
 }
 
-/**
- * Initializes the memory management system.
- */
-void memoryInit();
-
-/**
- * Disposes of the memory management system.
- */
-void memoryDispose();
+static void * memoryCallRealloc(void *p, size_t newSize) {
+  return realloc(p, newSize);
+}
 
 /**
  * Allocate some space in memory to use for your needs. Memory allocation may
@@ -57,6 +51,16 @@ void * memoryAllocateEmpty(const size_t count, const size_t size);
  */
 void memoryFree(void *pointer);
 
+/**
+ * Reallocate a part of memory. Reallocation simply creates a new buffer that
+ * will take all of the existing contents and then free's the original buffer.
+ * 
+ * @param pointer Pointer to pointer in memory that you wish to re-allocate.
+ * @param newSize The new size of the buffer.
+ * @return Pointer to the new buffer.
+ */
+void * memoryReallocate(void *pointer, size_t newSize);
+
 /**
  * Copies data from one buffer to another. Typically used for array operations.
  * 
@@ -86,32 +90,11 @@ int32_t memoryCompare(const void *left, const void *right, const size_t size);
 void memorySet(void *dest, uint8_t data, size_t length);
 
 /**
- * Reallocate a part of memory. Reallocation simply creates a new buffer that
- * will take all of the existing contents and then free's the original buffer.
- * 
- * @param pointer Pointer to pointer in memory that you wish to re-allocate.
- * @param currentSize Current size of the buffer that the pointer points to.
- * @param newSize The new size of the buffer.
- * @return The new size param you provided.
+ * Initializes the memory management system.
  */
-size_t memoryReallocate(void **pointer, size_t currentSize, size_t newSize);
+void memoryInit();
 
 /**
- * Overloads the new operator to use our memory allocation.
- * 
- * @param size Size of the memory to allocate.
- * @return Pointer to the memory.
+ * Disposes of the memory management system.
  */
-void * operator new(size_t size);
-
-/**
- * Overloads the delete operator to use our memory allocation.
- * 
- * @param p Pointer to the memory to free.
- */
-void operator delete(void * p);
-
-// Override default memory functions
-#define malloc(n) memoryAllocate(n)
-#define free(n) memoryFree(n)
-#define calloc(n, s) memoryAllocateEmpty(n, s)
+void memoryDispose();

src/dawntools/truetypetool/TrueTypeTool.cpp

@@ -151,12 +151,7 @@ int32_t TrueTypeTool::start() {
   }
 
   // Cleanup
-  itFile = files.begin();
-  while(itFile != files.end()) {
-    auto file = *itFile;
-    delete file;
-    ++itFile;
-  }
+  cleanupFiles();
 
   // Done
   fileOut.close();

src/dawntools/vnscenetool/events/VNChoiceEventParser.cpp

@@ -38,7 +38,7 @@ int32_t VNChoiceParser::onParse(
       if(ret != 0) return ret;
       out->texts.push_back(text);
     } else {
-      *error = "Unknown child node '" + child->node + "'";
+      *error = "Unknown child node for choice event '" + child->node + "'";
       return -1;
     }
 
@@ -98,7 +98,7 @@ int32_t VNChoicesEventParser::onParse(
       out->choices.push_back(choice);
 
     } else {
-      *error = "Unknown child node '" + child->node + "'";
+      *error = "Unknown child node for choices event '" + child->node + "'";
       return -1;
     }
 

src/dawntools/vnscenetool/events/VNTextEventParser.cpp

@@ -71,7 +71,7 @@ int32_t VNTextEventParser::onParse(
       if(ret != 0) return ret;
       out->texts.push_back(text);
     } else {
-      *error = "Unknown child node '" + child->node + "'";
+      *error = "Unknown child node for text event '" + child->node + "'";
       return -1;
     }