ContentBuildingReader.cpp

#include <iostream>
#include <fstream>
#include <string>

#include "common.h"
#include "GameBuildings.h"
#include "BuildingConfiguration.h"
#include "MiscUtils.h"
#include "TileCondition.h"
#include "tinyxml.h"
#include "GUI.h"
#include "ContentLoader.h"

#include "df/building_def.h"
#include "df/world.h"

using std::string;

int parseConditionNode(ConditionalNode* node, TiXmlElement* elemCondition, bool silent);
bool parseSpriteNode(SpriteNode* node, TiXmlElement* elemParent);
bool includeFile(SpriteNode* node, TiXmlElement* includeNode, SpriteTile* &oldSibling);

namespace {
    bool parseRecursiveNodes(ConditionalNode * pnode, TiXmlElement * pelem)
    {
        TiXmlElement* elemCondition = pelem->FirstChildElement();
        while (elemCondition) {
            if (!parseConditionNode(pnode, elemCondition, false)) {
                return false;
            }
            elemCondition = elemCondition->NextSiblingElement();
        }
        return true;
    }
}

int parseConditionNode(ConditionalNode* node, TiXmlElement* elemCondition, bool silent)
{
    const char* strType = elemCondition->Value();
    std::unique_ptr<TileCondition> cond;
    if( strcmp(strType, "NeighbourWall") == 0) {
        cond = std::make_unique<NeighbourWallCondition>( elemCondition->Attribute("dir") );
    }

    else if( strcmp(strType, "PositionIndex") == 0) {
        cond = std::make_unique<PositionIndexCondition>( elemCondition->Attribute("value") );
    }

    else if( strcmp(strType, "MaterialType") == 0) {
        cond = std::make_unique<MaterialTypeCondition>( elemCondition->Attribute("value") , elemCondition->Attribute("subtype"), elemCondition->Attribute("pattern_index"));
    }

    else if( strcmp(strType, "always") == 0) {
        cond = std::make_unique<AlwaysCondition>();
    }

    else if( strcmp(strType, "never") == 0) {
        cond = std::make_unique<NeverCondition>();
    }

    else if( strcmp(strType, "BuildingOccupancy") == 0) {
        cond = std::make_unique<BuildingOccupancyCondition>( elemCondition->Attribute("value") );
    }

    else if( strcmp(strType, "BuildingSpecial") == 0) {
        cond = std::make_unique<BuildingSpecialCondition>( elemCondition->Attribute("value") );
    }

    else if( strcmp(strType, "NeighbourSameBuilding") == 0) {
        cond = std::make_unique<NeighbourSameBuildingCondition>( elemCondition->Attribute("dir") );
    }

    else if( strcmp(strType, "NeighbourSameType") == 0) {
        cond = std::make_unique<NeighbourSameTypeCondition>( elemCondition->Attribute("dir") );
    }

    else if( strcmp(strType, "NeighbourOfType") == 0) {
        cond = std::make_unique<NeighbourOfTypeCondition>( elemCondition->Attribute("dir") , elemCondition->Attribute("value") );
    }

    else if( strcmp(strType, "NeighbourIdentical") == 0) {
        cond = std::make_unique<NeighbourIdenticalCondition>( elemCondition->Attribute("dir") );
    }

    else if( strcmp(strType, "AnimationFrame") == 0) {
        cond = std::make_unique<AnimationFrameCondition>( elemCondition->Attribute("value") );
    }

    else if( strcmp(strType, "FluidBelow") == 0) {
        cond = std::make_unique<FluidBelowCondition>( elemCondition->Attribute("value") );
    }

    else if( strcmp(strType, "HaveFloor") == 0) {
        cond = std::make_unique<HaveFloorCondition>();
    }

    else if( strcmp(strType, "and") == 0) {
        auto andNode = std::make_unique<AndConditionalNode>();
        if (!parseRecursiveNodes(andNode.get(), elemCondition)) {
            return 0;
        }
        cond = std::move(andNode);
    }

    else if( strcmp(strType, "or") == 0) {
        auto orNode = std::make_unique<OrConditionalNode>();
        if (!parseRecursiveNodes(orNode.get(), elemCondition)) {
            return 0;
        }
        cond = std::move(orNode);
    }

    else if( strcmp(strType, "not") == 0) {
        auto notNode = std::make_unique<NotConditionalNode>();
        if (!parseRecursiveNodes(notNode.get(), elemCondition)) {
            return 0;
        }
        cond = std::move(notNode);
    }

    if (cond != nullptr) {
        if (!node->addCondition( std::move(cond) )) {
            contentError("Unable to add subcondition",elemCondition);
            return 0;
        }
        return 1;
    } else if (!silent) {
        contentError("Misplaced or invalid element in Condition",elemCondition);
        return 0;
    }
    return -1;
}

