YourWishes/Dawn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Redid the VN Scene Parser

Browse Source
This commit is contained in:
Dominic Masters
2023-02-12 21:38:12 -08:00
parent 9436b7e98f
commit f1d13d2e45
32 changed files with 941 additions and 516 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/dawnpokergame/CMakeLists.txt
View File

@ -39,7 +39,7 @@ tool_truetype(truetype_alice ${DIR_GAME_ASSETS}/font/Alice-Regular.ttf truetype_
tool_audio(audio_test borrowed/sample_short.wav) tool_audio(audio_test borrowed/sample_short.wav)
tool_vnscene(vnscene_1 ${DIR_GAME_ASSETS}/vn/Scene_1.xml) tool_vnscene(Scene_1 ${DIR_GAME_ASSETS}/vn/Scene_1.xml)
add_dependencies(${DAWN_TARGET_NAME} add_dependencies(${DAWN_TARGET_NAME}
locale_poker locale_poker
@ -53,5 +53,5 @@ add_dependencies(${DAWN_TARGET_NAME}
audio_test audio_test
vnscene_1 Scene_1
) )

4
src/dawnpokergame/game/DawnGame.cpp
View File

@ -4,7 +4,7 @@
// https://opensource.org/licenses/MIT // https://opensource.org/licenses/MIT
#include "DawnGame.hpp" #include "DawnGame.hpp"
#include "scenes/vnscene_1.hpp" #include "scenes/Scene_1.hpp"
using namespace Dawn; using namespace Dawn;
@ -24,7 +24,7 @@ int32_t DawnGame::init() {
this->renderManager.init(); this->renderManager.init();
this->audioManager.init(); this->audioManager.init();
this->scene = new vnscene_1(this); this->scene = new Scene_1(this);
return DAWN_GAME_INIT_RESULT_SUCCESS; return DAWN_GAME_INIT_RESULT_SUCCESS;
} }

58
src/dawnpokergame/scenes/Scene_1.hpp
View File

@ -1,58 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "visualnovel/scene/SimpleVNScene.hpp"
#include "scenes/Scene_2.hpp"
#include "prefabs/characters/DeathPrefab.hpp"
#include "visualnovel/events/characters/VisualNovelFadeCharacterEvent.hpp"
#include "visualnovel/events/characters/VisualNovelTransformItemEvent.hpp"
#include "visualnovel/events/timing/VisualNovelBatchEvent.hpp"
namespace Dawn {
class Scene_1 : public SimpleVNScene {
protected:
DeathPrefab *death;
void vnStage() override {
this->death = DeathPrefab::create(this);
this->death->material->color.a = 0;
}
void onSceneEnded() {
auto scene = new Scene_2(this->game);
game->assetManager.queueSwap(
scene->getRequiredAssets(), this->getRequiredAssets()
);
game->assetManager.syncLoad();
scene->stage();
this->game->sceneCutover(scene);
}
public:
Scene_1(DawnGame *game) : SimpleVNScene(game) {
}
std::vector<Asset*> getRequiredAssets() override {
auto man = &this->game->assetManager;
std::vector<Asset*> assets = SimpleVNScene::getRequiredAssets();
vectorAppend(&assets, DeathPrefab::getRequiredAssets(man));
assets.push_back(man->get<AudioAsset>("audio_test"));
return assets;
}
IVisualNovelEvent * getVNEvent() override {
auto start = new VisualNovelPauseEvent(vnManager, 0.1f);
start
->then(new VisualNovelTextboxEvent(vnManager, this->death->vnCharacter, this->death->emotionHappy, "scene.1.1"))
->then(new VisualNovelFadeCharacterEvent(vnManager, this->death->vnCharacter, true, &easeOutQuad, 1.0f))
// ->then(new VisualNovelCallbackEvent<Scene_1>(vnManager, this, &Scene_1::onSceneEnded))
;
return start;
}
};
}

100
src/dawntools/util/CodeGen.hpp Normal file
View File

@ -0,0 +1,100 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "dawnsharedlibs.hpp"
namespace Dawn {
struct ClassGenInfo {
std::vector<std::string> includes;
std::string clazz = "Unknown";
std::string extend = "";
std::string constructorArgs = "";
std::string extendArgs = "";
std::vector<std::string> protectedCode;
std::vector<std::string> protectedProperties;
std::vector<std::string> publicCode;
std::vector<std::string> publicProperties;
};
struct MethodGenInfo {
std::string name;
std::string type = "void";
std::vector<std::string> body;
std::string args = "";
bool_t isStatic = false;
bool_t isOverride = false;
};
class CodeGen {
protected:
static void line(
std::vector<std::string> *out,
std::string contents,
std::string tabs
) {
out->push_back(tabs + contents);
}
static void lines(
std::vector<std::string> *out,
std::vector<std::string> lines,
std::string tabs
) {
auto itLine = lines.begin();
while(itLine != lines.end()) {
line(out, *itLine, tabs);
++itLine;
}
}
static void classGen(
std::vector<std::string> *out,
struct ClassGenInfo info
) {
std::vector<std::string> buffer;
line(out, "#pragma once", "");
line(out, "", "");
if(info.includes.size() > 0) {
lines(out, info.includes, "");
line(out, "", "");
}
line(out, "namespace Dawn {", "");
line(out, "class " + info.clazz + (info.extend.size() == 0 ? "{" : " : public " + info.extend + " {" ), " ");
if(info.protectedCode.size() > 0) {
line(out, "protected:", " ");
lines(out, info.protectedProperties, " ");
line(out, "", " ");
lines(out, info.protectedCode, " ");
}
if(info.publicCode.size() > 0 || info.constructorArgs.size() > 0) {
line(out, "public:", " ");
lines(out, info.publicProperties, " ");
line(out, "", " ");
line(out, info.clazz + "(" + info.constructorArgs + ")" + (info.extend.size() > 0 ? " : " + info.extend + "(" + info.extendArgs + ")" : "") + " {", " ");
line(out, "}", " ");
if(info.publicCode.size() > 0) {
line(out, "", " ");
lines(out, info.publicCode, " ");
}
}
line(out, "};", " ");
line(out, "}", "");
}
static void methodGen(
std::vector<std::string> *out,
struct MethodGenInfo info
) {
line(out, info.type + " " + info.name + "(" + info.args + ") " + ( info.isOverride ? "override" : "" ) + "{", "");
lines(out, info.body, " ");
line(out, "}", "");
}
};
}

4
src/dawntools/util/File.cpp
View File

@ -63,13 +63,13 @@ bool_t File::readString(std::string *out) {
out->clear(); out->clear();
size_t i = 0; size_t i = 0;
char buffer[FILE_BUFFER_SIZE + 1]; char buffer[FILE_BUFFER_SIZE + 1];// +1 for null term
while(i != this->length) { while(i != this->length) {
size_t amt = mathMin<size_t>(FILE_BUFFER_SIZE, (this->length - i)); size_t amt = mathMin<size_t>(FILE_BUFFER_SIZE, (this->length - i));
auto amtRead = fread(buffer, sizeof(char), amt, this->file); auto amtRead = fread(buffer, sizeof(char), amt, this->file);
if(amtRead != amt) return false; if(amtRead != amt) return false;
i += amtRead; i += amtRead;
buffer[amtRead + 1] = '\0'; buffer[amtRead] = '\0';
out->append(buffer); out->append(buffer);
} }

72
src/dawntools/util/XmlParser.hpp Normal file
View File

@ -0,0 +1,72 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/Xml.hpp"
namespace Dawn {
template<typename T>
class XmlParser {
protected:
virtual std::vector<std::string> getRequiredAttributes() = 0;
virtual std::map<std::string, std::string> getOptionalAttributes() = 0;
virtual int32_t onParse(
Xml *node,
std::map<std::string, std::string> values,
T *output,
std::string *error
) = 0;
public:
static std::string parseDuration(std::string duration) {
std::string dur = duration;
if(dur.find('.') == std::string::npos) dur += ".0";
return dur + "f";
}
static std::string parseEase(std::string e) {
if(e == "out-quad") return "&easeOutQuad";
if(e == "linear") return "&easeLinear";
return "";
}
int32_t parse(Xml *xml, T *output, std::string *error) {
std::map<std::string, std::string> values;
// First get the required attributes
auto required = this->getRequiredAttributes();
auto itRequired = required.begin();
while(itRequired != required.end()) {
auto s = *itRequired;
auto attr = xml->attributes.find(s);
if(attr == xml->attributes.end()) {
std::cout << "Missing required attribute \"" << s << "\"" << std::endl;
return 1;
}
values[s] = attr->second;
++itRequired;
}
// Now get the optional attributes
auto optional = this->getOptionalAttributes();
auto itOptional = optional.begin();
while(itOptional != optional.end()) {
auto key = itOptional->first;
auto defaultValue = itOptional->second;
auto attr = xml->attributes.find(key);
if(attr == xml->attributes.end()) {
values[key] = defaultValue;
} else {
values[key] = attr->second;
}
++itOptional;
}
// Now send to parser
return this->onParse(xml, values, output, error);
}
};
}

5
src/dawntools/visualnovel/vnscenegen/CMakeLists.txt
View File

@ -32,7 +32,4 @@ target_compile_definitions(vnscenegen
target_link_libraries(vnscenegen target_link_libraries(vnscenegen
PUBLIC PUBLIC
${DAWN_BUILD_HOST_LIBS} ${DAWN_BUILD_HOST_LIBS}
) )
# Subdirs
add_subdirectory(parse)

113
src/dawntools/visualnovel/vnscenegen/VnSceneGen.cpp
View File

@ -23,111 +23,24 @@ int32_t VnSceneGen::start() {
// Parse XML // Parse XML
Xml xml = Xml::load(buffer); Xml xml = Xml::load(buffer);
std::string error;
// First, read the header information struct RootInformation info;
struct HeaderInformation header; auto ret = (RootParser()).parse(&xml, &info, &error);
auto itXml = xml.children.begin(); if(ret != 0) {
while(itXml != xml.children.end()) { std::cout << error << std::endl;
auto child = *itXml; return ret;
if(child->node != "head") {
++itXml;
continue;
}
auto ret = parseHeader(&header, child);
if(ret != 0) return ret;
break;
}
// Validate header
if(header.sceneInfo.name.size() == 0 || header.sceneInfo.type.size() == 0) {
std::cout << "VN Scene header wasn't parsed properly." << std::endl;
return 1;
} }
// Parse and load events. std::vector<std::string> lines;
std::string bufferEvents; RootGen::generate(&lines, &info, "");
itXml = xml.children.begin();
while(itXml != xml.children.end()) {
auto events = *itXml;
if(events->node != "events") {
++itXml;
continue;
}
bufferEvents += "\n start\n";
auto itChildren = events->children.begin(); // Generate buffer
while(itChildren != events->children.end()) {
auto evt = *itChildren;
if(evt->node != "scene-transition") {
auto evtParsed = parseEvent(&header, evt);
if(evtParsed.size() == 0) return 1;
bufferEvents += " ->then(" + evtParsed + ")\n";
}
++itChildren;
}
bufferEvents += " ;\n";
++itXml;
}
// Now render output to file.
std::string bufferOut; std::string bufferOut;
bufferOut += "#pragma once\n\n"; auto itLine = lines.begin();
auto itInclude = header.includes.begin(); while(itLine != lines.end()) {
while(itInclude != header.includes.end()) { bufferOut += *itLine + "\n";
bufferOut += "#include \"" + (*itInclude) + "\"\n"; ++itLine;
++itInclude;
} }
bufferOut += "\nnamespace Dawn{\n";
bufferOut += " class " + header.sceneInfo.name + " : public " + header.sceneInfo.type + " {\n";
bufferOut += " protected:\n";
// Characters (As properties)
auto itCharacters = header.characters.begin();
while(itCharacters != header.characters.end()) {
auto c = *itCharacters;
bufferOut += " " + c.clazz + " *" + c.name + ";\n";
++itCharacters;
}
bufferOut += "\n void vnStage() override {\n";
bufferOut += " " + header.sceneInfo.type + "::vnStage();\n";
// Initialize the characters
itCharacters = header.characters.begin();
while(itCharacters != header.characters.end()) {
auto c = *itCharacters;
bufferOut += " this->" + c.name + " = " + c.clazz + "::create(this);\n";
++itCharacters;
}
bufferOut += " }\n";
bufferOut += "\n public:\n";
bufferOut += " " + header.sceneInfo.name + "(DawnGame *game) : " + header.sceneInfo.type + "(game) {\n";
bufferOut += " }\n";
// Assets
bufferOut += "\n std::vector<Asset*> getRequiredAssets() override{\n";
bufferOut += " auto man = &this->game->assetManager;\n";
bufferOut += " std::vector<Asset*> assets = " + header.sceneInfo.type + "::getRequiredAssets();\n";
itCharacters = header.characters.begin();
while(itCharacters != header.characters.end()) {
auto c = *itCharacters;
bufferOut += " vectorAppend(&assets, " + c.clazz + "::getRequiredAssets(man));\n";
++itCharacters;
}
bufferOut += " return assets;\n";
bufferOut += " }\n";
// VN Events
bufferOut += "\n IVisualNovelEvent * getVNEvent() override {\n";
bufferOut += " auto start = new VisualNovelPauseEvent(vnManager, 0.01f);\n";
bufferOut += bufferEvents;
bufferOut += "\n return start;\n";
bufferOut += " }\n";
bufferOut += " };\n";
bufferOut += "}";
// Finished with XML data, now we can write data out. // Finished with XML data, now we can write data out.
File fileOut(this->args[2] + ".hpp"); File fileOut(this->args[2] + ".hpp");

5
src/dawntools/visualnovel/vnscenegen/VnSceneGen.hpp
View File

@ -6,14 +6,13 @@
#pragma once #pragma once
#include "util/DawnTool.hpp" #include "util/DawnTool.hpp"
#include "util/File.hpp" #include "util/File.hpp"
#include "parse/VnSceneParseEvent.hpp" #include "parse/root.hpp"
#include "parse/VnSceneParseHeader.hpp"
namespace Dawn { namespace Dawn {
class VnSceneGen : public DawnTool { class VnSceneGen : public DawnTool {
protected: protected:
public: public:
int32_t start() override; int32_t start();
}; };
} }

15
src/dawntools/visualnovel/vnscenegen/parse/CMakeLists.txt
View File

@ -1,15 +0,0 @@
# Copyright (c) 2023 Dominic Msters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Sources
target_sources(vnscenegen
PRIVATE
VnSceneParseAsset.cpp
VnSceneParseCharacter.cpp
VnSceneParseEvent.cpp
VnSceneParseScene.cpp
VnSceneParseHeader.cpp
VnSceneParseInclude.cpp
)

27
src/dawntools/visualnovel/vnscenegen/parse/VnSceneParseAsset.cpp
View File

@ -1,27 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VnSceneParseAsset.hpp"
using namespace Dawn;
int32_t parseAsset(std::vector<struct Asset> *assets, Xml *node) {
auto attrType = node->attributes.find("type");
if(attrType == node->attributes.end()) {
std::cout << "VN Scene Asset missing type attribute" << std::endl;
return 1;
}
auto attrName = node->attributes.find("name");
if(attrName == node->attributes.end()) {
std::cout << "VN Scene Asset missing name attribute" << std::endl;
return 1;
}
struct Asset ass;
ass.type = attrType->second;
ass.name = attrType->second;
assets->push_back(ass);
return 0;
}

16
src/dawntools/visualnovel/vnscenegen/parse/VnSceneParseAsset.hpp
View File

@ -1,16 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/Xml.hpp"
using namespace Dawn;
struct Asset {
std::string type;
std::string name;
};
int32_t parseAsset(std::vector<struct Asset> *assets, Xml *node);

27
src/dawntools/visualnovel/vnscenegen/parse/VnSceneParseCharacter.cpp
View File

@ -1,27 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VnSceneParseCharacter.hpp"
using namespace Dawn;
int32_t parseCharacter(std::vector<struct CharacterInformation> *characters, Xml *node) {
auto attrClass = node->attributes.find("class");
if(attrClass == node->attributes.end()) {
std::cout << "Character definition is missing class" << std::endl;
return 1;
}
auto attrName = node->attributes.find("name");
if(attrName == node->attributes.end()) {
std::cout << "Character definition is missing name" << std::endl;
}
struct CharacterInformation character;
character.clazz = attrClass->second;
character.name = attrName->second;
characters->push_back(character);
return 0;
}

19
src/dawntools/visualnovel/vnscenegen/parse/VnSceneParseCharacter.hpp
View File

@ -1,19 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/Xml.hpp"
using namespace Dawn;
struct CharacterInformation {
std::string clazz;
std::string name;
};
int32_t parseCharacter(
std::vector<struct CharacterInformation> *characters,
Xml *node
);

105
src/dawntools/visualnovel/vnscenegen/parse/VnSceneParseEvent.cpp
View File

@ -1,105 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VnSceneParseEvent.hpp"
using namespace Dawn;
std::string parseEase(std::string e) {
if(e == "out-quad") return "easeOutQuad";
std::cout << "Invalid ease defined" << std::endl;
return "";
}
std::string parseEvent(struct HeaderInformation *header, Xml *evt) {
std::string buffer;
std::string node(evt->node);
if(node == "pause") {
// Pause
header->includes.push_back("visualnovel/events/timing/VisualNovelPauseEvent.hpp");
auto attrDuration = evt->attributes.find("duration");
if(attrDuration == evt->attributes.end()) {
std::cout << "Pause event is missing duration argument." << std::endl;
return "";
}
auto dur = attrDuration->second;
if(dur.find('.') == std::string::npos) dur += ".0";
buffer += "new VisualNovelPauseEvent(vnManager, " + dur + "f)";
} else if(node == "text") {
// Text
header->includes.push_back("visualnovel/events/VisualNovelTextboxEvent.hpp");
auto attrChar = evt->attributes.find("character");
if(attrChar == evt->attributes.end()) {
std::cout << "Text event missing character attribute." << std::endl;
return "";
}
auto attrEmotion = evt->attributes.find("emotion");
if(attrEmotion == evt->attributes.end()) {
std::cout << "Text event missing emotion attribute." << std::endl;
return "";
}
auto attrString = evt->attributes.find("string");
if(attrString == evt->attributes.end()) {
std::cout << "Text event missing string attribute." << std::endl;
return "";
}
std::string emo = attrEmotion->second;
emo[0] = toupper(emo[0]);
buffer += "new VisualNovelTextboxEvent(vnManager, ";
buffer += "this->" + attrChar->second + "->vnCharacter, ";
buffer += "this->" + attrChar->second + "->emotion" + emo + ", ";
buffer += "\"" + attrString->second + "\"" ;
buffer += ")";
} else if(node == "character-fade") {
// Character Fade
header->includes.push_back("visualnovel/events/characters/VisualNovelFadeCharacterEvent.hpp");
auto attrChar = evt->attributes.find("character");
auto attrDuration = evt->attributes.find("duration");
auto attrEase = evt->attributes.find("ease");
auto attrFade = evt->attributes.find("fade");
if(attrChar == evt->attributes.end()) {
std::cout << "Character fade event missing character attribute." << std::endl;
return "";
}
std::string character = attrChar->second;
std::string easeIn = "true";
std::string ease = "easeLinear";
std::string duration = "1.0";
if(attrFade != evt->attributes.end()) easeIn = attrFade->second == "in" ? "true" : "false";
if(attrDuration != evt->attributes.end()) duration = attrDuration->second;
if(duration.find('.') == std::string::npos) duration += ".0";
if(attrEase != evt->attributes.end()) {
ease = parseEase(attrEase->second);
if(ease.size() == 0) return "";
}
buffer += "new VisualNovelFadeCharacterEvent(vnManager, ";
buffer += "this->" + character + "->vnCharacter, ";
buffer += easeIn + ", ";
buffer += "&" + ease + ", ";
buffer += duration + "f";
buffer += ")";
} else if(node == "scene-transition") {
buffer += " ";
}
return buffer;
}

12
src/dawntools/visualnovel/vnscenegen/parse/VnSceneParseEvent.hpp
View File

@ -1,12 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/Xml.hpp"
#include "parse/VnSceneParseHeader.hpp"
using namespace Dawn;
std::string parseEvent(struct HeaderInformation *header, Xml *evt);

31
src/dawntools/visualnovel/vnscenegen/parse/VnSceneParseHeader.cpp
View File

@ -1,31 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VnSceneParseHeader.hpp"
using namespace Dawn;
int32_t parseHeader(struct HeaderInformation *info, Xml *node) {
auto itChildren = node->children.begin();
while(itChildren != node->children.end()) {
auto c = *itChildren;
int32_t ret = 0;
if(c->node == "include") {
ret = parseInclude(&info->includes, c);
} else if(c->node == "character") {
ret = parseCharacter(&info->characters, c);
} else if(c->node == "scene") {
ret = parseScene(&info->sceneInfo, c);
} else if (c->node == "asset") {
ret = parseAsset(&info->assets, c);
} else {
std::cout << "Parsing VN Scene header, unknown node " << c->node << std::endl;
}
if(ret != 0) return ret;
++itChildren;
}
return 0;
}

22
src/dawntools/visualnovel/vnscenegen/parse/VnSceneParseHeader.hpp
View File

@ -1,22 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/Xml.hpp"
#include "parse/VnSceneParseCharacter.hpp"
#include "parse/VnSceneParseInclude.hpp"
#include "parse/VnSceneParseScene.hpp"
#include "parse/VnSceneParseAsset.hpp"
using namespace Dawn;
struct HeaderInformation {
std::vector<std::string> includes;
std::vector<struct CharacterInformation> characters;
std::vector<struct Asset> assets;
struct SceneInformation sceneInfo;
};
int32_t parseHeader(struct HeaderInformation *info, Xml *node);

19
src/dawntools/visualnovel/vnscenegen/parse/VnSceneParseInclude.cpp
View File

@ -1,19 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VnSceneParseInclude.hpp"
using namespace Dawn;
int32_t parseInclude(std::vector<std::string> *includes, Xml *node) {
auto attrPath = node->attributes.find("path");
if(attrPath == node->attributes.end()) {
std::cout << "Missing include path in VN Header Defintions." << std::endl;
return 1;
}
includes->push_back(attrPath->second);
return 0;
}

11
src/dawntools/visualnovel/vnscenegen/parse/VnSceneParseInclude.hpp
View File

@ -1,11 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/Xml.hpp"
using namespace Dawn;
int32_t parseInclude(std::vector<std::string> *includes, Xml *node);

25
src/dawntools/visualnovel/vnscenegen/parse/VnSceneParseScene.cpp
View File

@ -1,25 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VnSceneParseScene.hpp"
using namespace Dawn;
int32_t parseScene(struct SceneInformation *info, Xml *node) {
auto attrName = node->attributes.find("name");
if(attrName == node->attributes.end()) {
std::cout << "VN Scene <scene> definition is missing name attribute" << std::endl;
return 1;
}
info->name = attrName->second;
auto attrType = node->attributes.find("type");
if(attrType == node->attributes.end()) {
info->type = "SimpleVNScene";
} else {
info->type = attrType->second;
}
return 0;
}

16
src/dawntools/visualnovel/vnscenegen/parse/VnSceneParseScene.hpp
View File

@ -1,16 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/Xml.hpp"
using namespace Dawn;
struct SceneInformation {
std::string type;
std::string name;
};
int32_t parseScene(struct SceneInformation *info, Xml *node);

56
src/dawntools/visualnovel/vnscenegen/parse/asset.hpp Normal file
View File

@ -0,0 +1,56 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/XmlParser.hpp"
#include "util/CodeGen.hpp"
namespace Dawn {
struct AssetInformation {
std::string type;
std::string name;
};
class AssetParser : public XmlParser<struct AssetInformation> {
protected:
std::vector<std::string> getRequiredAttributes() {
return std::vector<std::string>{
"name",
"type"
};
}
std::map<std::string, std::string> getOptionalAttributes() {
return std::map<std::string, std::string>();
}
int32_t onParse(
Xml *node,
std::map<std::string, std::string> values,
struct AssetInformation *out,
std::string *error
) {
out->name = values["name"];
out->type = values["type"];
return 0;
}
std::string convert(struct AssetInformation info) {
std::string out;
return out;
}
};
class AssetGen : public CodeGen {
public:
static void generate(
std::vector<std::string> *out,
struct AssetInformation *info,
std::string tabs
) {
return line(out, "// Asset will be generated here", tabs);
}
};
}

77
src/dawntools/visualnovel/vnscenegen/parse/character.hpp Normal file
View File

@ -0,0 +1,77 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/XmlParser.hpp"
#include "util/CodeGen.hpp"
namespace Dawn {
struct CharacterInformation {
std::string clazz;
std::string name;
};
class CharacterParser : public XmlParser<struct CharacterInformation> {
protected:
std::vector<std::string> getRequiredAttributes() {
return std::vector<std::string>{
"class",
"name"
};
}
std::map<std::string, std::string> getOptionalAttributes() {
return std::map<std::string, std::string>();
}
int32_t onParse(
Xml *node,
std::map<std::string, std::string> values,
struct CharacterInformation *out,
std::string *error
) {
out->clazz = values["class"];
out->name = values["name"];
if(out->clazz.size() == 0) {
*error = "Character class cannot be empty.";
return 1;
}
if(out->name.size() == 0) {
*error = "Character name cannot be empty.";
return 1;
}
return 0;
}
};
class CharacterGen : public CodeGen {
public:
static void generateProperty(
std::vector<std::string> *out,
struct CharacterInformation info,
std::string tabs
) {
line(out, info.clazz + " *" + info.name + ";", tabs);
}
static void generateInitializer(
std::vector<std::string> *out,
struct CharacterInformation info,
std::string tabs
) {
line(out, "this->" + info.name + " = " + info.clazz + "::create(this);", tabs);
}
static void generateAssets(
std::vector<std::string> *out,
struct CharacterInformation info,
std::string tabs
) {
line(out, "vectorAppend(&assets, " + info.clazz + "::getRequiredAssets(man));", "");
}
};
}

77
src/dawntools/visualnovel/vnscenegen/parse/event/characterfadeevent.hpp Normal file
View File

@ -0,0 +1,77 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/XmlParser.hpp"
#include "util/CodeGen.hpp"
namespace Dawn {
struct CharacterFadeEventInfo {
std::string character;
std::string duration;
std::string ease;
std::string fade;
std::string include;
};
class CharacterFadeParser : public XmlParser<struct CharacterFadeEventInfo> {
protected:
std::vector<std::string> getRequiredAttributes() {
return std::vector<std::string>{
"character"
};
}
std::map<std::string, std::string> getOptionalAttributes() {
return std::map<std::string, std::string>{
{ "fade", "in" },
{ "ease", "linear" },
{ "duration", "1" }
};
}
int32_t onParse(
Xml *node,
std::map<std::string, std::string> values,
struct CharacterFadeEventInfo *out,
std::string *error
) {
out->character = values["character"];
out->duration = parseDuration(values["duration"]);
out->ease = parseEase(values["ease"]);
out->fade = values["fade"] == "in" ? "true" : "false";
out->include = "visualnovel/events/characters/VisualNovelFadeCharacterEvent.hpp";
if(out->ease.size() == 0) {
*error = "Invalid ease";
return 1;
}
return 0;
}
};
class CharacterFadeGen : public CodeGen {
public:
static void generate(
std::vector<std::string> *out,
struct CharacterFadeEventInfo *info,
std::string tabs = ""
) {
line(out, "new VisualNovelFadeCharacterEvent(vnManager,", tabs + " ");
line(out, "this->" + info->character + "->vnCharacter,", tabs + " ");
line(out, info->fade + ",", tabs + " ");
line(out, info->ease + ",", tabs + " ");
line(out, info->duration, tabs + " ");
line(out, ")", tabs);
}
};
}

48
src/dawntools/visualnovel/vnscenegen/parse/event/pauseevent.hpp Normal file
View File

@ -0,0 +1,48 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/XmlParser.hpp"
#include "util/CodeGen.hpp"
namespace Dawn {
struct PauseEventInfo {
std::string duration;
std::string include;
};
class PauseEventParser : public XmlParser<struct PauseEventInfo> {
protected:
std::vector<std::string> getRequiredAttributes() {
return std::vector<std::string>{ "duration" };
}
std::map<std::string, std::string> getOptionalAttributes() {
return std::map<std::string, std::string>();
}
int32_t onParse(
Xml *node,
std::map<std::string, std::string> values,
struct PauseEventInfo *out,
std::string *error
) {
out->duration = parseDuration(values["duration"]);
out->include = "visualnovel/events/timing/VisualNovelPauseEvent.hpp";
return 0;
}
};
class PauseEventGen : public CodeGen {
public:
static void generate(
std::vector<std::string> *out,
struct PauseEventInfo *info,
std::string tabs = ""
) {
line(out, "new VisualNovelPauseEvent(vnManager, " + info->duration + ")", tabs);
}
};
}

100
src/dawntools/visualnovel/vnscenegen/parse/event/textevent.hpp Normal file
View File

@ -0,0 +1,100 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/XmlParser.hpp"
#include "util/CodeGen.hpp"
namespace Dawn {
struct TextStringInfo {
std::string lang;
std::string text;
};
struct TextEventInfo {
std::string character;
std::string emotion;
std::vector<struct TextStringInfo> strings;
std::string key = "scene.1.1";
};
class TextStringParser : public XmlParser<struct TextStringInfo> {
protected:
std::vector<std::string> getRequiredAttributes() {
return std::vector<std::string>{ "lang" };
}
std::map<std::string, std::string> getOptionalAttributes() {
return std::map<std::string, std::string>();
}
int32_t onParse(
Xml *node,
std::map<std::string, std::string> values,
struct TextStringInfo *out,
std::string *error
) {
out->lang = values["lang"];
out->text = node->value;
return 0;
}
};
class TextEventParser : public XmlParser<struct TextEventInfo> {
protected:
std::vector<std::string> getRequiredAttributes() {
return std::vector<std::string>{
"character",
"emotion"
};
}
std::map<std::string, std::string> getOptionalAttributes() {
return std::map<std::string, std::string>();
}
int32_t onParse(
Xml *node,
std::map<std::string, std::string> values,
struct TextEventInfo *out,
std::string *error
) {
int32_t ret = 0;
out->character = values["character"];
out->emotion = values["emotion"];
auto itChildren = node->children.begin();
while(itChildren != node->children.end()) {
auto c = *itChildren;
if(c->node == "string") {
struct TextStringInfo str;
ret = (TextStringParser()).parse(c, &str, error);
out->strings.push_back(str);
}
++itChildren;
}
return ret;
}
};
class TextEventGen : public CodeGen {
public:
static void generate(
std::vector<std::string> *out,
struct TextEventInfo *info,
std::string tabs = ""
) {
std::string emo = info->emotion;
emo[0] = toupper(emo[0]);
line(out, "new VisualNovelTextboxEvent(vnManager,", tabs);
line(out, "this->" + info->character + "->vnCharacter, ", tabs + " ");
line(out, "this->" + info->character + "->emotion" + emo + ", ", tabs + " ");
line(out, "\"" + info->key + "\"", tabs + " ");
line(out, ")", tabs);
}
};
}

109
src/dawntools/visualnovel/vnscenegen/parse/events.hpp Normal file
View File

@ -0,0 +1,109 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/XmlParser.hpp"
#include "parse/event/textevent.hpp"
#include "parse/event/characterfadeevent.hpp"
#include "parse/event/pauseevent.hpp"
namespace Dawn {
enum EventType {
EVENT_TYPE_TEXT,
EVENT_TYPE_CHARACTER_FADE,
EVENT_TYPE_PAUSE
};
struct EventsInformation {
std::map<int32_t, enum EventType> eventTypes;
std::map<int32_t, struct TextEventInfo> textEvents;
std::map<int32_t, struct CharacterFadeEventInfo> characterFadeEvents;
std::map<int32_t, struct PauseEventInfo> pauseEvents;
std::vector<std::string> includes;
};
class EventsParser : public XmlParser<struct EventsInformation> {
protected:
std::vector<std::string> getRequiredAttributes() {
return std::vector<std::string>{
};
}
std::map<std::string, std::string> getOptionalAttributes() {
return std::map<std::string, std::string>();
}
int32_t onParse(
Xml *node,
std::map<std::string, std::string> values,
struct EventsInformation *out,
std::string *error
) {
int32_t ret = 0;
int32_t i = 0;
auto itChildren = node->children.begin();
while(itChildren != node->children.end()) {
auto c = *itChildren;
if(c->node == "text") {
struct TextEventInfo textEvent;
ret = (TextEventParser()).parse(c, &textEvent, error);
out->eventTypes[i] = EVENT_TYPE_TEXT;
out->textEvents[i++] = textEvent;
} else if(c->node == "character-fade") {
struct CharacterFadeEventInfo charFadeEvent;
ret = (CharacterFadeParser()).parse(c, &charFadeEvent, error);
out->eventTypes[i] = EVENT_TYPE_CHARACTER_FADE;
out->characterFadeEvents[i++] = charFadeEvent;
out->includes.push_back(charFadeEvent.include);
} else if(c->node == "pause") {
struct PauseEventInfo pauseEvent;
ret = (PauseEventParser()).parse(c, &pauseEvent, error);
out->eventTypes[i] = EVENT_TYPE_PAUSE;
out->pauseEvents[i++] = pauseEvent;
out->includes.push_back(pauseEvent.include);
}
++itChildren;
}
return ret;
}
};
class EventsGen : public CodeGen {
public:
static void generate(
std::vector<std::string> *out,
struct EventsInformation *info,
std::string tabs
) {
auto itEvents = info->eventTypes.begin();
while(itEvents != info->eventTypes.end()) {
auto e = *itEvents;
line(out, "->then(", tabs);
switch(e.second) {
case EVENT_TYPE_TEXT:
TextEventGen::generate(out, &info->textEvents[e.first], tabs + " ");
break;
case EVENT_TYPE_CHARACTER_FADE:
CharacterFadeGen::generate(out, &info->characterFadeEvents[e.first], tabs + " ");
break;
case EVENT_TYPE_PAUSE:
PauseEventGen::generate(out, &info->pauseEvents[e.first], tabs + " ");
break;
}
line(out, ")", tabs);
++itEvents;
}
}
};
}

67
src/dawntools/visualnovel/vnscenegen/parse/header.hpp Normal file
View File

@ -0,0 +1,67 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "parse/include.hpp"
#include "parse/character.hpp"
#include "parse/scene.hpp"
#include "parse/asset.hpp"
namespace Dawn {
struct HeaderInformation {
std::vector<std::string> includes;
std::vector<struct CharacterInformation> characters;
std::vector<struct AssetInformation> assets;
std::map<std::string, std::map<std::string, std::string>> languages;
struct SceneInformation scene;
};
class HeaderParser : public XmlParser<struct HeaderInformation> {
protected:
std::vector<std::string> getRequiredAttributes() {
return std::vector<std::string>();
}
std::map<std::string, std::string> getOptionalAttributes() {
return std::map<std::string, std::string>();
}
int32_t onParse(
Xml *node,
std::map<std::string, std::string> values,
struct HeaderInformation *out,
std::string *error
) {
int32_t ret = 0;
auto itChildren = node->children.begin();
while(itChildren != node->children.end()) {
auto c = *itChildren;
if(c->node == "include") {
ret = (IncludeParser()).parse(c, &out->includes, error);
} else if (c->node == "character") {
struct CharacterInformation character;
ret = (CharacterParser()).parse(c, &character, error);
if(ret != 0) return ret;
out->characters.push_back(character);
} else if(c->node == "asset") {
struct AssetInformation asset;
ret = (AssetParser()).parse(c, &asset, error);
if(ret != 0) return ret;
out->assets.push_back(asset);
} else if(c->node == "scene") {
ret = (SceneParser()).parse(c, &out->scene, error);
}
if(ret != 0) return ret;
++itChildren;
}
return ret;
}
};
}

59
src/dawntools/visualnovel/vnscenegen/parse/include.hpp Normal file
View File

@ -0,0 +1,59 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/XmlParser.hpp"
#include "util/CodeGen.hpp"
namespace Dawn {
typedef std::vector<std::string> include_t;
class IncludeParser : public XmlParser<include_t> {
protected:
std::vector<std::string> getRequiredAttributes() {
return std::vector<std::string>{
"path"
};
}
std::map<std::string, std::string> getOptionalAttributes() {
return std::map<std::string, std::string>();
}
int32_t onParse(
Xml *node,
std::map<std::string, std::string> values,
include_t *out,
std::string *error
) {
if(values["path"].size() == 0) {
*error = "";
return 1;
}
out->push_back(values["path"]);
return 0;
}
};
class IncludeGen : public CodeGen {
public:
static void generate(
std::vector<std::string> *out,
include_t includes,
std::string tabs
) {
std::vector<std::string> generated;
auto it = includes.begin();
while(it != includes.end()) {
if(std::find(generated.begin(), generated.end(), *it) == generated.end()) {
line(out, "#include \"" + *it + "\"", tabs);
generated.push_back(*it);
}
++it;
}
}
};
}

114
src/dawntools/visualnovel/vnscenegen/parse/root.hpp Normal file
View File

@ -0,0 +1,114 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "parse/header.hpp"
#include "parse/events.hpp"
namespace Dawn {
struct RootInformation {
struct HeaderInformation header;
struct EventsInformation events;
};
class RootParser : public XmlParser<struct RootInformation> {
protected:
std::vector<std::string> getRequiredAttributes() {
return std::vector<std::string>();
}
std::map<std::string, std::string> getOptionalAttributes() {
return std::map<std::string, std::string>();
}
int32_t onParse(
Xml *node,
std::map<std::string, std::string> values,
struct RootInformation *out,
std::string *error
) {
int32_t ret = 0;
auto itChildren = node->children.begin();
while(itChildren != node->children.end()) {
auto c = *itChildren;
if(c->node == "head") {
ret = (HeaderParser()).parse(c, &out->header, error);
} else if(c->node == "events") {
ret = (EventsParser()).parse(c, &out->events, error);
}
if(ret != 0) return ret;
++itChildren;
}
return ret;
}
};
class RootGen : public CodeGen {
public:
static void generate(
std::vector<std::string> *out,
struct RootInformation *info,
std::string tabs = ""
) {
struct ClassGenInfo c;
c.clazz = info->header.scene.name;
c.extend = info->header.scene.type;
c.constructorArgs = "DawnGame *game";
c.extendArgs = "game";
struct MethodGenInfo vnStage;
vnStage.name = "vnStage";
vnStage.type = "void";
vnStage.isOverride = true;
line(&vnStage.body, info->header.scene.type+ "::vnStage();", "");
struct MethodGenInfo getAssets;
getAssets.name = "getRequiredAssets";
getAssets.type = "std::vector<Asset*>";
getAssets.isOverride = true;
line(&getAssets.body, "auto man = &this->game->assetManager;", "");
line(&getAssets.body, "auto assets = " + info->header.scene.type + "::getRequiredAssets();", "");
struct MethodGenInfo getVNEvent;
getVNEvent.name = "getVNEvent";
getVNEvent.type = "IVisualNovelEvent *";
getVNEvent.isOverride = true;
line(&getVNEvent.body, "auto start = new VisualNovelPauseEvent(vnManager, 1.0f);", "");
IncludeGen::generate(&c.includes, info->header.includes, "");
IncludeGen::generate(&c.includes, info->events.includes, "");
// Characters
auto itChar = info->header.characters.begin();
while(itChar != info->header.characters.end()) {
CharacterGen::generateProperty(&c.publicProperties, *itChar, "");
CharacterGen::generateInitializer(&vnStage.body, *itChar, "");
CharacterGen::generateAssets(&getAssets.body, *itChar, "");
++itChar;
}
// Events
if(info->events.eventTypes.size() > 0) {
line(&getVNEvent.body, "start", "");
EventsGen::generate(&getVNEvent.body, &info->events, " ");
line(&getVNEvent.body, ";", "");
}
// Wrap up methods
line(&getAssets.body, "return assets;", "");
line(&getVNEvent.body, "return start;", "");
methodGen(&c.publicCode, vnStage);
line(&c.publicCode, "", "");
methodGen(&c.publicCode, getAssets);
methodGen(&c.publicCode, getVNEvent);
classGen(out, c);
}
};
}

40
src/dawntools/visualnovel/vnscenegen/parse/scene.hpp Normal file
View File

@ -0,0 +1,40 @@
// 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 SceneInformation {
std::string type;
std::string name;
};
class SceneParser : public XmlParser<struct SceneInformation> {
protected:
std::vector<std::string> getRequiredAttributes() {
return std::vector<std::string>{
"name",
};
}
std::map<std::string, std::string> getOptionalAttributes() {
return std::map<std::string, std::string>{
{ "type", "SimpleVNScene" }
};
}
int32_t onParse(
Xml *node,
std::map<std::string, std::string> values,
struct SceneInformation *out,
std::string *error
) {
out->name = values["name"];
out->type = values["type"];
return 0;
}
};
}