FactoryCraft-Server/FactoryCraft/Quest.cpp

#include "Quest.h"

#include <File.h>
#include <Logging.h>

#include "Game.h"
#include "ItemType.h"

QuestRequirementStorage::QuestRequirementStorage()
    : ReferenceCounter(),
      fulfilled(0)
{}

void QuestRequirementStorage::setFullfilled(bool fullfilled)
{
    this->fulfilled = fullfilled;
}

bool QuestRequirementStorage::isFullfilled() const
{
    return fulfilled;
}

void QuestRequirementStorage::setRequirementId(Framework::Text requirementId)
{
    this->requirementId = requirementId;
}

const Framework::Text& QuestRequirementStorage::getRequirementId() const
{
    return requirementId;
}

QuestRequirementStorageType::QuestRequirementStorageType()
    : ObjectTypeFactory<QuestRequirementStorage>()
{}

QuestRequirementStorage* QuestRequirementStorageType::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    QuestRequirementStorage* result = new QuestRequirementStorage();
    result->setRequirementId(
        zJson->asObject()->zValue("requirementId")->asString()->getString());
    result->setFullfilled(
        zJson->asObject()->zValue("fulfilled")->asBool()->getBool());
    return result;
}

Framework::JSON::JSONObject* QuestRequirementStorageType::toJsonObject(
    QuestRequirementStorage* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    result->addValue("requirementId",
        new Framework::JSON::JSONString(zObject->getRequirementId()));
    result->addValue(
        "fulfilled", new Framework::JSON::JSONBool(zObject->isFullfilled()));
    return result;
}

JSONObjectValidationBuilder* QuestRequirementStorageType::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredString("requirementId")
        ->finishString()
        ->withRequiredBool("fulfilled")
        ->withDefault(false)
        ->finishBool();
}

QuestStorage::QuestStorage()
    : finished(0),
      rewarded(0),
      data(new Framework::JSON::JSONObject())
{}

QuestStorage::~QuestStorage()
{
    data->release();
}

void QuestStorage::setQuestFinished(bool finished)
{
    this->finished = finished;
}

void QuestStorage::setQuestRewarded(bool rewarded)
{
    this->rewarded = rewarded;
}

bool QuestStorage::isQuestFinished() const
{
    return finished;
}

bool QuestStorage::isQuestRewarded() const
{
    return rewarded;
}

QuestRequirementStorage* QuestStorage::zStorage(Framework::Text requirementId)
{
    for (QuestRequirementStorage* storage : requirements)
    {
        if (storage->getRequirementId().isEqual(requirementId))
        {
            return storage;
        }
    }
    QuestRequirementStorage* result = new QuestRequirementStorage();
    result->setRequirementId(requirementId);
    requirements.add(result);
    return result;
}

void QuestStorage::setQuestId(Framework::Text questId)
{
    this->questId = questId;
}

const Framework::Text& QuestStorage::getQuestId() const
{
    return questId;
}

bool QuestStorage::isVisible() const
{
    return visible;
}

void QuestStorage::setVisible(bool visible)
{
    this->visible = visible;
}

void QuestStorage::putValue(
    Framework::Text key, Framework::JSON::JSONValue* value)
{
    data->removeValue(key);
    data->addValue(key, value);
}

Framework::JSON::JSONValue* QuestStorage::getValue(Framework::Text key) const
{
    return data->getValue(key);
}

Framework::JSON::JSONValue* QuestStorage::zValue(Framework::Text key) const
{
    return data->zValue(key);
}

bool QuestStorage::containsKey(Framework::Text key) const
{
    return data->hasValue(key);
}

QuestStorageType::QuestStorageType()
    : ObjectTypeFactory<QuestStorage>()
{}

QuestStorage* QuestStorageType::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    QuestStorage* result = new QuestStorage();
    result->setQuestId(
        zJson->asObject()->zValue("questId")->asString()->getString());
    result->setQuestFinished(
        zJson->asObject()->zValue("finished")->asBool()->getBool());
    result->setQuestRewarded(
        zJson->asObject()->zValue("rewarded")->asBool()->getBool());
    Framework::JSON::JSONArray* rewardsArray
        = zJson->asObject()->zValue("requirements")->asArray();
    for (int i = 0; i < rewardsArray->getLength(); i++)
    {
        result->requirements.add(
            Game::INSTANCE->zTypeRegistry()->fromJson<QuestRequirementStorage>(
                rewardsArray->zValue(i)->asObject()));
    }
    result->data->release();
    result->data = zJson->asObject()->getValue("data")->asObject();
    return result;
}

