add first quest

FactoryCraft/AddEntityUpdate.cpp

@@ -1,6 +1,7 @@
 #include "AddEntityUpdate.h"
 
 #include "Dimension.h"
+#include "Entity.h"
 #include "EntityType.h"
 #include "StaticRegistry.h"
 

FactoryCraft/AddEntityUpdate.h

@@ -1,7 +1,8 @@
 #pragma once
-#include "Entity.h"
 #include "WorldUpdate.h"
 
+class Entity;
+
 class AddEntityUpdate : public WorldUpdate
 {
 private:

FactoryCraft/Block.h

@@ -5,7 +5,6 @@
 #include <Vec3.h>
 #include <VecN.h>
 
-#include "BlockType.h"
 #include "Inventory.h"
 #include "Item.h"
 #include "NetworkMessage.h"

FactoryCraft/Dimension.cpp

@@ -1,7 +1,9 @@
 #include "Dimension.h"
 
+#include "ChunkMap.h"
 #include "Constants.h"
 #include "Datei.h"
+#include "DimensionMap.h"
 #include "Game.h"
 #include "NoBlock.h"
 

FactoryCraft/Dimension.h

@@ -3,11 +3,17 @@
 #include <InMemoryBuffer.h>
 #include <Punkt.h>
 #include <Thread.h>
+#include <Trie.h>
+#include <Either.h>
+#include <Critical.h>
 
-#include "Chunk.h"
-#include "DimensionMap.h"
+#include "Constants.h"
 #include "MultiblockStructure.h"
-#include "NetworkMessage.h"
+#include "Chunk.h"
+
+class DimensionMap;
+class NetworkMessage;
+class Block;
 
 class DimensionEnum
 {
@@ -116,17 +122,4 @@ public:
     }
 
     friend DimensionMap;
-};
-
-class DimensionFactory : public virtual Framework::ReferenceCounter
-{
-private:
-    int dimensionId;
-
-public:
-    DimensionFactory(int dimensionId);
-    virtual ~DimensionFactory() = default;
-
-    virtual Dimension* createDimension() = 0;
-    int getDimensionId() const;
 };

FactoryCraft/DimensionGenerator.h

@@ -12,25 +12,6 @@
 
 class DimensionGenerator;
 
-class DimensionGeneratorFactory : public virtual Framework::ReferenceCounter
-{
-private:
-    Framework::Text name;
-    int dimensionId;
-
-public:
-    DimensionGeneratorFactory(Framework::Text name, int dimensionId);
-
-    virtual DimensionGenerator* createDimensionGenerator(
-        int worldSeed, Framework::JSON::JSONValue* config)
-        = 0;
-    virtual Framework::JSON::Validator::JSONValidator* getConfigValidator() = 0;
-    virtual Framework::JSON::JSONValue* getDefaultConfig() = 0;
-
-    Framework::Text getName() const;
-    int getDimensionId() const;
-};
-
 class WorldHeightLayer : public virtual Framework::ReferenceCounter
 {
 private:

FactoryCraft/DimensionMap.cpp

@@ -2,6 +2,7 @@
 
 #include <Datei.h>
 
+#include "ChunkMap.h"
 #include "Game.h"
 
 DimensionMap::DimensionMap(int dimensionId)

FactoryCraft/DimensionMap.h

@@ -4,12 +4,14 @@
 #include <InMemoryBuffer.h>
 #include <ReferenceCounter.h>
 #include <Trie.h>
-
-#include "ChunkMap.h"
+#include <Critical.h>
+#include <Punkt.h>
 
 class Dimension;
 class NetworkMessage;
 class Entity;
+class ChunkMap;
+class Chunk;
 
 class DimensionMap : public Framework::ReferenceCounter
 {

FactoryCraft/Entity.h

@@ -10,6 +10,7 @@
 #include "Inventory.h"
 #include "ItemSkill.h"
 #include "NetworkMessage.h"
+#include "ModelInfo.h"
 
 class EntityType;
 class Dimension;

FactoryCraft/Game.cpp

@@ -294,6 +294,7 @@ Game::Game(Framework::Text name, Framework::Text worldsDir)
       dimensions(new RCArray<Dimension>()),
       updates(new RCArray<WorldUpdate>()),
       clients(new RCArray<GameClient>()),
+      questManager(new QuestManager()),
       ticker(new TickOrganizer()),
       path((const char*)(worldsDir + "/" + name)),
       stop(0),
@@ -343,6 +344,7 @@ void Game::initialize()
     loader = new WorldLoader();
     recipies.loadRecipies("data/recipies");
     chat = new Chat();
+    questManager->loadQuests();
 }
 
 void Game::thread()
@@ -932,6 +934,7 @@ void Game::requestArea(Area area)
 
 void Game::save() const
 {
+    questManager->saveQuests();
     Datei d;
     d.setDatei(path + "/eid");
     d.open(Datei::Style::schreiben);
@@ -1057,6 +1060,11 @@ int Game::getPlayerId(const char* name) const
     return playerRegister->getPlayerId(name);
 }
 
+QuestManager* Game::zQuestManager() const
+{
+    return questManager;
+}
+
 double Game::getAverageTickTime() const
 {
     return averageTickTime;

FactoryCraft/Game.h

@@ -12,6 +12,7 @@
 #include "InMemoryBuffer.h"
 #include "Player.h"
 #include "PlayerRegister.h"
+#include "Quest.h"
 #include "RecipieLoader.h"
 #include "Server.h"
 #include "TickOrganizer.h"
@@ -80,6 +81,7 @@ private:
     Framework::RCArray<WorldUpdate>* updates;
     Framework::RCArray<GameClient>* clients;
     Framework::Array<std::function<void()>> actions;
+    QuestManager* questManager;
     Critical actionsCs;
     TickOrganizer* ticker;
     Framework::Text path;
@@ -149,6 +151,7 @@ public:
     Player* zPlayerByName(const char* name) const;
     TypeRegistry* zTypeRegistry() const;
     int getPlayerId(const char* name) const;
+    QuestManager* zQuestManager() const;
 
     double getAverageTickTime() const;
     int getTicksPerSecond() const;

FactoryCraft/GeneratorRule.h

@@ -43,14 +43,4 @@ public:
             ->whichIsLessOrEqual(1.0)
             ->finishNumber();
     }
-};
-
-class GeneratorRuleFactory : public virtual Framework::ReferenceCounter
-{
-public:
-    GeneratorRuleFactory();
-    virtual GeneratorRule* createRule(
-        Framework::JSON::JSONValue* zConfig, JExpressionMemory* zMemory)
-        = 0;
-    virtual Framework::JSON::Validator::JSONValidator* getValidator() = 0;
 };

