Add choice and choice-set event parsing

src/dawntools/vnscenetool/VNSceneGen.cpp

@@ -83,6 +83,25 @@ void VNSceneGen::test(
       line(&afterLines, eventName + "->then(marker_" + event->gotoMarker.name + ");", "");
       break;
 
+    case VN_SCENE_EVENT_TYPE_CHOICES: {
+      initType = "VNChoiceEvent";
+      toInclude = "games/vn/events/VNChoiceEvent.hpp";
+      line(&afterLines, eventName + "->key = \"" + event->choices.key+ "\";", "");
+      line(&afterLines, eventName + "->text = \"" + event->choices.titles.begin()->text + "\";", "");
+      auto itChoices = event->choices.choices.begin();
+      while(itChoices != event->choices.choices.end()) {
+        line(&afterLines, eventName + "->choices[\"" + itChoices->value + "\"] = \"" + itChoices->texts.begin()->text + "\";", "");
+        ++itChoices;
+      }
+      break;
+    }
+
+    case VN_SCENE_EVENT_TYPE_CHOICE_SET:
+      initType = "VNChoiceSetEvent";
+      toInclude = "games/vn/events/VNChoiceSetEvent.hpp";
+      line(&afterLines, eventName + "->key = \"" + event->choiceSet.key + "\";", "");
+      line(&afterLines, eventName + "->value = \"" + event->choiceSet.value + "\";", "");
+      break;
 
     default:
       std::cout << "Unknown event type: " << event->type << std::endl;

src/dawntools/vnscenetool/events/CMakeLists.txt

@@ -14,4 +14,6 @@ target_sources(vnscenetool
     VNWaitEventParser.cpp
     VNParallelEventParser.cpp
     VNGoToMarkerEventParser.cpp
+    VNChoiceEventParser.cpp
+    VNChoiceSetEventParser.cpp
 )

src/dawntools/vnscenetool/events/VNChoiceEventParser.cpp

@@ -0,0 +1,95 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "VNChoiceEventParser.hpp"
+
+using namespace Dawn;
+
+std::vector<std::string> VNChoiceParser::getRequiredAttributes() {
+  return { "value" };
+}
+
+std::map<std::string, std::string> VNChoiceParser::getOptionalAttributes() {
+  return { };
+}
+
+int32_t VNChoiceParser::onParse(
+  Xml *node,
+  std::map<std::string, std::string> values,
+  struct VNChoice *out,
+  std::string *error
+) {
+  int32_t ret;
+  auto itChildren = node->children.begin();
+  while(itChildren != node->children.end()) {
+    Xml *child = *itChildren;
+
+    // Parse strings
+    if(child->node == "string") {
+      VNText text;
+      ret = (VNTextParser()).parse(child, &text, error);
+      if(ret != 0) return ret;
+      out->texts.push_back(text);
+    } else {
+      *error = "Unknown child node '" + child->node + "'";
+      return -1;
+    }
+
+    itChildren++;
+  }
+
+  out->value = values["value"];
+  return 0;
+}
+
+// // // // // // // // // // // // // // // // // // // // // // // // // // //
+
+std::vector<std::string> VNChoicesEventParser::getRequiredAttributes() {
+  return { "key" };
+}
+
+std::map<std::string, std::string> VNChoicesEventParser::getOptionalAttributes() {
+  return { };
+}
+
+int32_t VNChoicesEventParser::onParse(
+  Xml *node,
+  std::map<std::string, std::string> values,
+  struct VNChoiceEvent *out,
+  std::string *error
+) {
+  int32_t ret;
+  auto itChildren = node->children.begin();
+  while(itChildren != node->children.end()) {
+    Xml *child = *itChildren;
+
+    // Parse strings
+    if(child->node == "title") {
+      auto itChildren2 = child->children.begin();
+      while(itChildren2 != child->children.end()) {
+        VNText text;
+        ret = (VNTextParser()).parse(*itChildren2, &text, error);
+        if(ret != 0) return ret;
+        out->titles.push_back(text);
+        ++itChildren2;
+      }
+
+    } else if(child->node == "choice") {
+      VNChoice choice;
+      ret = (VNChoiceParser()).parse(child, &choice, error);
+      if(ret != 0) return ret;
+      out->choices.push_back(choice);
+
+    } else {
+      *error = "Unknown child node '" + child->node + "'";
+      return -1;
+    }
+
+    itChildren++;
+  }
+
+  out->key = values["key"];
+  return 0;
+}

src/dawntools/vnscenetool/events/VNChoiceEventParser.hpp

@@ -0,0 +1,44 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "VNTextEventParser.hpp"
+
+namespace Dawn {
+  struct VNChoice {
+    std::vector<struct VNText> texts;
+    std::string value;
+  };
+
+  struct VNChoiceEvent {
+    std::vector<struct VNText> titles;
+    std::vector<struct VNChoice> choices;
+    std::string key;
+  };
+
+  class VNChoiceParser : public XmlParser<struct VNChoice> {
+    protected:
+      std::vector<std::string> getRequiredAttributes() override;
+      std::map<std::string, std::string> getOptionalAttributes() override;
+      int32_t onParse(
+        Xml *node,
+        std::map<std::string, std::string> values,
+        struct VNChoice *out,
+        std::string *error
+      ) override;
+  };
+
+  class VNChoicesEventParser : public XmlParser<struct VNChoiceEvent> {
+    protected:
+      std::vector<std::string> getRequiredAttributes() override;
+      std::map<std::string, std::string> getOptionalAttributes() override;
+      int32_t onParse(
+        Xml *node,
+        std::map<std::string, std::string> values,
+        struct VNChoiceEvent *out,
+        std::string *error
+      ) override;
+  };
+}

src/dawntools/vnscenetool/events/VNChoiceSetEventParser.cpp

@@ -0,0 +1,27 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "VNChoiceSetEventParser.hpp"
+
+using namespace Dawn;
+
+std::vector<std::string> VNChoiceSetEventParser::getRequiredAttributes() {
+  return { "key", "value" };
+}
+
+std::map<std::string, std::string> VNChoiceSetEventParser::getOptionalAttributes() {
+  return {};
+}
+
+int32_t VNChoiceSetEventParser::onParse(
+  Xml *node,
+  std::map<std::string, std::string> values,
+  struct VNChoiceSetEvent *out,
+  std::string *error
+) {
+  out->key = values["key"];
+  out->value = values["value"];
+  return 0;
+}

src/dawntools/vnscenetool/events/VNChoiceSetEventParser.hpp

@@ -0,0 +1,26 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "util/XmlParser.hpp"
+
+namespace Dawn {
+  struct VNChoiceSetEvent {
+    std::string key;
+    std::string value;
+  };
+
+  class VNChoiceSetEventParser : public XmlParser<VNChoiceSetEvent> {
+    protected:
+      std::vector<std::string> getRequiredAttributes() override;
+      std::map<std::string, std::string> getOptionalAttributes() override;
+      int32_t onParse(
+        Xml *node,
+        std::map<std::string, std::string> values,
+        struct VNChoiceSetEvent *out,
+        std::string *error
+      ) override;
+  };
+}

src/dawntools/vnscenetool/events/VNSceneEventsParser.cpp

@@ -65,6 +65,16 @@ int32_t VNSceneEventsParser::onParse(
       ret = (VNGoToMarkerEventParser()).parse(child, &event.gotoMarker, error);
       if(ret != 0) return ret;
 
+    } else if(child->node == "choices") {
+      event.type = VN_SCENE_EVENT_TYPE_CHOICES;
+      ret = (VNChoicesEventParser()).parse(child, &event.choices, error);
+      if(ret != 0) return ret;
+
+    } else if(child->node == "choice-set") {
+      event.type = VN_SCENE_EVENT_TYPE_CHOICE_SET;
+      ret = (VNChoiceSetEventParser()).parse(child, &event.choiceSet, error);
+      if(ret != 0) return ret;
+
     } else {
       *error = "Unknown child node '" + child->node + "'";
       return -1;

src/dawntools/vnscenetool/events/VNSceneEventsParser.hpp

@@ -11,6 +11,8 @@
 #include "VNParallelEventParser.hpp"
 #include "VNMarkerParser.hpp"
 #include "VNGoToMarkerEventParser.hpp"
+#include "VNChoiceEventParser.hpp"
+#include "VNChoiceSetEventParser.hpp"
 
 namespace Dawn {
   struct VNSceneEvent;
@@ -26,7 +28,9 @@ namespace Dawn {
     VN_SCENE_EVENT_TYPE_WAIT,
     VN_SCENE_EVENT_TYPE_PARALLEL,
     VN_SCENE_EVENT_TYPE_MARKER,
-    VN_SCENE_EVENT_TYPE_GOTO_MARKER
+    VN_SCENE_EVENT_TYPE_GOTO_MARKER,
+    VN_SCENE_EVENT_TYPE_CHOICES,
+    VN_SCENE_EVENT_TYPE_CHOICE_SET
   };
 
   struct VNParallelEvent {
@@ -43,6 +47,8 @@ namespace Dawn {
     struct VNParallelEvent parallel;
     struct VNMarker marker;
     struct VNGoToMarkerEvent gotoMarker;
+    struct VNChoiceEvent choices;
+    struct VNChoiceSetEvent choiceSet;
   };
 
   class VNSceneEventsParser : public XmlParser<struct VNSceneEventList> {

src/dawntools/vnscenetool/events/VNTextEventParser.cpp

@@ -7,6 +7,27 @@
 
 using namespace Dawn;
 
+std::vector<std::string> VNTextParser::getRequiredAttributes() {
+  return { "lang" };
+}
+
+std::map<std::string, std::string> VNTextParser::getOptionalAttributes() {
+  return { };
+}
+
+int32_t VNTextParser::onParse(
+  Xml *node,
+  std::map<std::string, std::string> values,
+  struct VNText *out,
+  std::string *error
+) {
+  out->language = values["lang"];
+  out->text = node->value;
+  return 0;
+}
+
+// // // // // // // // // // // // // // // // // // // // // // // // // // //
+
 std::vector<std::string> VNTextEventParser::getRequiredAttributes() {
   return { };
 }
@@ -21,6 +42,7 @@ int32_t VNTextEventParser::onParse(
   struct VNTextEvent *out,
   std::string *error
 ) {
+  int32_t ret;
   auto itChildren = node->children.begin();
   while(itChildren != node->children.end()) {
     Xml *child = *itChildren;
@@ -28,8 +50,8 @@ int32_t VNTextEventParser::onParse(
     // Parse strings
     if(child->node == "string") {
       VNText text;
-      text.language = child->attributes["lang"];
-      text.text = child->value;
+      ret = (VNTextParser()).parse(child, &text, error);
+      if(ret != 0) return ret;
       out->texts.push_back(text);
     } else {
       *error = "Unknown child node '" + child->node + "'";

src/dawntools/vnscenetool/events/VNTextEventParser.hpp

@@ -16,6 +16,18 @@ namespace Dawn {
     std::vector<VNText> texts;
   };
 
+  class VNTextParser : public XmlParser<struct VNText> {
+    protected:
+      std::vector<std::string> getRequiredAttributes() override;
+      std::map<std::string, std::string> getOptionalAttributes() override;
+      int32_t onParse(
+        Xml *node,
+        std::map<std::string, std::string> values,
+        struct VNText *out,
+        std::string *error
+      ) override;
+  };
+
   class VNTextEventParser : public XmlParser<struct VNTextEvent> {
     protected:
       std::vector<std::string> getRequiredAttributes() override;