Framework::JSON::JSONObject* QuestStorageType::toJsonObject(
    QuestStorage* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    result->addValue(
        "questId", new Framework::JSON::JSONString(zObject->questId));
    result->addValue(
        "finished", new Framework::JSON::JSONBool(zObject->finished));
    result->addValue(
        "rewarded", new Framework::JSON::JSONBool(zObject->rewarded));
    Framework::JSON::JSONArray* rewardsArray = new Framework::JSON::JSONArray();
    for (QuestRequirementStorage* storage : zObject->requirements)
    {
        rewardsArray->addValue(
            Game::INSTANCE->zTypeRegistry()->toJson(storage));
    }
    result->addValue("requirements", rewardsArray);
    Framework::Text dataString = zObject->data->toString();
    result->addValue("data", Framework::JSON::Parser::getValue(dataString));
    return result;
}

JSONObjectValidationBuilder* QuestStorageType::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredString("questId")
        ->finishString()
        ->withRequiredBool("finished")
        ->withDefault(false)
        ->finishBool()
        ->withRequiredBool("rewarded")
        ->withDefault(false)
        ->finishBool()
        ->withRequiredArray("requirements")
        ->addAcceptedTypeInArray(Game::INSTANCE->zTypeRegistry()
                ->getValidator<QuestRequirementStorage>())
        ->finishArray()
        ->withRequiredObject("data")
        ->allowAdditionalAttriutes()
        ->finishObject();
}

QuestParty::QuestParty()
    : ReferenceCounter()
{}

void QuestParty::addMember(int memberEntityId)
{
    memberEntityIds.add(memberEntityId);
}

void QuestParty::removeMember(int memberEntityId)
{
    memberEntityIds.removeValue(memberEntityId);
}

bool QuestParty::isMember(int memberEntityId) const
{
    return memberEntityIds.has(memberEntityId);
}

bool QuestParty::isEmpty() const
{
    return memberEntityIds.getEntryCount() == 0;
}

QuestStorage* QuestParty::zQuestStorage(Framework::Text questId)
{
    for (QuestStorage* storage : questStorage)
    {
        if (storage->getQuestId().isEqual(questId))
        {
            return storage;
        }
    }
    QuestStorage* result = new QuestStorage();
    result->setQuestId(questId);
    questStorage.add(result);
    return result;
}

QuestParty* QuestParty::clone() const
{
    QuestParty* result = new QuestParty();
    for (QuestStorage* storage : questStorage)
    {
        Framework::JSON::JSONValue* value
            = Game::INSTANCE->zTypeRegistry()->toJson(storage);
        result->questStorage.add(
            Game::INSTANCE->zTypeRegistry()->fromJson<QuestStorage>(value));
        value->release();
    }
    return result;
}

QuestPartyType::QuestPartyType()
    : ObjectTypeFactory<QuestParty>()
{}

QuestParty* QuestPartyType::fromJson(Framework::JSON::JSONObject* zJson) const
{
    QuestParty* result = new QuestParty();
    Framework::JSON::JSONArray* membersArray
        = zJson->asObject()->zValue("members")->asArray();
    for (int i = 0; i < membersArray->getLength(); i++)
    {
        result->memberEntityIds.add(
            (int)membersArray->zValue(i)->asNumber()->getNumber());
    }
    Framework::JSON::JSONArray* storagesArray
        = zJson->asObject()->zValue("quests")->asArray();
    for (int i = 0; i < storagesArray->getLength(); i++)
    {
        result->questStorage.add(
            Game::INSTANCE->zTypeRegistry()->fromJson<QuestStorage>(
                storagesArray->zValue(i)->asObject()));
    }
    return result;
}

Framework::JSON::JSONObject* QuestPartyType::toJsonObject(
    QuestParty* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    Framework::JSON::JSONArray* membersArray = new Framework::JSON::JSONArray();
    for (int memberEntityId : zObject->memberEntityIds)
    {
        membersArray->addValue(new Framework::JSON::JSONNumber(memberEntityId));
    }
    result->addValue("members", membersArray);
    Framework::JSON::JSONArray* storagesArray
        = new Framework::JSON::JSONArray();
    for (QuestStorage* storage : zObject->questStorage)
    {
        storagesArray->addValue(
            Game::INSTANCE->zTypeRegistry()->toJson(storage));
    }
    result->addValue("quests", storagesArray);
    return result;
}