FactoryCraft/Inventory.h

@@ -5,14 +5,17 @@
 #include <ImmutablePair.h>
 #include <ReferenceCounter.h>
 #include <Vec3.h>
+#include <Writer.h>
 
 #include "Area.h"
-#include "ItemSlot.h"
 
 class ItemFilter;
 class Inventory;
 class NetworkMessage;
 class Entity;
+class ItemSlot;
+class Item;
+class ItemStack;
 
 class InventoryInteraction
 {

FactoryCraft/Item.cpp

@@ -149,4 +149,51 @@ void Item::applyEquippedEffects(Entity* zTarget) {}
 
 void Item::removeEquippedEffects(Entity* zTarget) {}
 
-void Item::applyFoodEffects(Entity* zTarget) {}
+void Item::applyFoodEffects(Entity* zTarget) {}
+
+ItomJsonType::ItomJsonType()
+    : TypeFactory()
+{}
+
+Item* ItomJsonType::fromJson(Framework::JSON::JSONValue* zJson) const
+{
+    const ItemType* type = ItemType::zByName(
+        zJson->asObject()->zValue("type")->asString()->getString());
+    Item *result = type->createItem();
+    for (auto attribute = zJson->asObject()->getFields(); attribute;
+         attribute++)
+    {
+        if (attribute.val().istGleich("type"))
+			continue;
+        type->setItemAttribute(
+            result, attribute, zJson->asObject()->zValue(attribute));
+    }
+    return result;
+}
+
+Framework::JSON::JSONValue* ItomJsonType::toJson(Item* zObject) const {
+    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
+    result->addValue("type", new Framework::JSON::JSONString(
+		zObject->zItemType()->getName()));
+    zObject->zItemType()->addItemAttributes(zObject, result);
+	return result;
+}
+
+Framework::JSON::Validator::JSONValidator* ItomJsonType::getValidator() const {
+    Framework::RCArray<Framework::Text> itemTypes;
+    for (int index = 0; index < StaticRegistry<ItemType>::INSTANCE.getCount();
+         index++)
+    {
+        if (StaticRegistry<ItemType>::INSTANCE.zElement(index))
+        {
+            itemTypes.add(new Framework::Text(
+                StaticRegistry<ItemType>::INSTANCE.zElement(index)->getName()));
+        }
+    }
+    return Framework::JSON::Validator::JSONValidator::buildForObject()
+        ->withRequiredString("type")
+        ->whichIsOneOf(itemTypes)
+        ->finishString()
+        ->allowAdditionalAttriutes()
+        ->finishObject();
+}

FactoryCraft/Item.h

@@ -2,6 +2,7 @@
 
 #include "ItemType.h"
 #include "Reader.h"
+#include "TypeRegistry.h"
 
 class ItemType;
 class BlockType;
@@ -48,7 +49,8 @@ public:
     float getMaxHp() const;
     const Framework::Text& getName() const;
     virtual bool canBeStackedWith(const Item* zItem) const;
-    virtual bool canBePlacedAt(int dimensionId, Framework::Vec3<int> worldPos) const;
+    virtual bool canBePlacedAt(
+        int dimensionId, Framework::Vec3<int> worldPos) const;
     virtual void onPlaced();
     virtual Framework::Text getTooltipUIML() const;
 
@@ -59,4 +61,14 @@ public:
     virtual void applyFoodEffects(Entity* zTarget);
 
     friend ItemType;
+};
+
+class ItomJsonType : public TypeFactory<Item>
+{
+public:
+    ItomJsonType();
+    Item* fromJson(Framework::JSON::JSONValue* zJson) const override;
+    Framework::JSON::JSONValue* toJson(Item* zObject) const override;
+    Framework::JSON::Validator::JSONValidator*
+    getValidator() const override;
 };

FactoryCraft/ItemFilter.cpp

@@ -2,6 +2,7 @@
 
 #include "Item.h"
 #include "ItemSlot.h"
+#include "ItemStack.h"
 #include "ItemType.h"
 
 ItemFilter::ItemFilter()

FactoryCraft/ItemSlot.cpp

@@ -1,5 +1,7 @@
 #include "ItemSlot.h"
 
+#include "ItemStack.h"
+
 ItemSlot::ItemSlot(Framework::Text name,
     int maxSize,
     int pullPriority,

FactoryCraft/ItemSlot.h

@@ -1,9 +1,11 @@
 #pragma once
 
+#include <Text.h>
+
 #include "Area.h"
-#include "ItemStack.h"
 
 class Inventory;
+class ItemStack;
 
 class ItemSlotIDSetter
 {

FactoryCraft/ItemType.cpp

@@ -155,6 +155,38 @@ const ModelInfo& ItemType::getModel() const
     return model;
 }
 
+void ItemType::setItemAttribute(
+    Item* zItem, Framework::Text name, Framework::JSON::JSONValue* zValue) const
+{
+    if (zValue->getType() == Framework::JSON::JSONType::NUMBER)
+    {
+        if (name.istGleich("hp"))
+            zItem->hp = (float)zValue->asNumber()->getNumber();
+        else if (name.istGleich("maxHp"))
+            zItem->maxHp = (float)zValue->asNumber()->getNumber();
+        else if (name.istGleich("durability"))
+            zItem->durability = (float)zValue->asNumber()->getNumber();
+        else if (name.istGleich("maxDurability"))
+            zItem->maxDurability = (float)zValue->asNumber()->getNumber();
+    }
+    else if (zValue->getType() == Framework::JSON::JSONType::STRING)
+    {
+        if (name.istGleich("name"))
+            zItem->name = zValue->asString()->getString();
+    }
+}
+
+void ItemType::addItemAttributes(
+    Item* zItem, Framework::JSON::JSONObject* zItemObjet) const
+{
+    zItemObjet->addValue("hp", new Framework::JSON::JSONNumber((double)zItem->hp));
+    zItemObjet->addValue("maxHp", new Framework::JSON::JSONNumber((double)zItem->maxHp));
+    zItemObjet->addValue("durability", new Framework::JSON::JSONNumber((double)zItem->durability));
+    zItemObjet->addValue("maxDurability",
+        new Framework::JSON::JSONNumber((double)zItem->maxDurability));
+    zItemObjet->addValue("name", new Framework::JSON::JSONString(zItem->name));
+}
+
 Item* ItemType::createBasicItem(int id,
     const char* name,
     float hp,
@@ -193,4 +225,17 @@ int ItemType::getTypeId(const char* name)
             return StaticRegistry<ItemType>::INSTANCE.zElement(i)->getId();
     }
     return 0;
+}
+
+const ItemType* ItemType::zByName(const char* name)
+{
+    for (int i = 0; i < StaticRegistry<ItemType>::INSTANCE.getCount(); i++)
+    {
+        if (StaticRegistry<ItemType>::INSTANCE.zElement(i)
+            && StaticRegistry<ItemType>::INSTANCE.zElement(i)
+                   ->getName()
+                   .istGleich(name))
+            return StaticRegistry<ItemType>::INSTANCE.zElement(i);
+    }
+    return 0;
 }