namespace {
    bool readNode(SpriteNode* node, TiXmlElement* elemNode, TiXmlElement* elemParent, SpriteTile*& oldSibling)
    {
        const char* strType = elemNode->Value();
        if (strcmp(strType, "if") == 0 || strcmp(strType, "else") == 0) {
            if (!elemNode->Attribute("file") && elemParent->Attribute("file")) {
                elemNode->SetAttribute("file", elemParent->Attribute("file"));
            }

            auto tile = std::make_unique<SpriteTile>();
            if (!parseSpriteNode(tile.get(), elemNode)) {
                return false;
            }

            auto tilePtr = tile.get();
            if (elemNode->Attribute("else") || strcmp(strType, "else") == 0) {
                if (!oldSibling) {
                    contentError("Misplaced or invalid element in SpriteNode", elemNode);
                    return false;
                }
                oldSibling->addElse(std::move(tile));
            }
            else {
                node->addChild(std::move(tile));
            }
            oldSibling = tilePtr;
        }
        else if (strcmp(strType, "rotate") == 0) {
            if (!elemNode->Attribute("file") && elemParent->Attribute("file")) {
                elemNode->SetAttribute("file", elemParent->Attribute("file"));
            }

            auto tile = std::make_unique<RotationTile>();
            if (!parseSpriteNode(tile.get(), elemNode)) {
                return false;
            }
            else {
                node->addChild(std::move(tile));
            }
            oldSibling = nullptr;
        }
        else if ((strcmp(strType, "sprite") == 0) || (strcmp(strType, "empty") == 0)) {
            int fileindex = 0;
            const char* pfilename = elemParent->Attribute("file");
            if (pfilename != NULL && pfilename[0] != 0) {
                fileindex = loadConfigImgFile((char*)pfilename, elemNode);
                if (fileindex == -1) {
                    return false;
                }
            }
            auto sprite = std::make_unique<SpriteElement>();
            sprite->sprite.set_by_xml(elemNode, fileindex);
            node->addChild(std::move(sprite));
        }
        else if (strcmp(strType, "include") == 0) {
            if (!includeFile(node, elemNode, oldSibling)) {
                return false;
            }
        }
        else {
            contentError("Misplaced or invalid element in SpriteNode", elemNode);
            return false;
        }
        return true;
    }
}

bool includeFile(SpriteNode* node, TiXmlElement* includeNode, SpriteTile* &oldSibling)
{
    // get path... ugly
    std::filesystem::path documentRef = getDocument(includeNode);

    std::filesystem::path configfilepath = getLocalFilename(includeNode->Attribute("file"), documentRef);
    std::filesystem::path incpath = configfilepath.remove_filename() / "include" / configfilepath.filename();
    TiXmlDocument doc( incpath.string().c_str() );
    bool loadOkay = doc.LoadFile();
    TiXmlHandle hDoc(&doc);
    TiXmlElement* elemParent;
    if(!loadOkay) {
        contentError("Include failed",includeNode);
        LogError("File load failed: %s\n", incpath.string().c_str());
        LogError("Line %d: %s\n",doc.ErrorRow(),doc.ErrorDesc() ? doc.ErrorDesc() : "(null)");
        return false;
    }
    elemParent = hDoc.FirstChildElement("include").Element();
    if( elemParent == nullptr) {
        contentError("Main <include> node not present",&doc);
        return false;
    }
    TiXmlElement* elemNode =  elemParent->FirstChildElement();
    if (elemNode == nullptr) {
        contentError("Empty include",elemParent);
        return false;
    }
    while (elemNode) {
        if (!readNode(node, elemNode, elemParent, oldSibling)) {
            return false;
        }
        elemNode = elemNode->NextSiblingElement();
    }
    return true;
}

bool parseSpriteNode(SpriteNode* node, TiXmlElement* elemParent)
{
    //TODO: there is a leak here somewhere.
    SpriteTile* oldSibling = nullptr;
    TiXmlElement* elemNode =  elemParent->FirstChildElement();
    if (elemNode == nullptr) {
        contentError("Empty SpriteNode Element",elemParent);
        return false;
    }

    const char* strParent = elemParent->Value();
    if ( strcmp(strParent,"building") != 0 && strcmp(strParent,"custom_workshop") != 0 && strcmp(strParent,"rotate") != 0) {
        //flag to allow else statements to be empty, rather than needing an "always" tag
        bool allowBlank = (strcmp(strParent,"else") == 0 || elemParent->Attribute("else"));
        // cast should be safe, because only spritetiles
        // should get here
        int retvalue = parseConditionNode((SpriteTile *)node,elemNode,allowBlank);
        if (retvalue == 0) {
            return false;
        }
        if (retvalue > 0) {
            elemNode = elemNode->NextSiblingElement();
        }
    }
    while (elemNode) {
        if (!readNode(node, elemNode, elemParent, oldSibling)) {
            return false;
        }
        elemNode = elemNode->NextSiblingElement();
    }
    return true;
}

#include "df/siegeengine_type.h"
#include "df/workshop_type.h"
#include "df/trap_type.h"
#include "df/shop_type.h"
#include "df/construction_type.h"
#include "df/furnace_type.h"