JSONObjectValidationBuilder* QuestPartyType::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredArray("members")
        ->addAcceptedNumberInArray()
        ->finishNumber()
        ->removeInvalidEntries()
        ->finishArray()
        ->withRequiredArray("quests")
        ->addAcceptedTypeInArray(
            Game::INSTANCE->zTypeRegistry()->getValidator<QuestStorage>())
        ->removeInvalidEntries()
        ->finishArray();
}

Quest::Quest()
    : ReferenceCounter(),
      mainQuest(0)
{}

void Quest::processEvent(QuestEvent* zEvent, QuestStorage* zStorage)
{
    bool finished = 1;
    for (QuestRequirement* requirement : requirements)
    {
        QuestRequirementStorage* zRequirementStorage
            = zStorage->zStorage(requirement->getRequirementId());
        if (!zRequirementStorage->isFullfilled())
        {
            requirement->processEvent(zEvent, zStorage);
            finished &= zRequirementStorage->isFullfilled();
        }
    }
    if (finished)
    {
        zStorage->setQuestFinished(1);
    }
}

bool Quest::isVisible(QuestParty* zParty, QuestManager* zManager)
{
    if (zParty->zQuestStorage(questId)->isVisible())
    {
        return 1;
    }
    bool visible = requiredQuestsIds.getEntryCount() == 0;
    for (Framework::Text* requiredQuestId : requiredQuestsIds)
    {
        visible |= zParty->zQuestStorage(*requiredQuestId)->isQuestFinished();
    }
    if (visible)
    {
        zParty->zQuestStorage(questId)->setVisible(visible);
    }
    for (Framework::Text* requiredQuestId : requiredQuestsIds)
    {
        zManager->setQuestVisible(true, *requiredQuestId, zParty);
    }
    return visible;
}

bool Quest::isActive(QuestParty* zParty)
{
    bool active = 0;
    auto requiredQuestsIdsI = requiredQuestsGroups.begin();
    int last = 0;
    bool tmp = 1;
    bool first = 1;
    for (Framework::Text* requiredQuestId : requiredQuestsIds)
    {
        tmp &= zParty->zQuestStorage(*requiredQuestId)->isQuestFinished();
        first = 0;
        if (last != *requiredQuestsIdsI)
        {
            active |= tmp;
            tmp = 1;
            first = 1;
            if (active)
            {
                break;
            }
        }
        last = requiredQuestsIdsI.val();
        requiredQuestsIdsI++;
    }
    if (!first || requiredQuestsIds.getEntryCount() == 0)
    {
        active |= tmp;
    }
    return active;
}

void Quest::setQuestId(Framework::Text questId)
{
    this->questId = questId;
}

const Framework::Text& Quest::getQuestId() const
{
    return questId;
}

void Quest::setVisible(bool visible, QuestParty* zParty, QuestManager* zManager)
{
    if (zParty->zQuestStorage(questId)->isVisible() == visible)
    {
        return;
    }
    zParty->zQuestStorage(questId)->setVisible(visible);
    if (visible)
    {
        for (Framework::Text* requiredQuestId : requiredQuestsIds)
        {
            zManager->setQuestVisible(visible, *requiredQuestId, zParty);
        }
    }
}

QuestType::QuestType()
    : ObjectTypeFactory<Quest>()
{}