FactoryCraft/ItemType.h

@@ -75,6 +75,11 @@ public:
     virtual Item* cloneItem(const Item* zItem) const;
     virtual Item* breakItem(const Item* zItem) const;
     const ModelInfo& getModel() const;
+    virtual void setItemAttribute(Item* zItem,
+        Framework::Text name,
+        Framework::JSON::JSONValue* zValue) const;
+    virtual void addItemAttributes(Item* zItem,
+        Framework::JSON::JSONObject* zItemObjet) const;
 
     static Item* createBasicItem(int id,
         const char* name,
@@ -89,4 +94,5 @@ public:
         bool usable,
         int maxStackSize);
     static int getTypeId(const char* name);
+    static const ItemType* zByName(const char* name);
 };

FactoryCraft/JsonExpression.h

@@ -5,10 +5,12 @@
 #include <JSON.h>
 #include <Text.h>
 #include <Trie.h>
+#include <Critical.h>
 
-#include "Chunk.h"
 #include "Noise.h"
 
+class Chunk;
+
 class JExpressionMemory;
 
 class JExpressionMemory : public virtual Framework::ReferenceCounter

FactoryCraft/MultiblockStructure.h

@@ -1,11 +1,13 @@
 #pragma once
 
+#include <Array.h>
 #include <Punkt.h>
 #include <ReferenceCounter.h>
-
-#include "Block.h"
+#include <Vec3.h>
+#include <Writer.h>
 
 class MultiblockStructureType;
+class Block;
 
 class MultiblockStructureEnum
 {
@@ -63,7 +65,8 @@ protected:
         Framework::StreamWriter* zWriter) const;
     virtual MultiblockStructure* createStructure(int dimensionId,
         __int64 structureId,
-        Framework::Vec3<int> uniquePosition) const = 0;
+        Framework::Vec3<int> uniquePosition) const
+        = 0;
 
 public:
     MultiblockStructure* loadStructure(int dimensionId,

FactoryCraft/MultiblockTree.cpp

@@ -1,5 +1,7 @@
 #include "MultiblockTree.h"
 
+#include "Block.h"
+
 using namespace Framework;
 
 MultiblockTree::MultiblockTree(

FactoryCraft/Player.cpp

@@ -258,6 +258,9 @@ void Player::playerApi(
             *(int*)msg = uiml.getLength();
             memcpy(msg + 4, uiml.getText(), uiml.getLength());
             zResponse->setMessage(msg, msgSize);
+            Game::INSTANCE->zQuestManager()->processEvent(
+                new QuestEventOpenDialog(
+                    dynamic_cast<Entity*>(getThis()), "player_inventory"));
             break;
         }
     case 5:
@@ -362,6 +365,10 @@ void Player::playerApi(
             Game::INSTANCE->sendMessage(msg, this);
             break;
         }
+    case 9: // open quest dialog
+        {
+            // TODO: open quest dialog
+        }
     }
 }
 

FactoryCraft/Quest.cpp

@@ -1,5 +1,7 @@
 #include "Quest.h"
 
+#include "Game.h"
+
 QuestRequirementStorage::QuestRequirementStorage(Framework::Text requirementId)
     : ReferenceCounter(),
       requirementId(requirementId),
@@ -67,7 +69,7 @@ QuestRequirementStorage* QuestRequirementStorageType::fromJson(
     return result;
 }
 