bool addSingleBuildingConfig( TiXmlElement* elemRoot,  std::vector<std::unique_ptr<BuildingConfiguration>>*knownBuildings)
{
    using df::building_type;
    const char* strName = elemRoot->Attribute("name");
    const char* strGameID = elemRoot->Attribute("game_type");
    const char* strGameSub = elemRoot->Attribute("game_subtype");
    const char* strGameCustom = elemRoot->Attribute("game_custom");

    if (strName == nullptr || strGameID == nullptr || strName[0] == 0 || strGameID[0] == 0) {
        contentError("<building> node must have name and game_type attributes",elemRoot);
        return false;
    }
    df::building_type main_type = BUILDINGTYPE_NA;
    int subtype = INVALID_INDEX;
    string game_type_s;
    FOR_ENUM_ITEMS(building_type,i) {
        game_type_s = strGameID;
        if (game_type_s == ENUM_KEY_STR(building_type,i)) {
            main_type = i;
            break;
        }
    }
    if(main_type == BUILDINGTYPE_NA) {
        contentError("<building> unknown game_type value",elemRoot);
        return false;
    }

    // get subtype string, if available
    string sub;
    if(strGameSub) {
        sub = strGameSub;
    }

    bool needs_custom = false;

    // process types
    switch (main_type) {
    case building_type::Furnace: {
        if(!strGameSub) {
            contentWarning("<building> Is generic - game_subtype missing.",elemRoot);
            break;
        }
        FOR_ENUM_ITEMS(furnace_type,i) {
            if (sub == ENUM_KEY_STR(furnace_type,i)) {
                subtype = i;
                break;
            }
        }
        if(subtype == INVALID_INDEX) {
            contentError("<building> unknown game_subtype value",elemRoot);
            return false;
        }
        if(subtype == df::furnace_type::Custom) {
            needs_custom = true;
        }
        break;
    }
    case building_type::Construction: {
        if(!strGameSub) {
            contentWarning("<building> Is generic - game_subtype missing.",elemRoot);
            break;
        }
        FOR_ENUM_ITEMS(construction_type,i) {
            if (sub == ENUM_KEY_STR(construction_type,i)) {
                subtype = i;
                break;
            }
        }
        if(subtype == INVALID_INDEX) {
            contentError("<building> unknown game_subtype value",elemRoot);
            return false;
        }
        break;
    }
    case building_type::SiegeEngine: {
        if(!strGameSub) {
            contentWarning("<building> Is generic - game_subtype missing.",elemRoot);
            break;
        }
        FOR_ENUM_ITEMS(siegeengine_type,i) {
            if (sub == ENUM_KEY_STR(siegeengine_type,i)) {
                subtype = i;
                break;
            }
        }
        if(subtype == INVALID_INDEX) {
            contentError("<building> unknown game_subtype value",elemRoot);
            return false;
        }
        break;
    }
    case building_type::Shop: {
        if(!strGameSub) {
            contentWarning("<building> Is generic - game_subtype missing.",elemRoot);
            break;
        }
        FOR_ENUM_ITEMS(shop_type,i) {
            if (sub == ENUM_KEY_STR(shop_type,i)) {
                subtype = i;
                break;
            }
        }
        if(subtype == INVALID_INDEX) {
            contentError("<building> unknown game_subtype value",elemRoot);
            return false;
        }
        break;
    }
    case building_type::Workshop: {
        if(!strGameSub) {
            contentWarning("<building> Is generic - game_subtype missing.",elemRoot);
            break;
        }
        FOR_ENUM_ITEMS(workshop_type,i) {
            if (sub == ENUM_KEY_STR(workshop_type,i)) {
                subtype = i;
                break;
            }
        }
        if(subtype == INVALID_INDEX) {
            contentError("<building> unknown game_subtype value",elemRoot);
            return false;
        }
        if(subtype == df::workshop_type::Custom) {
            needs_custom = true;
        }
        break;
    }
    default: {
        // we need no sub/custom type.
        break;
    }
    }
    int32_t custom = -1;
    // needs custom building spec, doesn't have a string... FAIL
    if (needs_custom && (strGameCustom == 0 || strGameCustom[0] == 0)) {
        contentError("<building> game_custom attribute is required, but missng.",elemRoot);
        return false;
    }
    else if (strGameCustom && strGameCustom[0])
    {
        auto& bld = df::global::world->raws.buildings.all;
        auto it = std::find_if(bld.begin(), bld.end(), [&](auto b) { return b->code == strGameCustom; });
        if (it != bld.end())
            custom = it - bld.begin();
        if (custom == -1)
        {
            contentWarning("<building> game_custom attribute is invalid", elemRoot);
            return false;
        }
    }
    auto building = std::make_unique<BuildingConfiguration>(strName, main_type, subtype, custom );
    auto spriteroot = std::make_unique<RootTile>();
    if (!parseSpriteNode(spriteroot.get(), elemRoot)) {
        contentError("<building> Failed while parsing sprite node",elemRoot);
        return false;
    }
    building->sprites = std::move(spriteroot);

    //add a copy of 'building' to known buildings
    knownBuildings->push_back( std::move(building) );
    return true;
}