Quest* QuestType::fromJson(Framework::JSON::JSONObject* zJson) const
{
    Quest* result = new Quest();
    result->setQuestId(
        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* requiredQuestGroups
        = zJson->asObject()->zValue("requiredQuestIds")->asArray();
    for (int i = 0; i < requiredQuestGroups->getLength(); i++)
    {
        Framework::JSON::JSONArray* requiredQuestIdsArray
            = requiredQuestGroups->zValue(i)->asArray();
        for (int j = 0; j < requiredQuestIdsArray->getLength(); j++)
        {
            result->requiredQuestsIds.add(new Framework::Text(
                requiredQuestIdsArray->zValue(j)->asString()->getString()));
            result->requiredQuestsGroups.add(i);
        }
    }
    Framework::JSON::JSONArray* requirementsArray
        = zJson->asObject()->zValue("requirements")->asArray();
    for (int i = 0; i < requirementsArray->getLength(); i++)
    {
        result->requirements.add(
            Game::INSTANCE->zTypeRegistry()->fromJson<QuestRequirement>(
                requirementsArray->zValue(i)));
    }
    Framework::JSON::JSONArray* rewardsArray
        = zJson->asObject()->zValue("rewards")->asArray();
    for (int i = 0; i < rewardsArray->getLength(); i++)
    {
        result->rewards.add(
            Game::INSTANCE->zTypeRegistry()->fromJson<QuestReward>(
                rewardsArray->zValue(i)));
    }
    if (zJson->asObject()->hasValue("imagePath"))
    {
        result->imagePath
            = zJson->asObject()->zValue("imagePath")->asString()->getString();
    }
    else if (zJson->asObject()->hasValue("imageItemType"))
    {
        result->imagePath = Framework::Text("itemType:")
                          + zJson->asObject()
                                ->zValue("imageItemType")
                                ->asString()
                                ->getString();
    }
    else
    {
        result->imagePath
            = Framework::Text("itemType:")
            + Game::INSTANCE->zItemType(ItemTypeEnum::PLAYER_HAND)->getName();
    }
    result->mainQuest
        = zJson->asObject()->zValue("mainQuest")->asBool()->getBool();
    return result;
}

Framework::JSON::JSONObject* QuestType::toJsonObject(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* requiredQuestGroupArray
        = new Framework::JSON::JSONArray();
    Framework::JSON::JSONArray* requiredQuestIdsArray
        = new Framework::JSON::JSONArray();
    int index = 0;
    int lastGroup = 0;
    for (Framework::Text* requiredQuestId : zObject->requiredQuestsIds)
    {
        int group = zObject->requiredQuestsGroups.get(index);
        if (lastGroup != group)
        {
            if (requiredQuestIdsArray->getLength())
            {
                requiredQuestGroupArray->addValue(requiredQuestIdsArray);
                requiredQuestIdsArray = new Framework::JSON::JSONArray();
            }
            lastGroup = group;
        }
        requiredQuestIdsArray->addValue(
            new Framework::JSON::JSONString(*requiredQuestId));
        index++;
    }
    if (requiredQuestIdsArray->getLength())
    {
        requiredQuestGroupArray->addValue(requiredQuestIdsArray);
    }
    else
    {
        requiredQuestIdsArray->release();
    }
    result->addValue("requiredQuestIds", requiredQuestGroupArray);
    Framework::JSON::JSONArray* requirementsArray
        = new Framework::JSON::JSONArray();
    for (QuestRequirement* requirement : zObject->requirements)
    {
        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(Game::INSTANCE->zTypeRegistry()->toJson(reward));
    }
    result->addValue("rewards", rewardsArray);
    if (zObject->imagePath.beginnsWith("itemType:"))
    {
        Framework::Text* itemTypeName = zObject->imagePath.getTeilText(9);
        result->addValue(
            "imageItemType", new Framework::JSON::JSONString(*itemTypeName));
        itemTypeName->release();
    }
    else
    {
        result->addValue(
            "imagePath", new Framework::JSON::JSONString(zObject->imagePath));
    }
    result->addValue(
        "mainQuest", new Framework::JSON::JSONBool(zObject->mainQuest));
    return result;
}

JSONObjectValidationBuilder* QuestType::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredString("questId")
        ->finishString()
        ->withRequiredString("questName")
        ->finishString()
        ->withRequiredString("description")
        ->finishString()
        ->withRequiredArray("requiredQuestIds")
        ->addAcceptedArrayInArray()
        ->addAcceptedStringInArray()
        ->finishString()
        ->finishArray()
        ->withDefault(new Framework::JSON::JSONArray())
        ->finishArray()
        ->withRequiredArray("requirements")
        ->addAcceptedTypeInArray(
            Game::INSTANCE->zTypeRegistry()->getValidator<QuestRequirement>())
        ->finishArray()
        ->withRequiredArray("rewards")
        ->addAcceptedTypeInArray(
            Game::INSTANCE->zTypeRegistry()->getValidator<QuestReward>())
        ->finishArray()
        ->withOptionalString("imagePath")
        ->finishString()
        ->withRequiredAttribute("imageItemType",
            Game::INSTANCE->zTypeRegistry()->getValidator<Framework::Text>(
                ItemTypeNameFactory::TYPE_ID),
            0,
            1)
        ->withRequiredBool("mainQuest")
        ->withDefault(false)
        ->finishBool();
}