-Framework::JSON::JSONValue* QuestRequirementStorageType::toJSON(
+Framework::JSON::JSONValue* QuestRequirementStorageType::toJson(
     QuestRequirementStorage* zObject) const
 {
     Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
@@ -164,7 +166,7 @@ QuestStorage* QuestStorageType::fromJson(
     return result;
 }
 
-Framework::JSON::JSONValue* QuestStorageType::toJSON(
+Framework::JSON::JSONValue* QuestStorageType::toJson(
     QuestStorage* zObject) const
 {
     Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
@@ -178,7 +180,7 @@ Framework::JSON::JSONValue* QuestStorageType::toJSON(
     for (QuestRequirementStorage* storage : zObject->requirements)
     {
         rewardsArray->addValue(
-            Game::INSTANCE->zTypeRegistry()->toJSON(storage));
+            Game::INSTANCE->zTypeRegistry()->toJson(storage));
     }
     result->addValue("requirements", rewardsArray);
     return result;
@@ -247,7 +249,7 @@ QuestParty* QuestParty::clone() const
     for (QuestStorage* storage : questStorage)
     {
         Framework::JSON::JSONValue* value
-            = Game::INSTANCE->zTypeRegistry()->toJSON(storage);
+            = Game::INSTANCE->zTypeRegistry()->toJson(storage);
         result->questStorage.add(
             Game::INSTANCE->zTypeRegistry()->fromJson<QuestStorage>(value));
         value->release();
@@ -259,8 +261,7 @@ QuestPartyType::QuestPartyType()
     : TypeFactory<QuestParty>()
 {}
 
-QuestParty* QuestPartyType::fromJson(
-    Framework::JSON::JSONValue* zJson) const
+QuestParty* QuestPartyType::fromJson(Framework::JSON::JSONValue* zJson) const
 {
     QuestParty* result = new QuestParty();
     Framework::JSON::JSONArray* membersArray
@@ -281,8 +282,7 @@ QuestParty* QuestPartyType::fromJson(
     return result;
 }
 
-Framework::JSON::JSONValue* QuestPartyType::toJSON(
-    QuestParty* zObject) const
+Framework::JSON::JSONValue* QuestPartyType::toJson(QuestParty* zObject) const
 {
     Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
     Framework::JSON::JSONArray* membersArray = new Framework::JSON::JSONArray();
@@ -296,7 +296,7 @@ Framework::JSON::JSONValue* QuestPartyType::toJSON(
     for (QuestStorage* storage : zObject->questStorage)
     {
         storagesArray->addValue(
-            Game::INSTANCE->zTypeRegistry()->toJSON(storage));
+            Game::INSTANCE->zTypeRegistry()->toJson(storage));
     }
     result->addValue("quests", storagesArray);
     return result;
@@ -359,8 +359,8 @@ void Quest::giveReward(
     {
         return;
     }
-    rewards.z(choice)->giveReward(zTargetEntity);
     zStorage->setQuestRewarded(1);
+    rewards.z(choice)->giveReward(zTargetEntity);
 }
 
 const Framework::Text& Quest::getQuestId() const
@@ -378,6 +378,8 @@ Quest* QuestType::fromJson(Framework::JSON::JSONValue* zJson) const
         zJson->asObject()->zValue("questId")->asString()->getString());
     result->questName
         = zJson->asObject()->zValue("questName")->asString()->getString();
+    result->description
+        = zJson->asObject()->zValue("description")->asString()->getString();
     Framework::JSON::JSONArray* requiredQuestIdsArray
         = zJson->asObject()->zValue("requiredQuestIds")->asArray();
     for (int i = 0; i < requiredQuestIdsArray->getLength(); i++)
@@ -399,18 +401,20 @@ Quest* QuestType::fromJson(Framework::JSON::JSONValue* zJson) const
     {
         result->rewards.add(
             Game::INSTANCE->zTypeRegistry()->fromJson<QuestReward>(
-                requirementsArray->zValue(i)));
+                rewardsArray->zValue(i)));
     }
     return result;
 }
 
-Framework::JSON::JSONValue* QuestType::toJSON(Quest* zObject) const
+Framework::JSON::JSONValue* QuestType::toJson(Quest* zObject) const
 {
     Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
     result->addValue(
         "questId", new Framework::JSON::JSONString(zObject->questId));
     result->addValue(
         "questName", new Framework::JSON::JSONString(zObject->questName));
+    result->addValue(
+        "description", new Framework::JSON::JSONString(zObject->description));
     Framework::JSON::JSONArray* requiredQuestIdsArray
         = new Framework::JSON::JSONArray();
     for (Framework::Text* requiredQuestId : zObject->requiredQuestsIds)
@@ -423,14 +427,16 @@ Framework::JSON::JSONValue* QuestType::toJSON(Quest* zObject) const
         = new Framework::JSON::JSONArray();
     for (QuestRequirement* requirement : zObject->requirements)
     {
-        requirementsArray->addValue(requirement->getAsJSON());
+        requirementsArray->addValue(
+            Game::INSTANCE->zTypeRegistry()->toJson(requirement));
     }
     result->addValue("requirements", requirementsArray);
     Framework::JSON::JSONArray* rewardsArray = new Framework::JSON::JSONArray();
     for (QuestReward* reward : zObject->rewards)
     {
-        rewardsArray->addValue(reward->getAsJSON());
+        rewardsArray->addValue(Game::INSTANCE->zTypeRegistry()->toJson(reward));
     }
+    result->addValue("rewards", rewardsArray);
     return result;
 }
 
@@ -441,7 +447,10 @@ Framework::JSON::Validator::JSONValidator* QuestType::getValidator() const
         ->finishString()
         ->withRequiredString("questName")
         ->finishString()
+        ->withRequiredString("description")
+        ->finishString()
         ->withRequiredArray("requiredQuestIds")
+        ->withDefault(new Framework::JSON::JSONArray())
         ->addAcceptedStringInArray()
         ->finishString()
         ->finishArray()
@@ -527,7 +536,7 @@ QuestCollection* QuestCollectionType::fromJson(
     return result;
 }
 
-Framework::JSON::JSONValue* QuestCollectionType::toJSON(
+Framework::JSON::JSONValue* QuestCollectionType::toJson(
     QuestCollection* zObject) const
 {
     Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
@@ -535,7 +544,7 @@ Framework::JSON::JSONValue* QuestCollectionType::toJSON(
     Framework::JSON::JSONArray* questsArray = new Framework::JSON::JSONArray();
     for (Quest* quest : zObject->quests)
     {
-        questsArray->addValue(Game::INSTANCE->zTypeRegistry()->toJSON(quest));
+        questsArray->addValue(Game::INSTANCE->zTypeRegistry()->toJson(quest));
     }
     result->addValue("quests", questsArray);
     return result;
@@ -660,7 +669,7 @@ void QuestManager::saveQuests()
     for (QuestCollection* questCollection : questCollections)
     {
         questCollectionsArray->addValue(
-            Game::INSTANCE->zTypeRegistry()->toJSON(questCollection));
+            Game::INSTANCE->zTypeRegistry()->toJson(questCollection));
     }
     Datei datei(questDir + "/quests.json");
     if (!datei.existiert()) datei.erstellen();
@@ -672,7 +681,7 @@ void QuestManager::saveQuests()
     Framework::JSON::JSONArray* partiesArray = new Framework::JSON::JSONArray();
     for (QuestParty* party : parties)
     {
-        partiesArray->addValue(Game::INSTANCE->zTypeRegistry()->toJSON(party));
+        partiesArray->addValue(Game::INSTANCE->zTypeRegistry()->toJson(party));
     }
     datei.setDatei(questDir + "/parties.json");
     if (!datei.existiert()) datei.erstellen();
@@ -683,20 +692,21 @@ void QuestManager::saveQuests()
     partiesArray->release();
 }
 
-void QuestManager::processEvent(QuestEvent* zEvent)
+void QuestManager::processEvent(QuestEvent* event)
 {
-    Entity* zEntity = zEvent->zActingEntity();
+    Entity* zEntity = event->zActingEntity();
     for (QuestParty* party : parties)
     {
         if (party->isMember(zEntity->getId()))
         {
             for (QuestCollection* questCollection : questCollections)
             {
-                questCollection->processEvent(zEvent, party);
+                questCollection->processEvent(event, party);
             }
-            return;
+            break;
         }
     }
+    event->release();
 }
 
 void QuestManager::giveReward(

FactoryCraft/Quest.h

@@ -2,7 +2,6 @@
 
 #include <JSON.h>
 
-#include "Game.h"
 #include "QuestEvent.h"
 #include "QuestRequirement.h"
 #include "QuestReward.h"
@@ -38,7 +37,7 @@ public:
     QuestRequirementStorageType();
     QuestRequirementStorage* fromJson(
         Framework::JSON::JSONValue* zJson) const override;
-    Framework::JSON::JSONValue* toJSON(
+    Framework::JSON::JSONValue* toJson(
         QuestRequirementStorage* zObject) const override;
     Framework::JSON::Validator::JSONValidator* getValidator() const override;
 };
@@ -72,7 +71,7 @@ public:
     QuestStorageType();
     QuestStorage* fromJson(
         Framework::JSON::JSONValue* zJson) const override;
-    Framework::JSON::JSONValue* toJSON(
+    Framework::JSON::JSONValue* toJson(
         QuestStorage* zObject) const override;
     Framework::JSON::Validator::JSONValidator* getValidator() const override;
 };
@@ -103,7 +102,7 @@ class QuestPartyType : public TypeFactory<QuestParty>
 public:
     QuestPartyType();
     QuestParty* fromJson(Framework::JSON::JSONValue* zJson) const override;
-    Framework::JSON::JSONValue* toJSON(QuestParty* zObject) const override;
+    Framework::JSON::JSONValue* toJson(QuestParty* zObject) const override;
     Framework::JSON::Validator::JSONValidator* getValidator() const override;
 };
 
@@ -114,6 +113,7 @@ class Quest : public virtual Framework::ReferenceCounter
 private:
     Framework::Text questId;
     Framework::Text questName;
+    Framework::Text description;
     Framework::RCArray<Framework::Text> requiredQuestsIds;
     Framework::RCArray<QuestRequirement> requirements;
     Framework::RCArray<QuestReward> rewards;
@@ -134,7 +134,7 @@ class QuestType : public TypeFactory<Quest>
 public:
     QuestType();
     Quest* fromJson(Framework::JSON::JSONValue* zJson) const override;
-    Framework::JSON::JSONValue* toJSON(Quest* zObject) const override;
+    Framework::JSON::JSONValue* toJson(Quest* zObject) const override;
     Framework::JSON::Validator::JSONValidator* getValidator() const override;
 };
 
@@ -166,7 +166,7 @@ public:
     QuestCollectionType();
     QuestCollection* fromJson(
         Framework::JSON::JSONValue* zJson) const override;
-    Framework::JSON::JSONValue* toJSON(
+    Framework::JSON::JSONValue* toJson(
         QuestCollection* zObject) const override;
     Framework::JSON::Validator::JSONValidator* getValidator() const override;
 };
@@ -183,6 +183,6 @@ public:
     void loadQuests();
     void saveQuests();
 
-    void processEvent(QuestEvent* zEvent);
+    void processEvent(QuestEvent* event);
     void giveReward(Framework::Text questId, int choice, Entity* zTargetEntity);
 };

FactoryCraft/QuestEvent.cpp

@@ -13,4 +13,15 @@ QuestEvent::~QuestEvent()
 Entity* QuestEvent::zActingEntity() const
 {
     return actingEntity;
+}
+
+QuestEventOpenDialog::QuestEventOpenDialog(Entity* actingEntity,
+    	Framework::Text dialogId)
+	: QuestEvent(actingEntity),
+	  dialogId(dialogId)
+{}
+
+const Framework::Text& QuestEventOpenDialog::getDialogId() const
+{
+	return dialogId;
 }

FactoryCraft/QuestEvent.h

@@ -2,7 +2,7 @@
 
 #include "Entity.h"
 
-class QuestEvent: public virtual Framework::ReferenceCounter
+class QuestEvent : public virtual Framework::ReferenceCounter
 {
 private:
     Entity* actingEntity;
@@ -14,32 +14,30 @@ public:
     Entity* zActingEntity() const;
 };
 
-class QuestEventBlockBreak : public QuestEvent
+class QuestEventOpenDialog : public QuestEvent
 {
+private:
+    Framework::Text dialogId;
 
+public:
+    QuestEventOpenDialog(Entity* actingEntity, Framework::Text dialogId);
+    const Framework::Text& getDialogId() const;
 };
 
-class QuestEventBlockPlace : public QuestEvent
-{
+class QuestEventBlockBreak : public QuestEvent
+{};
 
-};
+class QuestEventBlockPlace : public QuestEvent
+{};
 
 class QuestEventBlockInteract : public QuestEvent
-{
-
-};
+{};
 
 class QuestEventTimeUpdate : public QuestEvent
-{
-
-};
+{};
 
 class QuestEventCraft : public QuestEvent
-{
-
-};
+{};
 
 class QuestEventItemPickup : public QuestEvent
-{
-
-};
+{};

FactoryCraft/QuestRequirement.cpp

@@ -1,11 +1,84 @@
 #include "QuestRequirement.h"
 
-QuestRequirement::QuestRequirement(Framework::Text id)
-	: ReferenceCounter(),
-	  id(id)
+#include "Quest.h"
+
+QuestRequirement::QuestRequirement(
+    Framework::Text id, Framework::Text description)
+    : ReferenceCounter(),
+      id(id),
+      description(description)
 {}
 
 const Framework::Text& QuestRequirement::getRequirementId() const
 {
-	return id;
+    return id;
+}
+
+const Framework::Text& QuestRequirement::getDescription() const
+{
+    return description;
+}
+
+QuestRequirementOpenDialog::QuestRequirementOpenDialog(
+    Framework::Text id, Framework::Text description, Framework::Text dialogId)
+    : QuestRequirement(id, description),
+      dialogId(dialogId)
+{}
+
+void QuestRequirementOpenDialog::processEvent(
+    QuestEvent* zEvent, QuestRequirementStorage* zStorage)
+{
+    QuestEventOpenDialog* event = dynamic_cast<QuestEventOpenDialog*>(zEvent);
+    if (event)
+    {
+        if (event->getDialogId() == dialogId)
+        {
+            zStorage->setFullfilled(true);
+        }
+    }
+}
+
+QuestRequirementOpenDialogType::QuestRequirementOpenDialogType()
+    : SubTypeFactory()
+{}
+
+QuestRequirementOpenDialog* QuestRequirementOpenDialogType::fromJson(
+    Framework::JSON::JSONObject* zJson) const
+{
+    return new QuestRequirementOpenDialog(
+        zJson->zValue("id")->asString()->getString(),
+        zJson->zValue("description")->asString()->getString(),
+        zJson->zValue("dialogId")->asString()->getString());
+}
+
+Framework::JSON::JSONObject* QuestRequirementOpenDialogType::toJson(
+    QuestRequirementOpenDialog* zObject) const
+{
+    Framework::JSON::JSONObject* json = new Framework::JSON::JSONObject();
+    json->addValue(
+        "id", new Framework::JSON::JSONString(zObject->getRequirementId()));
+    json->addValue(
+        "description", new Framework::JSON::JSONString(zObject->getDescription()));
+    json->addValue(
+        "dialogId", new Framework::JSON::JSONString(zObject->dialogId));
+    return json;
+}
+
+Framework::JSON::Validator::JSONValidator*
+QuestRequirementOpenDialogType::getValidator(
+    Framework::JSON::Validator::ObjectValidationBuilder<
+        Framework::JSON::Validator::JSONValidator>* builder) const
+{
+    return builder->withRequiredString("id")
+        ->finishString()
+        ->withRequiredString("description")
+        ->finishString()
+        ->withRequiredString("dialogId")
+        ->finishString()
+        ->finishObject();
+}
+
+Framework::Text QuestRequirementOpenDialogType::getTypeToken() const
+{
+    return "open_dialog";
 }

FactoryCraft/QuestRequirement.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "QuestEvent.h"
+#include "TypeRegistry.h"
 
 class QuestRequirementStorage;
 
@@ -8,21 +9,52 @@ class QuestRequirement : public virtual Framework::ReferenceCounter
 {
 private:
     Framework::Text id;
+    Framework::Text description;
 
 public:
-    QuestRequirement(Framework::Text id);
-    virtual bool processEvent(
+    QuestRequirement(Framework::Text id, Framework::Text description);
+    virtual void processEvent(
         QuestEvent* zEvent, QuestRequirementStorage* zStorage)
         = 0;
-    virtual Framework::JSON::JSONObject* getAsJSON() const = 0;
     const Framework::Text& getRequirementId() const;
+    const Framework::Text& getDescription() const;
 };
 
-class QuestRequirementBlockBreak : public QuestRequirement
+class QuestRequirementOpenDialogType;
+
+class QuestRequirementOpenDialog : public QuestRequirement
 {
+private:
+    Framework::Text dialogId;
+
+public:
+    QuestRequirementOpenDialog(Framework::Text id,
+        Framework::Text description,
+        Framework::Text dialogId);
+    void processEvent(
+        QuestEvent* zEvent, QuestRequirementStorage* zStorage) override;
+
+    friend QuestRequirementOpenDialogType;
+};
 
+class QuestRequirementOpenDialogType
+    : public SubTypeFactory<QuestRequirement, QuestRequirementOpenDialog>
+{
+public:
+    QuestRequirementOpenDialogType();
+    QuestRequirementOpenDialog* fromJson(
+        Framework::JSON::JSONObject* zJson) const override;
+    Framework::JSON::JSONObject* toJson(
+        QuestRequirementOpenDialog* zObject) const override;
+    Framework::JSON::Validator::JSONValidator* getValidator(
+        Framework::JSON::Validator::ObjectValidationBuilder<
+            Framework::JSON::Validator::JSONValidator>* builder) const override;
+    Framework::Text getTypeToken() const override;
 };
 
+class QuestRequirementBlockBreak : public QuestRequirement
+{};
+
 class QuestRequirementBlockPlace : public QuestRequirement
 {};
 

FactoryCraft/QuestReward.cpp

@@ -1,11 +1,147 @@
 #include "QuestReward.h"
 
+#include "Entity.h"
+#include "Game.h"
+
 QuestReward::QuestReward(Framework::Text rewardId)
-	: ReferenceCounter(),
-	  rewardId(rewardId)
+    : ReferenceCounter(),
+      rewardId(rewardId)
 {}
 
 const Framework::Text& QuestReward::getRewardId() const
 {
-	return rewardId;
+    return rewardId;
+}
+
+ItemStackInfo::ItemStackInfo(Item* item, int count)
+    : ReferenceCounter(),
+      item(item),
+      count(count)
+{}
+
+ItemStackInfo::~ItemStackInfo()
+{
+    item->release();
+}
+
+Item* ItemStackInfo::zItem() const
+{
+    return item;
+}
+
+int ItemStackInfo::getCount() const
+{
+    return count;
+}
+
+ItemStackInfoType::ItemStackInfoType()
+    : TypeFactory<ItemStackInfo>()
+{}
+
+ItemStackInfo* ItemStackInfoType::fromJson(
+    Framework::JSON::JSONValue* zJson) const
+{
+    return new ItemStackInfo(Game::INSTANCE->zTypeRegistry()->fromJson<Item>(
+                                 zJson->asObject()->zValue("item")),
+        (int)zJson->asObject()->zValue("count")->asNumber()->getNumber());
+}
+
+Framework::JSON::JSONValue* ItemStackInfoType::toJson(
+    ItemStackInfo* zObject) const
+{
+    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
+    result->addValue(
+        "item", Game::INSTANCE->zTypeRegistry()->toJson(zObject->zItem()));
+    result->addValue(
+        "count", new Framework::JSON::JSONNumber((double)zObject->getCount()));
+    return result;
+}
+
+Framework::JSON::Validator::JSONValidator*
+ItemStackInfoType::getValidator() const
+{
+    return Framework::JSON::Validator::JSONValidator::buildForObject()
+        ->withRequiredAttribute(
+            "item", Game::INSTANCE->zTypeRegistry()->getValidator<Item>())
+        ->withRequiredNumber("count")
+        ->withDefault(1.0)
+        ->whichIsGreaterOrEqual(1.0)
+        ->finishNumber()
+        ->finishObject();
+}
+
+QuestRewardGiveItems::QuestRewardGiveItems(Framework::Text rewardId)
+    : QuestReward(rewardId)
+{}
+
+void QuestRewardGiveItems::giveReward(Entity* zTargetEntity)
+{
+    for (ItemStackInfo* info : items)
+    {
+        ItemStack* stack = new ItemStack(
+            dynamic_cast<Item*>(info->zItem()->getThis()), info->getCount());
+        zTargetEntity->unsaveAddItem(stack, Direction::NO_DIRECTION, 0);
+        if (stack->getSize() > 0)
+        {
+            Game::INSTANCE->spawnItem(zTargetEntity->getLocation(),
+                zTargetEntity->getDimensionId(),
+                stack);
+        }
+        else
+        {
+            stack->release();
+        }
+    }
+}
+
+QuestRewardGiveItemsType::QuestRewardGiveItemsType()
+    : SubTypeFactory<QuestReward, QuestRewardGiveItems>()
+{}
+
+QuestRewardGiveItems* QuestRewardGiveItemsType::fromJson(
+    Framework::JSON::JSONObject* zJson) const
+{
+    QuestRewardGiveItems* result = new QuestRewardGiveItems(
+        zJson->zValue("rewardId")->asString()->getString());
+    Framework::JSON::JSONArray* itemsJson = zJson->zValue("items")->asArray();
+    for (Framework::JSON::JSONValue* itemJson : *itemsJson)
+    {
+        result->items.add(
+            Game::INSTANCE->zTypeRegistry()->fromJson<ItemStackInfo>(itemJson));
+    }
+    return result;
+}
+
+Framework::JSON::JSONObject* QuestRewardGiveItemsType::toJson(
+    QuestRewardGiveItems* zObject) const
+{
+    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
+    result->addValue(
+        "rewardId", new Framework::JSON::JSONString(zObject->getRewardId()));
+    Framework::JSON::JSONArray* itemsJson = new Framework::JSON::JSONArray();
+    for (ItemStackInfo* item : zObject->items)
+    {
+        itemsJson->addValue(Game::INSTANCE->zTypeRegistry()->toJson(item));
+    }
+    result->addValue("items", itemsJson);
+    return result;
+}
+
+Framework::JSON::Validator::JSONValidator*
+QuestRewardGiveItemsType::getValidator(
+    Framework::JSON::Validator::ObjectValidationBuilder<
+        Framework::JSON::Validator::JSONValidator>* builder) const
+{
+    return builder->withRequiredString("rewardId")
+        ->finishString()
+        ->withRequiredArray("items")
+        ->addAcceptedTypeInArray(
+            Game::INSTANCE->zTypeRegistry()->getValidator<ItemStackInfo>())
+        ->finishArray()
+        ->finishObject();
+}
+
+Framework::Text QuestRewardGiveItemsType::getTypeToken() const
+{
+    return "give_items";
 }

FactoryCraft/QuestReward.h

@@ -1,22 +1,71 @@
 #pragma once
 
-#include "Entity.h"
+#include "TypeRegistry.h"
+
+class Entity;
+class Item;
 
 class QuestReward : public virtual Framework::ReferenceCounter
 {
 private:
-	Framework::Text rewardId;
+    Framework::Text rewardId;
 
 public:
     QuestReward(Framework::Text rewardId);
 
     virtual void giveReward(Entity* zTargetEntity) = 0;
-    virtual Framework::JSON::JSONObject* getAsJSON() const = 0;
 
     const Framework::Text& getRewardId() const;
 };
 
-class QuestRewardItem : public QuestReward
+class ItemStackInfo : public virtual Framework::ReferenceCounter
+{
+private:
+    Item* item;
+    int count;
+
+public:
+    ItemStackInfo(Item* item, int count);
+    ~ItemStackInfo();
+    Item* zItem() const;
+    int getCount() const;
+};
+
+class ItemStackInfoType : public TypeFactory<ItemStackInfo>
+{
+public:
+    ItemStackInfoType();
+    ItemStackInfo* fromJson(Framework::JSON::JSONValue* zJson) const override;
+    Framework::JSON::JSONValue* toJson(ItemStackInfo* zObject) const override;
+    Framework::JSON::Validator::JSONValidator* getValidator() const override;
+};
+
+class QuestRewardGiveItemsType;
+
+class QuestRewardGiveItems : public QuestReward
 {
+private:
+    Framework::RCArray<ItemStackInfo> items;
+
+public:
+    QuestRewardGiveItems(Framework::Text rewardId);
 
+    void giveReward(Entity* zTargetEntity) override;
+
+    friend QuestRewardGiveItemsType;
+};
+
+class QuestRewardGiveItemsType
+    : public SubTypeFactory<QuestReward, QuestRewardGiveItems>
+{
+public:
+    QuestRewardGiveItemsType();
+    QuestRewardGiveItems* fromJson(
+        Framework::JSON::JSONObject* zJson) const override;
+    Framework::JSON::JSONObject* toJson(
+        QuestRewardGiveItems* zObject) const override;
+    Framework::JSON::Validator::JSONValidator* getValidator(
+        Framework::JSON::Validator::ObjectValidationBuilder<
+            Framework::JSON::Validator::JSONValidator>* builder) const override;
+    Framework::Text getTypeToken() const override;
 };

FactoryCraft/TreeTemplate.cpp

@@ -104,7 +104,7 @@ TreeTemplate* TreeTemplateFactory::fromJson(
             zConfig->asObject()->zValue("maxSize")->asNumber()->getNumber())));
 }
 
-Framework::JSON::JSONObject* TreeTemplateFactory::toJSON(
+Framework::JSON::JSONObject* TreeTemplateFactory::toJson(
     TreeTemplate* zObject) const
 {
     Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();

FactoryCraft/TreeTemplate.h

@@ -31,7 +31,7 @@ class TreeTemplateFactory
 public:
     TreeTemplateFactory();
     TreeTemplate* fromJson(Framework::JSON::JSONObject* zConfig) const override;
-    Framework::JSON::JSONObject* toJSON(TreeTemplate* zObject) const override;
+    Framework::JSON::JSONObject* toJson(TreeTemplate* zObject) const override;
     Framework::JSON::Validator::JSONValidator* getValidator(
         Framework::JSON::Validator::ObjectValidationBuilder<
             Framework::JSON::Validator::JSONValidator>* builder) const override;

FactoryCraft/TypeRegistry.cpp

@@ -1,11 +1,14 @@
 #include "TypeRegistry.h"
 
-#include "BlockTypeGeneratorRule.h"
 #include "BlockInstanceGeneratorRule.h"
-#include "OverworldDimensionGenerator.h"
-#include "TreeTemplate.h"
+#include "BlockTypeGeneratorRule.h"
+#include "Dimension.h"
+#include "DimensionGenerator.h"
+#include "GeneratorRule.h"
 #include "OverworldDimension.h"
+#include "OverworldDimensionGenerator.h"
 #include "Quest.h"
+#include "TreeTemplate.h"
 
 TypeRegistry::TypeRegistry()
     : ReferenceCounter()
@@ -18,15 +21,18 @@ TypeRegistry::TypeRegistry()
     registerGeneratorRuleFactory(new BlockTypeGeneratorRuleFactory());
     registerGeneratorRuleFactory(new BlockInstanceGeneratorRuleFactory());
     // register templates
-    registerSubType<GeneratorTemplate, TreeTemplate>(new TreeTemplateFactory());
+    registerSubType(new TreeTemplateFactory());
 
     // register quest datastructures
-    registerType<QuestRequirementStorage>(
-		new QuestRequirementStorageType());
-    registerType<QuestStorage>(new QuestStorageType());
-    registerType<QuestParty>(new QuestPartyType());
-    registerType<Quest>(new QuestType());
-    registerType<QuestCollection>(new QuestCollectionType());
+    registerType(new QuestRequirementStorageType());
+    registerType(new QuestStorageType());
+    registerType(new QuestPartyType());
+    registerType(new QuestType());
+    registerType(new QuestCollectionType());
+    registerSubType(new QuestRequirementOpenDialogType());
+    registerType(new ItomJsonType());
+    registerType(new ItemStackInfoType());
+    registerSubType(new QuestRewardGiveItemsType());
 }
 
 void TypeRegistry::registerGeneratorRuleFactory(GeneratorRuleFactory* factory)
@@ -117,8 +123,8 @@ Dimension* TypeRegistry::createDimension(int id)
     {
         if (factory->getDimensionId() == id)
         {
-			return factory->createDimension();
-		}
+            return factory->createDimension();
+        }
     }
     return 0;
 }