QuestCollection::QuestCollection()
    : ReferenceCounter()
{}

void QuestCollection::processEvent(QuestEvent* zEvent, QuestParty* zParty)
{
    for (Quest* quest : quests)
    {
        QuestStorage* zStorage = zParty->zQuestStorage(quest->getQuestId());
        if (quest->isActive(zParty) && !zStorage->isQuestFinished())
        {
            quest->processEvent(zEvent, zStorage);
        }
    }
}

bool QuestCollection::isVisible(QuestParty* zParty, QuestManager* zManager)
{
    bool visible = 0;
    for (Quest* quest : quests)
    {
        visible |= quest->isVisible(zParty, zManager);
    }
    return visible;
}

void QuestCollection::addQuest(Quest* zQuest)
{
    quests.add(zQuest);
}

void QuestCollection::setName(Framework::Text name)
{
    this->name = name;
}

const Framework::Text& QuestCollection::getName() const
{
    return name;
}

void QuestCollection::setQuestVisible(bool visible,
    Framework::Text questId,
    QuestParty* zParty,
    QuestManager* zManager)
{
    for (Quest* quest : quests)
    {
        if (quest->getQuestId().isEqual(questId))
        {
            return quest->setVisible(visible, zParty, zManager);
        }
    }
}

QuestCollectionType::QuestCollectionType()
    : ObjectTypeFactory<QuestCollection>()
{}

QuestCollection* QuestCollectionType::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    QuestCollection* result = new QuestCollection();
    result->setName(zJson->asObject()->zValue("name")->asString()->getString());
    Framework::JSON::JSONArray* questsArray
        = zJson->asObject()->zValue("quests")->asArray();
    for (int i = 0; i < questsArray->getLength(); i++)
    {
        result->quests.add(Game::INSTANCE->zTypeRegistry()->fromJson<Quest>(
            questsArray->zValue(i)->asObject()));
    }
    return result;
}

Framework::JSON::JSONObject* QuestCollectionType::toJsonObject(
    QuestCollection* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    result->addValue("name", new Framework::JSON::JSONString(zObject->name));
    Framework::JSON::JSONArray* questsArray = new Framework::JSON::JSONArray();
    for (Quest* quest : zObject->quests)
    {
        questsArray->addValue(Game::INSTANCE->zTypeRegistry()->toJson(quest));
    }
    result->addValue("quests", questsArray);
    return result;
}

JSONObjectValidationBuilder* QuestCollectionType::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredString("name")
        ->finishString()
        ->withRequiredArray("quests")
        ->addAcceptedTypeInArray(
            Game::INSTANCE->zTypeRegistry()->getValidator<Quest>())
        ->removeInvalidEntries()
        ->finishArray();
}

QuestManager::QuestManager()
    : ReferenceCounter()
{}

QuestParty* QuestManager::zParty(int entityId)
{
    for (QuestParty* party : parties)
    {
        if (party->isMember(entityId))
        {
            return party;
        }
    }
    QuestParty* result = new QuestParty();
    result->addMember(entityId);
    parties.add(result);
    return result;
}

QuestCollection* QuestManager::zCollection(int index)
{
    return questCollections.z(index);
}

void QuestManager::loadQuests()
{
    Framework::Text worldDir = Game::INSTANCE->getWorldDirectory();
    Framework::Text questDir = worldDir + "/quests";
    if (!Framework::FileExists(questDir))
    {
        Framework::Logging::info()
            << "no quest data found in world save, using default data";
        questDir = "data/quests";
    }
    Framework::JSON::JSONValue* value
        = Framework::JSON::loadJSONFromFile(questDir + "/quests.json");
    if (!value || value->getType() == Framework::AbstractType::NULL_)
    {
        Framework::Logging::warning()
            << "No valid quests.json found in " << questDir;
        if (value)
        {
            value->release();
        }
    }
    else
    {
        Framework::Logging::info() << "loading quests ...";
        Framework::Validator::DataValidator* validator
            = Framework::Validator::DataValidator::buildForArray()
                  ->addAcceptedTypeInArray(Game::INSTANCE->zTypeRegistry()
                          ->getValidator<QuestCollection>())
                  ->removeInvalidEntries()
                  ->finishArray();
        Framework::RCArray<Framework::Validator::ValidationResult>
            validationResult;
        Framework::JSON::JSONArray* valid
            = validator->getValidParts(value, &validationResult)->asArray();
        for (Framework::Validator::ValidationResult* invalidPart :
            validationResult)
        {
            Framework::Logging::error() << invalidPart->getInvalidInfo();
        }
        value->release();
        for (Framework::JSON::JSONValue* validPart : *valid)
        {
            questCollections.add(
                Game::INSTANCE->zTypeRegistry()->fromJson<QuestCollection>(
                    validPart->asObject()));
        }
        valid->release();
        Framework::JSON::JSONObject* schema = validator->getJsonSchema();
        Framework::File syntaxFile;
        syntaxFile.setFile("data/syntax/schema/quests.json");
        syntaxFile.create();
        syntaxFile.open(Framework::File::Style::write);
        syntaxFile.write(schema->toString(), schema->toString().getLength());
        syntaxFile.close();
        schema->release();
        validator->release();
    }
    value = Framework::JSON::loadJSONFromFile(questDir + "/parties.json");
    if (!value || value->getType() == Framework::AbstractType::NULL_)
    {
        if (value)
        {
            value->release();
        }
    }
    else
    {
        Framework::Logging::info() << "loading quest parties ...";
        Framework::Validator::DataValidator* validator
            = Framework::Validator::DataValidator::buildForArray()
                  ->addAcceptedTypeInArray(Game::INSTANCE->zTypeRegistry()
                          ->getValidator<QuestParty>())
                  ->removeInvalidEntries()
                  ->finishArray();
        Framework::RCArray<Framework::Validator::ValidationResult>
            validationResult;
        Framework::JSON::JSONArray* valid
            = validator->getValidParts(value, &validationResult)->asArray();
        for (Framework::Validator::ValidationResult* invalidPart :
            validationResult)
        {
            Framework::Logging::error() << invalidPart->getInvalidInfo();
        }
        value->release();
        for (Framework::JSON::JSONValue* validPart : *valid)
        {
            parties.add(Game::INSTANCE->zTypeRegistry()->fromJson<QuestParty>(
                validPart->asObject()));
        }
        valid->release();
        validator->release();
    }
    Framework::Logging::info()
        << "Loaded " << questCollections.getEntryCount()
        << " Quest Collections and " << parties.getEntryCount()
        << " Quest Parties";
}

void QuestManager::saveQuests()
{
    Framework::Text worldDir = Game::INSTANCE->getWorldDirectory();
    Framework::Text questDir = worldDir + "/quests";
    if (!Framework::FileExists(questDir))
    {
        Framework::FilePathCreate(questDir + "/");
    }
    Framework::JSON::JSONArray* questCollectionsArray
        = new Framework::JSON::JSONArray();
    for (QuestCollection* questCollection : questCollections)
    {
        questCollectionsArray->addValue(
            Game::INSTANCE->zTypeRegistry()->toJson(questCollection));
    }
    Framework::File File(questDir + "/quests.json");
    if (!File.exists()) File.create();
    File.open(Framework::File::Style::write);
    Framework::Text jsonStr = questCollectionsArray->toString();
    File.write(jsonStr.getText(), jsonStr.getLength());
    File.close();
    questCollectionsArray->release();
    Framework::JSON::JSONArray* partiesArray = new Framework::JSON::JSONArray();
    for (QuestParty* party : parties)
    {
        partiesArray->addValue(Game::INSTANCE->zTypeRegistry()->toJson(party));
    }
    File.setFile(questDir + "/parties.json");
    if (!File.exists()) File.create();
    File.open(Framework::File::Style::write);
    jsonStr = partiesArray->toString();
    File.write(jsonStr.getText(), jsonStr.getLength());
    File.close();
    partiesArray->release();
}

void QuestManager::processEvent(QuestEvent* event)
{
    if (!event->zActingEntity())
    {
        for (QuestParty* party : parties)
        {
            for (QuestCollection* questCollection : questCollections)
            {
                questCollection->processEvent(event, party);
            }
        }
    }
    else
    {
        QuestParty* party = zParty(event->zActingEntity()->getId());
        if (party)
        {
            for (QuestCollection* questCollection : questCollections)
            {
                questCollection->processEvent(event, party);
            }
        }
    }
    event->release();
}

void QuestManager::setQuestVisible(
    bool visible, Framework::Text questId, QuestParty* zParty)
{
    for (QuestCollection* questCollection : questCollections)
    {
        questCollection->setQuestVisible(visible, questId, zParty, this);
    }
}