FactoryCraft/TypeRegistry.h

@@ -1,14 +1,18 @@
 #pragma once
 
+#include <Array.h>
 #include <cstdlib>
 #include <JSON.h>
+#include <Trie.h>
 #include <typeinfo>
 
-#include "Dimension.h"
-#include "DimensionGenerator.h"
-#include "GeneratorRule.h"
-
 class TypeRegistry;
+class GeneratorRuleFactory;
+class GeneratorRule;
+class DimensionGenerator;
+class JExpressionMemory;
+class DimensionFactory;
+class Dimension;
 
 /*
  * Used to convert an object of type T to a JSONValue and vice versa.
@@ -20,7 +24,7 @@ public:
     TypeFactory()
         : ReferenceCounter(){};
     virtual T* fromJson(Framework::JSON::JSONValue* zJson) const = 0;
-    virtual Framework::JSON::JSONValue* toJSON(T* zObject) const = 0;
+    virtual Framework::JSON::JSONValue* toJson(T* zObject) const = 0;
     virtual Framework::JSON::Validator::JSONValidator* getValidator() const = 0;
 };
 
@@ -38,7 +42,7 @@ public:
         : ReferenceCounter(){};
 
     virtual S* fromJson(Framework::JSON::JSONObject* zJson) const = 0;
-    virtual Framework::JSON::JSONObject* toJSON(S* zObject) const = 0;
+    virtual Framework::JSON::JSONObject* toJson(S* zObject) const = 0;
     virtual Framework::JSON::Validator::JSONValidator* getValidator(
         Framework::JSON::Validator::ObjectValidationBuilder<
             Framework::JSON::Validator::JSONValidator>* builder) const
@@ -129,7 +133,7 @@ public:
         return 0;
     }
 
-    Framework::JSON::JSONValue* toJSON(T* zObject) const override
+    Framework::JSON::JSONValue* toJson(T* zObject) const override
     {
         for (SubTypeFactoryRef<T>* factory : factories)
         {
@@ -178,7 +182,7 @@ public:
                 S* value = dynamic_cast<S*>(zObject);
                 if (value)
                 {
-                    return factory->toJSON(value);
+                    return factory->toJson(value);
                 }
                 return (Framework::JSON::JSONObject*)0;
             },
@@ -239,6 +243,48 @@ public:
     }
 };
 
+class GeneratorRuleFactory : public virtual Framework::ReferenceCounter
+{
+public:
+    GeneratorRuleFactory();
+    virtual GeneratorRule* createRule(
+        Framework::JSON::JSONValue* zConfig, JExpressionMemory* zMemory)
+        = 0;
+    virtual Framework::JSON::Validator::JSONValidator* getValidator() = 0;
+};
+
+class DimensionFactory : public virtual Framework::ReferenceCounter
+{
+private:
+    int dimensionId;
+
+public:
+    DimensionFactory(int dimensionId);
+    virtual ~DimensionFactory() = default;
+
+    virtual Dimension* createDimension() = 0;
+    int getDimensionId() const;
+};
+
+class DimensionGeneratorFactory : public virtual Framework::ReferenceCounter
+{
+private:
+    Framework::Text name;
+    int dimensionId;
+
+public:
+    DimensionGeneratorFactory(Framework::Text name, int dimensionId);
+
+    virtual DimensionGenerator* createDimensionGenerator(
+        int worldSeed, Framework::JSON::JSONValue* config)
+        = 0;
+    virtual Framework::JSON::Validator::JSONValidator* getConfigValidator() = 0;
+    virtual Framework::JSON::JSONValue* getDefaultConfig() = 0;
+
+    Framework::Text getName() const;
+    int getDimensionId() const;
+};
+
 class TypeRegistry : public Framework::ReferenceCounter
 {
 private:
@@ -304,7 +350,7 @@ public:
             [factory](Framework::JSON::JSONValue* zJson) {
                 return factory->fromJson(zJson);
             },
-            [factory](void* zObject) { return factory->toJSON((T*)zObject); },
+            [factory](void* zObject) { return factory->toJson((T*)zObject); },
             [factory]() { return factory->getValidator(); },
             factory);
         parsableTypes.set(typeId, typeId.getLength(), typeFactoryRef);
@@ -322,7 +368,7 @@ public:
         return (T*)(typeFactoryRef->fromJson(zJson));
     }
 
-    template<typename T> Framework::JSON::JSONValue* toJSON(T* zObject) const
+    template<typename T> Framework::JSON::JSONValue* toJson(T* zObject) const
     {
         Framework::Text typeId = typeid(T).name();
         TypeFatoryRef* typeFactoryRef

Windows Version/data/quests/quests.json

@@ -0,0 +1,34 @@
+[
+  {
+    "name": "Tutorial",
+    "quests": [
+      {
+        "questId": "tutorial_1",
+        "questName": "Quest Dialog",
+        "description": "Welcome to Factory Craft! This is a tutorial quest to get you started. You have already completed it by opening the quest dialog. Here you can see all current open or completed quests. Completing a quest can make other quests visible. You can view all current quests by clicking on a quest category on the left.",
+        "requirements": [
+          {
+            "id": "1",
+            "description": "Open the quest dialog",
+            "type": "open_dialog",
+            "dialogId": "quests"
+          }
+        ],
+        "rewards": [
+          {
+            "rewardId": "1",
+            "type": "give_items",
+            "items": [
+              {
+                "item": {
+                  "type": "Flint"
+                },
+                "count": 10
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  }
+]